HuffmanTree

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define OK 1
#define NO 0
#define True 1
#define FALSE 0
#define ERROR -1
#define MAX_TREE_SIZE 100

typedef int  Status;
typedef struct 
{
    unsigned int weight;
    unsigned int parent;
    unsigned int lchild;
    unsigned int rchild;
}HTNode;
typedef HTNode *HuffmanTree;
typedef char* HCNode;
typedef HCNode* HuffmanCode;

void InitTree_HT(HuffmanTree *HT);

Status CreateHuffmanTree_HT(HuffmanTree *HT);

Status Select_HT(HuffmanTree HT,int end,int *order_1,int *order_2);//在哈夫曼树结点中一次选出权值最小且未编入树的两个结点的序号order_1,order_2；

Status ShowHuffmanTree_HT(HuffmanTree HT);

Status HuffmanCoding_HT(HuffmanTree HT,HuffmanCode *HC);//先序遍历计算哈夫曼编码值

void ShowHuffmanCode_HT(HuffmanTree HT,HuffmanCode HC);

int main (int argc,char** argv){
    HuffmanTree HT;
    HuffmanCode HC;
    printf("1\n函数InitTree_HT 测试..\n");
    {
        printf("初始化哈夫曼树 HT..\n");
        InitTree_HT(&HT);
        printf("\n");
    }
    printf("2,3\n函数CreateHuffmanTree_HT等测试..\n");
    {
        printf("创建哈夫曼树HT..\n");
        printf("作为示范，输入8个结点的权值（5，29，7，8，14，23，3，11）..\n");
        CreateHuffmanTree_HT(&HT);
        printf("\n");
    }
    printf("5\n函数 ShowHuffmanTree_HT");
    {
        printf("展示哈夫曼树 HT=\n");
        ShowHuffmanTree_HT(HT);
        printf("\n");
    }
    printf("4\n函数HuffmanCoding_HT 测试..\n");
    {
        printf("计算哈夫曼编码 HC..\n");
        HuffmanCoding_HT(HT,&HC);
        printf("\n");
    }
    printf("6\n函数ShowHuffmanCode_HT测试..\n");
    {
        printf("展示哈夫曼编码 HC = ");
        ShowHuffmanCode_HT(HT,HC);
        printf("\n");
    
    }
}
void InitTree_HT(HuffmanTree *HT){
    *HT=NULL;
}

Status CreateHuffmanTree_HT(HuffmanTree *HT){
    int m,n;  //n为叶子的个数，m为总的结点树 m=2*n-1
    int w[MAX_TREE_SIZE];
    HuffmanTree p;
    int i;
    int s1,s2;
    
    printf("录入哈夫曼树叶子结点个数-->");
    //scanf 要在用n之前给n幅值
    scanf("%d",&n);
    printf("\n");
    printf("依次录入各叶子结点的权值-->");
    for(i=1;i<=n;i++)   //0单元弃用
        scanf("%d",&w[i]);
    printf("\n");
    m=2*n-1;   //哈夫曼树的有效结点个数
    *HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));//0单元弃用,申请了m+1个连续的存储单元，其中首个单元*(HT)[0]用来存放叶子的数目
    if(!(*HT))
        exit(ERROR);
    (*HT)[0].weight = n;//利用0号单元的权值存储哈夫曼树叶子个数
    for(i=1;i<=m;i++)
    {
        if(i<=n)
            (*HT)[i].weight=w[i];//[1,2,……,n]叶子的结点
        else 
            (*HT)[i].weight=0;//其余的双亲结点，权重都设置为0
        (*HT)[i].parent=0;
        (*HT)[i].lchild=0;
        (*HT)[i].rchild=0;  //初始化各个结点
    }
    for(i=n+1;i<=m;i++)
    {
        Select_HT(*HT,i-1,&s1,&s2);
       /****************************************************************************************************************************
        *本实现方法为，将所有的哈夫曼树的结点都按照静态链表存储起来，然后对于权重weight来说，首先是只有前n个结点中有权重，后面的   *
        *全都被重置为0，然后从第n+1个结点开始操作，这个结点原本没有写入weight(为0)后来经过了Select_HT的遍历之后找到了前面没有使用  *
        *过的两个最小的权重，并且将它们的父亲都设置成这个i+1,结点，相当与将这两个结点合并，然后在下一次进入这个循环的时候i变成了n  *
        *+2，然后这个时候遍历的就是前面n+1个结点，找出最小的weight，同时将这个时候的双亲设置成为n+2,但这个时候需要注意的是，不能够 *
        *选取之前选过的结点，可以对他们添加一些标记，比如将它们的改变他们的父亲的值，这个之前已经改变过了，因此只要遍历的时候再增加*
        *一次判断即可                                                                                                              *
        ****************************************************************************************************************************/
        (*HT)[s1].parent=(*HT)[s2].parent=i;
        (*HT)[i].lchild=s1;
        (*HT)[i].rchild=s2;
        (*HT)[i].weight=(*HT)[s1].weight+(*HT)[s2].weight;
    }
    return OK;

}
Status Select_HT(HuffmanTree HT,int end,int *order_1,int *order_2){
    //传进来的end是i-1因为i是要当双亲的结点
    HuffmanTree p;
    int i,count;
    int m,n,tmp;
    if(end<2)  //此时只有一个结点,无法进行比较
        return ERROR;
    for(i=1,count=1;i<=end;i++)  //遍历找到前两个并没有被使用的weight
    {
        if(HT[i].parent==0)//只有还没有被使用才会进入循环
        {
            if(count==1)
                m=i;  //找到第一个位置
            if(count==2)
                n=i;  //找到第二个位置
            count++;
        }
        if(count>2) //找到两个之后就结束跳出循环
            break;
    }
    if(HT[m].weight>HT[n].weight) //保证m的weight比较的小
    {
        tmp=n;
        n=m;
        m=tmp;
        
    }
    i=(m>n?m:n)+1;//便于继续遍历找到下一个未使用的结点，找到m,n两者的较大值的后一个
    while(i<=end)  //找到最小的两个weight
    {
        if(HT[i].parent==0)  //同前
        {
            if(HT[i].weight<HT[m].weight) //如果i的weight小 那么就选择i，m 将最小的i给m,第二小的m给n
            {
                n=m;
                m=i;            
            }
            else
            {
                if(HT[i].weight>=HT[m].weight&&HT[i].weight<HT[n].weight)//如果i的weight在m,n之间，那么将i的权重给n,同时比较两者大的舍去
                    n=i;
            }    
        }
        i++;
    
    }

    *order_1=HT[m].weight<=HT[n].weight?m:n;//最小的weigth
    *order_2=HT[m].weight>HT[n].weight?m:n;//第二小的weight
    return OK;

}

Status ShowHuffmanTree_HT(HuffmanTree HT){
    int i;
    printf(" ---------------------------------------- \n");
    printf("┃*order┃weight┃parent┃lchild┃rchild┃\n");
    for(i=0;i<=2*HT[0].weight-1;i++)
    {
        if(i==0)
            printf("┃%6d┃%6d┃  *   ┃   *  ┃  *   ┃\n",i,HT[i].weight);
        else 
            printf("┃%6d┃%6d┃%6d┃%6d┃%6d┃\n",i,HT[i].weight,HT[i].parent,HT[i].lchild,HT[i].rchild);    
    }
    printf(" ---------------------------------------- \n");
    return OK;

}

Status HuffmanCoding_HT(HuffmanTree HT,HuffmanCode *HC){
    int m,n,i;
    int cdlen;
    int p,mark[MAX_TREE_SIZE];  //mark用来标记访问的次数 
    char *code;//用来存储编码 赋值给HC
    
    n=HT[0].weight;//哈夫曼树叶子结点个数
    m=2*n-1;//哈夫曼树结点个数

    *HC=(HuffmanCode)malloc((n+1)*sizeof(HCNode));
    if(!(*HC))
        exit(ERROR);
    code=(char*)malloc(n*sizeof(char));
    if(!code)
        exit(ERROR);
    for(i=1;i<=n;i++)
        code[i]='\0';
    for(i=1;i<=m;i++)
        mark[i]=0;//0，1，2分别表示访问零次一次两次
    p=m;
    cdlen=0;
    /*对于每一个结点p，都会经历2次访问，最后退回到父亲的结点，因此一层层递归之后，最后会回到根节点的上一个也就是之前定义过的0结束循环*/
    while(p)
    {
        if(mark[p]==0)  //第一次访问这个结点
        {
            mark[p]=1;    //左孩子不存在，那么这个时候就只是执行了mark[p]=1，下次就不会直接进来
            if(HT[p].lchild!=0) //从根结点的向左访问
            {
                p=HT[p].lchild; //p向左走一步
                code[cdlen]='0';//走左边就给一个0
                cdlen++;
            }
            else
            {
                if(HT[p].rchild==0)   //找到叶子结点
                {
                    (*HC)[p]=(char*)malloc((cdlen+1)*sizeof(char));//+1是为了放置最后的'\0'，指针数组中存放的是一个指针，
                                                                    //所以p不一样的时候会指向不同的地方
                    strcpy((*HC)[p],code);//复制编码串
                }
            }    
        
        }    
        else //左孩子不存在的时候，这个时候右孩子可能存在，因为右孩子是不是0都会进入这里
        {
            if(mark[p]==1)  //第二次访问，当
            {
                mark[p]=2;
                if(HT[p].rchild!=0)//如果右孩子存在，那么这个时候由于之前判断了左孩子不存在，所以p不是叶子，因此继续往右并给编码1
                {
                    p=HT[p].rchild;
                    code[cdlen]='1';
                    cdlen++;      //这个时候code继续加长
                }    
            
                //先标记p为2，如果p的右孩子不存在的话
            }
        
            /*
                当p的右孩子是0的时候，进行第三次访问，由于在第一个if中就已经用strcpy将code字符串的值给了HC的指针所以可以直接返回p
                并且在字符串的尾部加上‘\0’
            */
            else 
            {
                p=HT[p].parent;  //退回父亲之后，之前的在的code的最右边的值需要抹掉，重新让结点访问，相当于后进先出的栈结构
                cdlen--;
                code[cdlen]='\0';    
            }
        
        }
    
    }
    free(code);

    return OK;

}

void ShowHuffmanCode_HT(HuffmanTree HT,HuffmanCode HC){
    int i;
        printf(" ------------------------------------ \n");
    printf("┃*order┃weight┃      ┃  哈夫曼编码  ┃\n");
    for(i=1;i<=HT[0].weight;i++)
    {
        
            printf("┃%6d┃%6d┃----->%14s┃\n",i,HT[i].weight,HC[i]);    
    }
    printf(" ---------------------------------------- \n");



}

 

参考：http://www.cnblogs.com/kangjianwei101/p/5222014.html