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 : 
");

    obtainIput(&head, &needcode);

    creatHuffmanTree(head, &headTree);

    huffmanCode(head, headTree);

    printLinkList(head);

    //linkCode(head, needcode);

    system("pause");
    return 0;
}

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 !='
')
    {
        if (!(t2= isExitence( (*head), tempInput)))
        {
            nodeHuffmanTree_t *nodeTempHuffman = (nodeHuffmanTree_t *)malloc(sizeof(nodeHuffmanTree_t));

            (*t1) = nodeTempHuffman;

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

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 = 0;
    int i = 1;

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

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

    t1 = headLinkList;

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

    (int)spaceSave[0] = n;

    return n;
}

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

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

    while (n2 > 1)
    {
    
        int t1, t2;

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


        makeBranch(spaceSave, n, t1, t2);

        n2--;
    }

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

    return 0;
}

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

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

#include"myHuffmanHead.h"



/*

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

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

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

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

        nexthuffmanTree->code = (char*)malloc(layer+2);
        
        changeCode(parenthuffmanTree->code, nexthuffmanTree->code, tempCode, tempSpace);

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

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

    }
}

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

#include"myHuffmanHead.h"


static int  flag = 0;

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

    int i = 0;
    int j = 0;
    
    while (i<2)
    {
        int min = 1;
        j = 0;

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

        spaceSave[min]->isCoded = 1;

        if (0 == 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 = 0;

    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 = 0;

    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 (1)
    {
        if (*tempP == '')
        {
            *tempP = needAppend;

            *(tempP + 1) = '';

            strcpy(strKid, tempspace);

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

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

#include"myHuffmanHead.h"

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

    while (1)
    {
        if (*needCatP == '')
        {
            *needCatP = str;

            *(needCatP + 1) = '';

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

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

#include"myHuffmanHead.h"

int printLinkList(nodeHuffmanTree_t *head)
{
    printf(" Key	 Frequncy	 HuffmanCode

");
    while (head != NULL)
    {
        printf(" %c	 %d	 %s
", head->key, head->frequency, head->code);
        
        head = head->next;
    }
}

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

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