huffman树即Huffma编码的实现

自己写的Huffman树生成与Huffman编码实现 （实现了核心功能 ，打出了每个字符的huffman编码 其他的懒得实现了，有兴趣的朋友可以自己在我的基础增加功能 ）

/* 原创文章 转载请附上原链接: https://www.cnblogs.com/jiujue/p/10325699.html  */

### 硬核警告 递归 玩的可以在往下看 核心是递归实现 ￥_￥

上图：

上代码：（思路：通过递归将父亲的Huffman编码传给给孩子 孩子以此为基础进行在编码 ）

1.头文件:(myHuffmanHead.h)

 #pragma once

 #pragma warning(disable :4996)
 #include<stdio.h>
 #include<stdlib.h>
 #include<string.h>

 /*
     huffmanTree : 思路
      注：每个关键字为一个节点 整个数据使用链表存储
         节点内容 : 关键字 ，出现次数 ，编码 ， 下一个节点。 

         将 关键字的出现频率作为权值来生成HuffmanTree 然后进行Huffman code
             //1.获取关键字频率
                 1.1 获取输入 并 记录 关键字 出现次数

             2.生成HuffmanTree

             3.根据huffmanTree 进行HuffmanCode 并打印每个关键字的  Huffman编码
                     tips : 左 0 ; 右 1
 */

 typedef struct nodehuffmantree {

     char key;
     int frequency;

     char *code;

     int isCoded;

     struct nodehuffmantree * next;
     struct nodehuffmantree *lchild, *rchild;

 }nodeHuffmanTree_t;

 int myStrCat(char *des, char *str);

 int changeCode(char *strParent, char *strKid, char needAppend, char *tempspace);

 int linkCode(nodeHuffmanTree_t *headLinkList, char *input);

 int printLinkList(nodeHuffmanTree_t *head);

 int makeBranch(nodeHuffmanTree_t **spaceSave, int spaceSize, int t1, int t2);

 nodeHuffmanTree_t* isExitence(nodeHuffmanTree_t* head, char inputTemp);

 int creatHuffmanTree(nodeHuffmanTree_t *headLinkList, nodeHuffmanTree_t **headhuffmanTree);

 nodeHuffmanTree_t ** getSpaceSave(nodeHuffmanTree_t *headLinkList);

 int huffmanCode(nodeHuffmanTree_t *headLinkList, nodeHuffmanTree_t *headhuffmanTree);

2主函数入口：（source_1.c）

 #include"myHuffmanHead.h"

 int main()
 {

     nodeHuffmanTree_t *head = NULL;
     nodeHuffmanTree_t *headTree = NULL;
     char *needcode;
     printf("please input : \n");

     obtainIput(&head, &needcode);

     creatHuffmanTree(head, &headTree);

     huffmanCode(head, headTree);

     printLinkList(head);

     //linkCode(head, needcode);

     system("pause");
     return ;
 }

10.获取输入：（obtainIput.c）

 #include"myHuffmanHead.h"

 int obtainIput(nodeHuffmanTree_t **head,char **input)
 {
     char tempInput;
     nodeHuffmanTree_t **t1 = head;
     nodeHuffmanTree_t *t2 = NULL;

     tempInput = getc(stdin);
     *input = tempInput;
     while (tempInput !='\n')
     {
         if (!(t2= isExitence( (*head), tempInput)))
         {
             nodeHuffmanTree_t *nodeTempHuffman = (nodeHuffmanTree_t *)malloc(sizeof(nodeHuffmanTree_t));

             (*t1) = nodeTempHuffman;

             nodeTempHuffman->key = tempInput;
             nodeTempHuffman->frequency = ;
             nodeTempHuffman->next = NULL;
             nodeTempHuffman->lchild = NULL;
             nodeTempHuffman->rchild = NULL;
             nodeTempHuffman->isCoded = ;
             t1 = &((*t1)->next);
             tempInput = getc(stdin);
         }
         else
         {
             t2->frequency++ ;
             tempInput = getc(stdin);
             continue;
         }
     }
     return ;
 }

3.创建一个Huffman树：（creatHuffmanTree.c）

 #include"myHuffmanHead.h"

 /*
     1.1 先遍历 链表 计算有几个需要编码
     1.2 创建一个空间 来存储 需要被编码的节点 并在每次编码后将编码后的过的删除 替换成 parent
 */

 static nodeHuffmanTree_t **spaceSave = NULL;

 nodeHuffmanTree_t ** getSpaceSave(nodeHuffmanTree_t *headLinkList)
 {
     nodeHuffmanTree_t *t1 = headLinkList;

     int n = ;
     int i = ;

     while (t1 != NULL)
     {
         n++;
         t1 = t1->next;
     }

     spaceSave = (nodeHuffmanTree_t*)malloc(sizeof(nodeHuffmanTree_t*)*n + );

     t1 = headLinkList;

     while (i < n + )
     {
         spaceSave[i] = t1;
         ++i;
         t1 = t1->next;
     }

     (int)spaceSave[] = n;

     return n;
 }

 int creatHuffmanTree(nodeHuffmanTree_t *headLinkList, nodeHuffmanTree_t **headhuffmanTree)
 {
     //nodeHuffmanTree_t **spaceSave = NULL;

     int n = getSpaceSave(headLinkList);
     int n2 = (int)spaceSave[];

     while (n2 > )
     {

         int t1, t2;

         getMinTwo(spaceSave, n, &t1, &t2);

         makeBranch(spaceSave, n, t1, t2);

         n2--;
     }

     while (n >= )
     {
         if (spaceSave[n] != NULL)
         {
             *headhuffmanTree = spaceSave[n];
             break;
         }
         else
         {
             n--;
         }
     }

     return ;
 }

5.实现对huffman树的Huffman编码：

（huffmanCode.c）//先后顺序以代码为主 &_&

 #include"myHuffmanHead.h"

 /*

     递归 每次向下递归是 向左递归 传0 向右传1
     每次接受并改掉 '\0' 为传的 0或1 然后追加 '\0';
         每次传个n来记录编码空间长度 n+1

 */
 int huffmanCode(nodeHuffmanTree_t *headLinkList, nodeHuffmanTree_t *headhuffmanTree)
 {
     headhuffmanTree->code = (char*)malloc();

     *(headhuffmanTree->code) = '\0';

     huffmanCode_(headhuffmanTree, headhuffmanTree->lchild, '', );
     huffmanCode_(headhuffmanTree, headhuffmanTree->rchild, '', );
 }

 int huffmanCode_(nodeHuffmanTree_t *parenthuffmanTree, nodeHuffmanTree_t *nexthuffmanTree, char tempCode, int layer)
 {
     if (NULL == nexthuffmanTree)
     {
         return ;
     }
     else
     {
         char *tempSpace = (char*)malloc(sizeof(parenthuffmanTree->code));

         nexthuffmanTree->code = (char*)malloc(layer+);

         changeCode(parenthuffmanTree->code, nexthuffmanTree->code, tempCode, tempSpace);

         huffmanCode_(nexthuffmanTree, nexthuffmanTree->lchild, '', layer + );

         huffmanCode_(nexthuffmanTree, nexthuffmanTree->rchild, '', layer + );

     }
 }

　　5.1.获取一个最小key的节点是个子功能：（getMinTwo.c）

 #include"myHuffmanHead.h"

 static int  flag = ;

 int getMinTwo(nodeHuffmanTree_t **spaceSave,int spaceSize ,int *t1, int *t2)
 {

     int i = ;
     int j = ;

     while (i<)
     {
         int min = ;
         j = ;

         while (j+ < spaceSize)
         {
             if (NULL==spaceSave[ + j])
             {
                 j++;
                 continue;
             }
             if ( == spaceSave[ + j]->isCoded)
             {
                 min =  + j;
                 break;
             }
             else
             {
                 j++;
             }
         }

         for (j= ; j < spaceSize; ++j)
         {
             if (NULL == spaceSave[min] || NULL == spaceSave[ + j])
             {
                 continue;
             }
             if (spaceSave[min]->frequency > spaceSave[ + j]->frequency && spaceSave[ + j]->isCoded !=)
             {
                 min =  + j;
             }
         }

         spaceSave[min]->isCoded = ;

         if ( == flag)
         {
             *t1 = min;
             flag++;
         }
         else
         {
             *t2 = min;
             flag--;
         }

         i++;
     }

 }

　　5.2.判断是否已经编码：（isExitence.c）

 #include"myHuffmanHead.h"

 nodeHuffmanTree_t* isExitence(nodeHuffmanTree_t* head, char inputTemp)
 {
     int i = ;

     if (NULL == head)
     {
         return NULL;
     }
     else
     {

         if((head->key==inputTemp))
         {
             return head;
         }
         else
         {
             isExitence(head->next, inputTemp);
         }
     }
 }

　　5.3.创建分支：（makebranch.c）

 #include"myHuffmanHead.h"

 int makeBranch(nodeHuffmanTree_t **spaceSave, int spaceSize, int t1, int t2)
 {

     nodeHuffmanTree_t *newNode = (nodeHuffmanTree_t*)malloc(sizeof(nodeHuffmanTree_t));

     newNode->frequency = spaceSave[t1]->frequency + spaceSave[t2]->frequency;
     newNode->isCoded = ;

     newNode->lchild = spaceSave[t1];
     newNode->rchild = spaceSave[t2];

     spaceSave[t1] = newNode;
     spaceSave[t2] = NULL;

 }

　　5.4.实现拼接孩子的编码：（changeCode.c）

 #include"myHuffmanHead.h"

 int changeCode(char *strParent, char *strKid, char needAppend, char *tempspace)
 {
     strcpy(tempspace, strParent);

     char *tempP = tempspace;

     while ()
     {
         if (*tempP == '\0')
         {
             *tempP = needAppend;

             *(tempP + ) = '\0';

             strcpy(strKid, tempspace);

             break;
         }
         else
         {
             ++tempP;
         }
     }
     return ;
 }

　　5.5.拼接Huffman编码：（myStrCat.c）

 #include"myHuffmanHead.h"

 int myStrCat(char *des, char *str)
 {
     char *needCatP = des;

     while ()
     {
         if (*needCatP == '\0')
         {
             *needCatP = str;

             *(needCatP + ) = '\0';

             break;
         }
         else
         {
             ++needCatP;
         }
     }
     return ;
 }

6.打印huffman编码：（printLinkList.c）

 #include"myHuffmanHead.h"

 int printLinkList(nodeHuffmanTree_t *head)
 {
     printf(" Key\t Frequncy\t HuffmanCode\n\n");
     while (head != NULL)
     {
         printf(" %c\t %d\t %s\n", head->key, head->frequency, head->code);

         head = head->next;
     }
 }

结语：有问题欢迎提在下方 ，本人在校学生，时间较为充裕， 有时间会回复的。

/* 原创文章 转载请附上原链接: https://www.cnblogs.com/jiujue/p/10325699.html  */