哈夫曼编码

前面一节我们知道了，怎样去创建一个哈夫曼树，这一节我们来看看哈夫曼编码。

思想：得到哈夫曼树后，自顶向下按路径编号，指向左节点的边编号0，指向右节点的边编号1，从根到叶节点的所有边上的0和1连接起来，就是叶子节点中字符的哈夫曼编码。

下图体现了哈夫曼编码的过程：





#include <stdio.h>

#include <stdlib.h>

#include <string.h>

//哈夫曼树结点

typedef struct HuffNode

{

int weight;

char ch;

char code[20];

struct HuffNode *rchild;

struct HuffNode *lchild;

}HuffMan;

//队列设计

typedef struct _node_

{

HuffMan *data;

struct _node_ *next;

}ListNode;

typedef struct

{

ListNode *front;

ListNode *rear;

}Queue;

//create empty queue

Queue *create_empty_queue()

{

ListNode *HList;

Queue *Hqueue;

HList = (ListNode *)malloc(sizeof(ListNode));

HList->next = NULL;

Hqueue = (Queue *)malloc(sizeof(Queue));

Hqueue->front = Hqueue->rear = HList;

return Hqueue;

}

//入队

int EnterQueue(Queue *head,HuffMan *data)

{

ListNode *temp;

temp = (ListNode *)malloc(sizeof(ListNode));

temp->data = data;

temp->next = NULL;

head->rear->next = temp;

head->rear = temp;

return 0;

}

//有序插入结点

int OrderEnterQueue(Queue *head,HuffMan *p)

{

ListNode *m = head->front->next;

ListNode *n = head->front;

ListNode *temp;

while(m)

{

if(m->data->weight < p->weight)

{

m = m->next;

n = n->next;

}

else{

break;

}

}

//插到最后一个结点

if(m == NULL)

{

temp = (ListNode *)malloc(sizeof(ListNode));

temp->data = p;

temp->next = NULL;

n->next = temp;

head->rear = temp;

return 0;

}

//插入中间结点

temp = (ListNode *)malloc(sizeof(ListNode));

temp->data = p;

n->next = temp;

temp->next = m;

return 0;

}

//判断队列是否为空(注意，我们认为队列含有一个结点为空，想想为什么

//这样做?

int _is_empty_queue(Queue *head)

{

if(head->front->next->next == NULL)

{

printf("is_empty_queue\n");

return 1;

}

return 0;

}

//判断队列是否为空

int is_empty_queue(Queue *head)

{

if(head->front == head->rear)

return 1;

else

return 0;

}

//出队

HuffMan *DeleteQueue(Queue * head)

{

ListNode *temp;

temp = head->front;

head->front = temp->next;

free(temp);

temp = NULL;

return head->front->data;

}

//创建哈夫曼树

HuffMan *create_huffman_tree(Queue *head)

{

HuffMan *right,*left,*current;

//循环结束时，队列只含有一个结点

while(!_is_empty_queue(head))

{

left = DeleteQueue(head);

right = DeleteQueue(head);

current = (HuffMan *)malloc(sizeof(HuffMan));

current->weight = left->weight + right->weight;

current->rchild = right;

current->lchild = left;

OrderEnterQueue(head,current);

}

return head->front->next->data;

}

//哈夫曼编码

int HuffmanCode(HuffMan *root)

{

HuffMan *current = NULL;

Queue *queue = NULL;

queue = create_empty_queue();

EnterQueue(queue, root);

while(!is_empty_queue(queue))

{

current = DeleteQueue(queue);

if(current->rchild == NULL && current->lchild == NULL)

{

printf("%c:%d %s\n",current->ch,current->weight,current->code);

}

if(current->lchild)

{

strcpy(current->lchild->code,current->code);

strcat(current->lchild->code,"0");

EnterQueue(queue, current->lchild);

}

if(current->rchild)

{

strcpy(current->rchild->code,current->code);

strcat(current->rchild->code,"1");

EnterQueue(queue, current->rchild);

}

}

return 0;

}

运行结果: