数据结构之Huffman树

啥是Huffman树

赫夫曼树，又称最优二叉树。它的最优体现在每个结点的权值与它的路径长度的乘积之和最小。具体定义参考博客：https://blog.csdn.net/heart_love/article/details/50901943

代码实现

  结点结构示意:

Data(数据位)

Weight(权值)

Parent(双亲)

Lchild(左孩子)

Rchild(右孩子)

  初始化的结构示意图 (数据在代码中)

data	weight	parent	lchild	rchild
A	10	-1	-1	-1
B	20	-1	-1	-1
C	15	-1	-1	-1
D	17	-1	-1	-1

  Huffman树实现原理:

  1、在已知数组结点中找到没有双亲(双亲数据为-1)且权值最小的2个结点 这边设置为 m1,m2。

  2、在数组中增加了一个结点  该结点的权值 = m1的权值 + m2的权值   该结点的左孩子为m1  该结点的右孩子为m2 

  m1和m2的双亲为该下标

 3、重复 1和2这两个步骤 直到只剩下一个结点的双亲值为-1

Huffman编码代码输出原理(注意这边的data中的(1)到(3)是没有的为了讲解方便才写上的)

data	weight	parent	lchild	rchild
A	10	4	-1	-1
B	20	5	-1	-1
C	15	4	-1	-1
D	17	5	-1	-1
(1)	25	6	0	2
(2)	37	6	3	1
(3)	62	-1	4	5

这边以A的huffman编码为例

1、找到A的双亲(1)看A在(1)中若是左孩子则存入0若为右孩子则存入1

2、再找到(1)的双亲(3)看(1)在(3)中若是左孩子则存入0若为右孩子则存入1

3、重复上面步骤直到该结点双亲为-1 其实就是根结点

4、将存入的数据再反序输出  比如C存入的数据为10 则反序输出的数据为01--就是C的huffman编码

代码展示

#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define INF 1000
#define MAX 50
/*
4
A 10
B 20
C 15
D 17
*/
typedef int Status;

typedef struct HuffmanNode{
	char data;//数据域
	int weight;//权值
	int parent,lchild,rchild;//双亲结点 左孩子结点 右孩子结点
}HuffmanNode;

typedef struct HuffmanTree{
    HuffmanNode arr[MAX];
    int n;//输入元素个数
}HuffmanTree;

//全局变量 用于输出huffman编码
char gg[MAX][MAX];

/*
fflush(stdin)是一个计算机专业术语，功能是清空输入缓冲区，
通常是为了确保不影响后面的数据读取
（例如在读完一个字符串后紧接着又要读取一个字符，此时应该先执行fflush(stdin);）。
*/
Status initTree(HuffmanTree *T){
   int i=0;
	scanf("%d",&T->n);//输入结点个数
	for(i = 0; i < T->n; i++){
		fflush(stdin);
		scanf("%c%d",&T->arr[i].data,&T->arr[i].weight);//输入数据和权值
		T->arr[i].parent=T->arr[i].lchild=T->arr[i].rchild=-1;//设置双亲结点 左孩子结点 右孩子结点为-1
	}
	return OK;
}

//找到数组中最小的两个数(只可意会)  min1比min2的权值小
Status findMin(HuffmanTree T,int *m1,int *m2,int num){
    int m3;
    int i,min1=INF,min2=INF;
    for(i = 0;i<num;i++){
        if(T.arr[i].parent == -1){
            //若权值大于min1 则交换数据 并赋值数据
            if(min1 > T.arr[i].weight){
                min2 = min1;*m2 = *m1;
               *m1 = i;min1 = T.arr[i].weight;
            //若权值大于min2且权值小于min1 则赋值数据
            }else if(min2 > T.arr[i].weight){
                *m2 = i;min2 = T.arr[i].weight;
            }

        }
    }
    //只剩下一个节点的情况
    if(min1 == INF || min2 == INF){
        return ERROR;
    }
    return OK;
}

//创建HuffmanTree
Status createTree(HuffmanTree *T){
    int i,m1,m2;
    i = T->n;
    while(findMin(*T,&m1,&m2,i)){
        /*
        增加结点 该结点的权值 = m1的权值 + m2的权值   该结点的左孩子为m1  该结点的右孩子为m2 
        m1和m2的双亲为该下标
        */
        T->arr[m1].parent = i;
        T->arr[m2].parent = i;
        T->arr[i].weight  = T->arr[m1].weight + T->arr[m2].weight;
        T->arr[i].lchild = m1;
        T->arr[i].rchild = m2;
        T->arr[i].parent = -1;
        i++;
    }
    return OK;
}

//输出Huffman编码
void createHuffmanCode(HuffmanTree T){
    int n = T.n;
    int i,k;
    char c[MAX];
    int j,top;
    for(k = 0;k<n;k++){
        i = k;
        j = 0;
        top = 0;
        int p = T.arr[i].parent;
        gg[k][top++] = T.arr[i].data;
        gg[k][top++] = ':';
        while(T.arr[i].parent != -1){
            if(T.arr[p].lchild == i){
                c[j++] = '0';
            }
            if(T.arr[p].rchild == i){
               c[j++] = '1';
            }
            i = p;
            p = T.arr[i].parent;
        }

        while(j != 0){
            gg[k][top++] = c[--j];

        }
        gg[k][top] = '\0';
    }
}

//输出HuffmanNode数组
void show(HuffmanTree T){
    int i;
    for(i = 0; i < T.n+3; i++){
		printf("%c %d\t%d %d %d\n ",T.arr[i].data,T.arr[i].weight,T.arr[i].parent,T.arr[i].lchild,T.arr[i].rchild);

	}
}

int main()
{
    HuffmanTree T;
    initTree(&T);
    int m1,m2,i;
    createTree(&T);
    show(T);
    createHuffmanCode(T);
    for(i = 0;i<T.n;i++){
        printf("%s\n",gg[i]);
    }
    return 0;
}