哈夫曼树

 哈夫曼树(Huffman tree)也称最优二叉树。每个叶子节点都有一个权值，就是一个有意义的数据值，一般取正整数。

 一个二叉树具有N个带权值的叶子节点，从根节点到各个子节点的路径长度和相应权值的的乘积之和就做二叉树的带权路径长度。

 WPL=(W1*L1+W2*L2+W3*L3+...+Wn*Ln)

 带权路径长度最小的称为哈夫曼树。

 算法描述如下

（1）初始化：给定的n个权值{W1,W2,...,Wn}构造n棵只有一个根节点的二叉树，得到一个二叉树的集合F={T1,T2,...,Tn}.

（2）选择和合并：在F中选取根节点的权值最小的两棵二叉树分别作为左右子树构造一棵新的二叉树，这课二叉树的根节点的权值为其左右子树根节点的权值之和。

（3 ）删除和加入：在F中删除作为左右子树的两棵二叉树，将新建的二叉树加入到F中。

（4）重复2，3操作，在F只剩一棵二叉树结束，这棵二叉树叫做哈夫曼属。

 一棵哈夫曼树的非叶子节点度都为2，现在具有n个叶子节点的哈夫曼树共有2n-1个节点。怎么算的了？二叉树的性质可知，叶子节点的个数N0，度为2的节点的个数为N2，则N0 = N2 + 1。所以哈夫曼树n = n2 + 1；n2 = n - 1；n2 + n = 2n - 1；

 下面是代码实现，使用数组保存哈夫曼树的节点信息

                  

#include <iostream>
using namespace std;
 
struct element
{
    /**
     * @brief weight 权值
     */
    int weight;
    /**
     * @brief lchild 左孩子
     */
    int lchild;
    /**
     * @brief rchild 右孩子
     */
    int rchild;
    /**
     * @brief parent 父亲
     */
    int parent;
};
 
/**
 * @brief selectTwoMins 从根节点中取出两个最小权值的节点
 * @param tree 树
 * @param min1 第一小下标
 * @param min2 第二小下标
 * @param n 当前的构成中的树的节点数
 */
 
void selectTwoMins(element tree[],int &min1,int &min2,int n)
{
    int t = 0;//第一小权值
    int t1 = 0;//第二小权值
    for (int i = 0;i < n;++i) {
        if (tree[i].parent == -1) {//只操作根节点
            if (t == 0) {
                t = tree[i].weight;//第一小权值赋予初值
                min1 = i;
            } else if (t1 == 0) {
                if (t > tree[i].weight) {//第二小权值赋予初值，如果第一比第二大，则互换
                    min2 = min1;
                    min1 = i;
                    t1 = t;
                    t = tree[i].weight;
                } else {
                    min2 = i;
                    t1 = tree[i].weight;
                }
            } else if (t < tree[i].weight) {//第一小权值与后续的比较大小，如果小于在比较第二小权值与后续比较大小
                if (t1 > tree[i].weight) {
                    min2 = i;
                    t1 = tree[i].weight;
                }
 
            } else {//第一小权值与后续的比较大，则第一给第二，第一被后续值覆盖
                min2 = min1;
                t1 = t;
                min1 = i;
                t = tree[i].weight;
            }
        }
    }
}
/**
 * @brief huffmanTree
 * @param tree 树
 * @param w 权值序列
 * @param n 节点个数
 */
void huffmanTree(element tree[],int w[],int n)
{
    for (int i = 0;i < 2 * n - 1;++i) {//初始化
        tree[i].lchild = -1;
        tree[i].rchild = -1;
        tree[i].parent = -1;
    }
    for (int i = 0;i < n;++i) {//赋予权值
        tree[i].weight = w[i];
    }
    for (int i = n;i < 2 * n - 1;++i) {//增加的节点为n~2n-2(2n-2-n+1 = n-1个)
        int t = 0;
        int t1 = 0;
        selectTwoMins(tree,t,t1,i);
        tree[i].weight = tree[t].weight + tree[t1].weight;
        tree[t].parent = i;
        tree[t1].parent = i;
        tree[i].lchild = t;
        tree[i].rchild = t1;
    }
}
 
int main()
{
    int n = 4;
    int m = 2 * n - 1;
    element tree[8];
    int w[] = {2,4,5,3};
    huffmanTree(tree,w,n);
    for (int i = 0;i < m;++i) {
        cout << tree[i].weight << "  ";
    }
    return 0;
}