哈夫曼算法(huffman algorithm C)

哈夫曼算法：树的权值*路径相加最小。

#include<stdio.h>
#define size 10
typedef struct huffman
{

    int weight;
    int lchild,rchild,parent;

} huff;
void select(huff a[],int b[],int qu);
void huffman(huff hufftree[],int w[],int n);

void main()
{

    int w[size] = {12,2,4,6,7,11,5,9,13,10};
    huff hufftree[2*size-1];
    huffman(hufftree,w,size);

}
void select(huff a[],int b[],int qu) //找出两个最小权值的数组的下标
{

    int min1 = 100000, min2 = 100000,index1,index2; //min1,min2为大于所有权值的数
    for(int i = 0; i < qu; i++)
    {
        if(a[i].parent == -1) //必须比较那些没有双亲节点的，有双亲节点的都是比较过的，不能重复比较
        {

            if(a[i].weight < min1)
            {
                min1 = a[i].weight;
                index1 = i;
                continue;
            }
            if(a[i].weight<min2)
            {
                min2 = a[i].weight;
                index2 = i;
            }
        }

    }
    b[0] = index1;
    b[1] = index2;
}
void huffman(huff hufftree[],int w[],int n)
{

    for(int i = 0; i<2*n-1; i++)
    {

        hufftree[i].lchild = -1;
        hufftree[i].rchild = -1;
        hufftree[i].parent = -1;

    }
    for(int j = 0; j<n; j++)
    {

        hufftree[j].weight = w[j];
    }
    int b[2];
    int k,j;
    for(int i = n; i<2*n-1; i++)
    {

        select(hufftree, b, i); //每产生一个新的组合节点，就要加进去比较，所以这里是变化的参数i
        k = b[0];
        j = b[1];
        hufftree[k].parent = i;
        hufftree[j].parent = i;
        hufftree[i].lchild = k;
        hufftree[i].rchild = j;
        hufftree[i].weight = hufftree[k].weight + hufftree[j].weight;
        printf("组合：%d\t%d\t父节点：%d\n",hufftree[k].weight,hufftree[j].weight,hufftree[i].weight);//打印结果
    }

}

我那个找出最小两个权值算法太low了，那个你们可以自己改进一下。
最后结果：

转载于:https://www.cnblogs.com/qukingblog/p/7475315.html