huffman tree

要求：

　　对于给定的字符串构建哈夫曼树，生成 huffman 编码，并进行编码 / 译码。

思路：

　　    1. 生成 huffman 树
            1> 对样本中各个字符出现次数进行统计
            2> 按统计结果以 队列 形式排列
            3> 从队列中拿出前两个生成子树，父节点大小为两节点之和
            4> 将子树再次按顺序插入队列
            5> 重复 3 4 操作，至最后只有一个根节点
    　　2. 生成 huffman 编码
            1> 以结构体存放字符（变量）及其 huffman 编码（数组）
            2> 向左为 0 ，向右为 1 ，到指针指向 NULL

#include <stdio.h>
#include <stdlib.h>
#include "huffman.h"

int main()
{
    htTree *codeTree = buildTree("I am yan guo dong!");            // 创建huffman树 通过对字符出现的次数进行统计 
    
    hlTable *codeTable = buildTable(codeTree);                    // huffman树 -> huffman编码 按次数进行 huffman 编码 
    
    encode(codeTable, "I am yan guo dong!");                        // 对字符进行编码 
    
    decode(codeTree, "0011111000111");                            // 对编码进行解码 
    
    return 0;
}


/* 
    1. 生成 huffman 树
            1> 对样本中各个字符出现次数进行统计
            2> 按统计结果以 队列 形式排列 
            3> 从队列中拿出前两个生成子树，父节点大小为两节点之和
            4> 将子树再次按顺序插入队列
            5> 重复 3 4 操作，至最后只有一个根节点 
    2. 生成 huffman 编码 
            1> 以结构体存放字符（变量）及其 huffman 编码（数组） 
            2> 向左为 0 ，向右为 1 ，到指针指向 NULL 
*/ 

#pragma once
#ifndef _PQUEUE_H
#define _PQUEUE_H

#include "huffman.h"

#define TYPE htNode *

#define MAX_SZ 256

typedef struct _pQueueNode        // 队列的节点 
{
    TYPE val;                    // 指向一个树的指针 
    unsigned int priority;        // 优先级（非负） 即该字符出现的次数 
    struct _pQueueNode *next;    // 指向下一个节点 
} pQueueNode;

typedef struct _pQueue            // 指向队列的头指针类型 
{
    unsigned int size;            // 队列的长度 
    pQueueNode *first;            // 队列的头指针 
} pQueue;

// 队列初始化 传入队列头结点的地址
void initPQueue(pQueue **queue);
// 将节点插入队列 传入（指针头结点的地址 ，待插入树的节点的指针 ，优先级即字符出现的次数 ）
void addPQueue(pQueue **queue, TYPE val, unsigned int priority);
// TYPE是树节点的类型     从队列中获取树节点
TYPE getPQueue(pQueue **queue);

#endif

#pragma once                // 防止被重复定义 
#ifndef _HUFFMAN_H            // 如果没有定义 ，已经定义则跳过 
#define _HUFFMAN_H            // 定义 

typedef struct _htNode                // 树的节点 
{
    char symbol;                    // 存放的是字符 
    struct _htNode *left, *right;
} htNode;

typedef struct _htTree        
{
    htNode *root;                     // 树的根节点 
} htTree;

typedef struct _hlNode                // 链表节点 
{
    char symbol;                    // 存放需编码的字符 
    char *code;                        // 字符指针，即字符串，存放huffman编码 
    struct _hlNode *next;            // 指向下一个节点 
}hlNode;

typedef struct _hlTable
{
    hlNode *first;
    hlNode *last;
}hlTable;

htTree *buildTree(char *inputString);
hlTable *buildTable(htTree *huffmanTree);
void encode(hlTable *table, char *stringToEncode);
void decode(htTree *tree, char *stringToDecode);

#endif

#include "queue.h"
#include <stdio.h>
#include <stdlib.h>

void initPQueue(pQueue **queue)                // 队列初始化 传入队列头结点的地址
{
    (*queue) = (pQueue *) malloc(sizeof(pQueue));        
    (*queue)->first = NULL;
    (*queue)->size = 0;
}

//                 将节点插入队列 
//        传入（指针头结点的地址 ，待插入树的节点的指针 ，优先级即字符出现的次数 ） 
void addPQueue(pQueue **queue, TYPE val, unsigned int priority)
{
    if((*queue)->size == MAX_SZ)            // MAX_SZ = 256  判断队列是否已满 
    {
        printf("
Queue is full.
");
        return;
    }
    
    pQueueNode *aux = (pQueueNode *) malloc(sizeof(pQueueNode));        // 新建节点内存 
    aux->priority = priority;
    aux->val = val;
    
    if((*queue)->size == 0 || (*queue)->first == NULL)                    // 插入的为第一个节点
    {
        aux->next = NULL;
        (*queue)->first = aux;
        (*queue)->size = 1;
    }
    else
    {
        if(priority <= (*queue)->first->priority)            // 整个队列按字符出现的次数进行前后排序 
        {                                                    // 对将插入的队列节点优先级进行判断，排序 
            aux->next = (*queue)->first;
            (*queue)->first = aux;
            (*queue)->size++;
            return;
        }
        else
        {
            pQueueNode *iterator = (*queue)->first;            // 临时变量 ，等于第一个节点  
            while(iterator->next!=NULL)                        // 遍历整个队列，进行判断排序 
            {
                if(priority <= iterator->next->priority)
                {
                    aux->next = iterator->next;
                    iterator->next = aux;
                    (*queue)->size++;
                    return ;
                }
                iterator = iterator->next;
            }
            
            if(iterator->next == NULL)                // 当待插入节点为队列中最大的一个，即该节点位于队列最后 
            {
                aux->next = NULL;
                iterator->next = aux;
                (*queue)->size++;
                return;
            }
        }
    }
}

// TYPE是树节点的类型 
TYPE getPQueue(pQueue **queue)                // 从队列中获取数据 
{
    TYPE returnValue;                        // 返回的节点数据 （指针类型） 
    
    if((*queue)->size > 0)                    // 将传入队列节点的下一个队列节点中指向的树节点返回 
    {
        returnValue = (*queue)->first->val;
                                                        // 执行删除队列节点操作 
        (*queue)->first = (*queue)->first->next;        // 队列指针指向下一个队列节点 
        (*queue)->size--;                                // 队列长度减一 
    }
    else
    {
        printf("
Queue is empty.
");
    }
    return returnValue;                        // 将指向树节点的指针返回 
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "huffman.h"
#include "queue.h"

// 从 huffman树 根节点开始进行 huffman编码 
// 
void traverseTree(htNode *treeNode, hlTable **table, int k, char code[256])
{
    if(treeNode->left == NULL && treeNode->right == NULL)        // 没有左右孩子 为叶子节点 
    {
    
        code[k] = '';
        hlNode *aux = (hlNode *)malloc(sizeof(hlNode));
        aux->code = (char *)malloc(sizeof(char)*(strlen(code)+1));
        strcpy(aux->code, code);
        aux->symbol = treeNode->symbol;
        aux->next = NULL;
    
        if((*table)->first == NULL)
        {
            (*table)->first = aux;
            (*table)->last = aux;
        }
        else
        {
            (*table)->last->next = aux;
            (*table)->last = aux;
        }
    }
    
    if(treeNode->left != NULL)                // 递归调用 
    {
        code[k] = '0';
        traverseTree(treeNode->left, table, k+1, code);
    }
    
    if(treeNode->right != NULL)
    {
        code[k] = '1';
        traverseTree(treeNode->right, table, k+1, code);
    }
}

hlTable *buildTable(htTree *huffmanTree)
{
    hlTable *table = (hlTable *)malloc(sizeof(hlTable));
    table->first = NULL;
    table->last = NULL;
    
    char code[256];                // 编码存放数组  
    int k = 0;                    // 当前索引 huffman树 的层数 
    
        // 传入  huffman树的根节点，链表指针，层数，编码数组 
    traverseTree(huffmanTree->root, &table, k, code);
    return table;
}

htTree *buildTree(char *inputString)            // 创建huffman树 
{
    int *probability = (int *)malloc(sizeof(int)*256);        // 存储每个字符出现次数的数组 
    
    // 初始化
    for(int i = 0; i < 256; i++)
    {
        probability[i] = 0;                // 记录每个字符出现的次数 
    }
    
    // 统计待编码的字符串各个字符出现的次数 
    for(int j = 0; inputString[j] != ''; j++)
    {
        probability[(unsigned char)inputString[j]]++;
    }
    
    pQueue *huffmanQueue;                // pQueue队列的头节点
    initPQueue(&huffmanQueue);            // 对队列进行初始化 传入指向地址的指针的地址 
    
    // 填充对列 
    for(int k = 0; k < 256; k++)
    {
        if(probability[k] != 0)            // 存在ASCII码为 k 的字符 
        {
            htNode *aux = (htNode *)malloc(sizeof(htNode));            // 新建树的节点 
            aux->left = NULL;
            aux->right = NULL;
            aux->symbol = (char) k;
            
            addPQueue(&huffmanQueue, aux, probability[k]);            // 将节点插入队列 
        } 
    }
    
    free(probability);            // 将数组存储空间释放 
    
    // 生成 huffman 树  
    while(huffmanQueue->size != 1)            // 将所有树节点构造huffman树，让最后一个节点为根节点 
    {
        int priority = huffmanQueue->first->priority;                // 将两个最小的字符出现次数相加 
        priority += huffmanQueue->first->next->priority;
        
        htNode *left = getPQueue(&huffmanQueue);                    // 将最小两个树节点作为子树的左右孩子 
        htNode *right = getPQueue(&huffmanQueue);
        
        htNode *newNode = (htNode *)malloc(sizeof(htNode));            // 创建两节点的父节点 
        newNode->left = left;
        newNode->right = right;
        
        addPQueue(&huffmanQueue, newNode, priority);                // 将父节点再次加入队列， 
    } 
    
    htTree *tree = (htTree *)malloc(sizeof(htTree));                 // 一个指向树的节点的指针 
    
    tree->root = getPQueue(&huffmanQueue);                            // 指向根节点 
    
    return tree;
}

void encode(hlTable *table, char *stringToEncode)                // 编码 
{
    hlNode *traversal;
    
    printf("Encoding.............

Input string : 
%s

Encodeed string : 
", stringToEncode);
    
    for(int i = 0; stringToEncode[i] != ''; i++)
    {
        traversal = table->first;
        while(traversal->symbol != stringToEncode[i])
            traversal = traversal->next;
        printf("%s", traversal->code);
    }
    
    printf("
");
}

// 解码 
void decode(htTree *tree, char *stringToDecode)
{
    htNode *traversal;
    traversal = tree->root;
    
    printf("Encoding.............

Input string : 
%s

Decodeed string : 
", stringToDecode);
    
    for(int i = 0; stringToDecode[i] != ''; i++)
    {
        if(stringToDecode[i])
        {
            if(!traversal->right)
            {
                printf("%c", traversal->symbol);
                traversal = tree->root;
            }
            else
                traversal = traversal->right;
        }    
        else{
            if(!traversal->left)
            {
                printf("%c", traversal->symbol);
                traversal = tree->root;
            }
            traversal = traversal->left;
        }
    }
}