哈夫曼树的实现及哈夫曼编码

感悟

哈夫曼树，核心思想：就是每次从当前的根节点数组中，找出两个权值最小的根节点，然后让它们两个分别作为左子树和右子树，去构造一颗新的树，并把这个新的根节点，添加到根节点数组中。如此反复，直到就只剩一个根节点。

思路

//n是度为0的节点数

1. 创捷一个空间大小为 2 * n的线性表；//new Tree_nde[2 * n];
2. 将每个节点的双亲，左孩子，右孩子都初始化为0，并输入前n个节点的权值
3. 循环n - 1次，每次找到表中，权值最小的根节点的下标。
4. 将这两个根节点的双亲，设置为第n + i个节点
5. 让第n + i个节点的左右孩子，为这两个节点。

讲的不怎么清楚，也许看代码更好懂一些。

Q1： 怎么知道是否为根节点？

我们每次找出两个权值最小的根节点，使这两个节点的parent为最后一个根节点的下一个位置，因为这两个根节点的parent已经不为0，所以他们已经不再是根节点。

Q2：怎么同时找到两个最小值？
首先找到第一个最小值，然后在找第二个最小值时，判断当前节点，是否为刚才找到的节点，如果是，就跳过，进行下一次寻找。

Q3：总共有多少个节点？
我们输入的值，都是哈夫曼树的叶子节点，而且哈夫曼树没有度为1的节点，根据公式n0 = n2 + 1；总共有2 * n0 - 1个节点。

//5 29 7 8 14 23 3 11
#include<iostream>
using namespace std;
typedef struct Tree_node
{
    int weight;
    int parent,lchild,rchild;
};
void get_min(Tree_node * arr, int n, int &s1, int &s2)
{
    int min = 100000;
    for(int i = 1; i<= n; i++)
    {
        if(arr[i].parent != 0)
            continue;
        if(arr[i].weight <= min)
        {
            min = arr[i].weight;
            s1 = i;
        }
    }
    min = 100000;
    for(int i = 1; i<= n; i++)
    {
        if(arr[i].parent != 0 || i == s1)     //查找除了刚才那个以外，最小的根节点
            continue;
        if(arr[i].weight <= min)
        {
            min = arr[i].weight;
            s2 = i;
        }
    }
}
int main()
{
    int n;cin >> n;
    Tree_node * arr = new Tree_node[2 *n];
    for(int i = 1; i <= 2 * n - 1; i++)
    {
        arr[i].parent = 0;
        arr[i].lchild = 0;
        arr[i].rchild = 0;
        if(i <= n)
        {
            cin >> arr[i].weight;
        }
    }
    for(int i = 1; i <= 2 * n -1; i++)
    {
        cout<<i<<"\t"<<arr[i].weight<<"\t"<<arr[i].parent<<"\t";
        cout<<arr[i].lchild<<"\t"<<arr[i].rchild<<endl;
    }
    cout<<endl<<"------------------------------------------"<<endl<<endl;
    int s1, s2;
    for(int i = n + 1; i <=2*n - 1; i++)
    {
        get_min(arr,i-1,s1,s2);
        arr[s1].parent = i;
        arr[s2].parent = i;
        arr[i].lchild = s1;
        arr[i].rchild = s2;
        arr[i].weight = arr[s1].weight + arr[s2].weight;
    }
    for(int i = 1; i <= 2 * n -1; i++)
    {
        cout<<i<<"\t"<<arr[i].weight<<"\t"<<arr[i].parent<<"\t";
        cout<<arr[i].lchild<<"\t"<<arr[i].rchild<<endl;
    }//5 29 7 8 14 23 3 11
}

哈夫曼编码

#include<iostream>
using namespace std;
typedef double TElemTpye;
typedef struct Tree_Node
{
    TElemTpye weight;
    int parent, lchild, rchild;
    string Huffman_num;
};
void Get_min(Tree_Node * arr,int n, int &x, int &y)
{
    int Min = 100;
    for(int i = 1; i <= n; i++)
    {
        if(arr[i].weight < Min && arr[i].parent == 0)
        {
            Min = arr[i].weight;
            x = i;
        }
    }
    Min = 100;
    for(int i = 1; i <= n; i++)
    {
        if(arr[i].weight < Min && arr[i].parent == 0 && i != x)
        {
            Min = arr[i].weight;
            y = i;
        }
    }
}
Tree_Node * Create_HuffmanTree(int n)
{
    Tree_Node * arr = new Tree_Node[2 * n];
    for(int i = 1; i < 2 * n; i++)
    {
        arr[i].parent = 0;
        arr[i].lchild = 0;
        arr[i].rchild = 0;
        if(i <= n) cin>>arr[i].weight;
    }
    int x, y;
    for(int i = 1; i < n; i++)
    {
        Get_min(arr,n + i -1,x,y);
        arr[x].parent = n + i;
        arr[y].parent = n + i;
        arr[n + i].weight = arr[x].weight + arr[y].weight;
        arr[n + i].lchild = x;arr[n + i].rchild = y;
    }
    return arr;
}
int Get_Huffman_num(Tree_Node * arr,int n)
{
    string num = "";
    int index = arr[n].parent, x = n;
    while(index != 0)
    {
        if(arr[index].lchild == x)
            num = num + "0";
        else
            num = num + "1";
        x = index;
        index = arr[index].parent;
    }
    //cout<<num;
    for(int i = 0; i < num.length(); i++)
        arr[n].Huffman_num += num[num.length() - i - 1];
    cout<<arr[n].weight<<"\t"<<arr[n].Huffman_num<<endl;
}
int main()
{
    //Create_HuffmanTree(8);
    Tree_Node * arr = Create_HuffmanTree(8);
    for(int i = 1; i <= 8; i++)
    {
        Get_Huffman_num(arr,i);
    }

    // 5 29 7 8 14 23 3 11
}