[置顶] 哈夫曼树 之 建树和编解码

/* 实现过程：着先通过 HuffmanTree() 函数构造哈夫曼树，然后在主函数 main()中
 *自底向上开始(也就是从数组序号为零的结点开始)向上层层判断，若在
 *           父结点左侧，则置码为 0,若在右侧,则置码为 1。最后输出生成的编码。
 *------------------------------------------------------------------------*/
#include <stdio.h>
#include<stdlib.h>
#include<cstring>

const int MAXBIT = 100;
const int MAXVALUE = 10000;
const int MAXLEAF = 30;
const int MAXNODE = MAXLEAF*2 -1;

typedef struct
{
    int bit[MAXBIT];
    int start;
}HCodeType;   // 编码结构体
typedef struct
{
    int weight;
    int parent;
    int lchild;
    int rchild;
    int value;
}HNodeType;        // 结点结构体
// 输入并初始化
void node_input(HNodeType HuffNode[], const int &n)
{
    int i;
    for(i=0; i<n; i++)
    {
        printf ("Please input weight of leaf node %d: \n", i);
        scanf ("%d", &HuffNode[i].weight);//权值
        HuffNode[i].parent =-1;
        HuffNode[i].lchild =-1;
        HuffNode[i].rchild =-1;// 初始值为-1
        HuffNode[i].value=i; //现在用的是下标值，实际值，可根据情况替换为字母
    }
}
void out_put(HCodeType HuffCode[], const int &n)
{
    int i, j;
    for (i=0; i<n; i++)
    {
        printf ("%d 's Huffman code is: ", i);
        for (j=HuffCode[i].start+1; j < n; j++)
        {
            printf ("%d", HuffCode[i].bit[j]);
        }
        printf(" start:%d",HuffCode[i].start);
        printf ("\n");
    }
}
void min_two(HNodeType HuffNode[],  const int &n,const int &i, int &x1, int &x2)
{
    int j, m1, m2;
    m1=m2=MAXVALUE; //m1、m2中存放两个无父结点且结点权值最小的两个结点
    //找出所有结点中权值最小、无父结点的两个结点，并合并之为一颗二叉树
    for (j=0; j<n+i; j++)
    {
        if (HuffNode[j].weight < m1 && HuffNode[j].parent==-1)
        {
            m2=m1;
            x2=x1;
            m1=HuffNode[j].weight;
            x1=j;
        }
        else if (HuffNode[j].weight < m2 && HuffNode[j].parent==-1)
        {
            m2=HuffNode[j].weight;
            x2=j;
        }
    }
}
// 构造一颗哈夫曼树
void HuffmanTree(HNodeType HuffNode[],  const int &n)
{
    //i： 循环变量，m1、m2：构造哈夫曼树不同过程中两个最小权值结点的权值，
    //x1、x2：构造哈夫曼树不同过程中两个最小权值结点在数组中的序号。
    int i, x1, x2;
    //循环构造 Huffman 树
    for (i=0; i<n-1; i++)
    {
        x1=x2=0;
        min_two(HuffNode, n, i, x1, x2);
        /* 设置找到的两个子结点 x1、x2 的父结点信息 */
        HuffNode[x1].parent  = n+i;
        HuffNode[x2].parent  = n+i;
        HuffNode[n+i].weight = HuffNode[x1].weight + HuffNode[x2].weight;
        HuffNode[n+i].lchild = x1;
        HuffNode[n+i].rchild = x2;
        HuffNode[n+i].parent = -1;// 新节点的父亲是-1

        printf ("x1.weight and x2.weight in round %d: %d, %d\n", i+1, HuffNode[x1].weight, HuffNode[x2].weight);  /* 用于测试 */
        printf ("\n");
    }
    /*for(i=0;i<n+2;i++)
    {
        printf(" Parents:%d,lchild:%d,rchild:%d,value:%d,weight:%d\n",HuffNode[i].parent,HuffNode[i].lchild,HuffNode[i].rchild,HuffNode[i].value,HuffNode[i].weight);
    }*///测试
} // end HuffmanTree

// 编码
void encodeing(HNodeType HuffNode[], HCodeType HuffCode[], const int &n)
{
    int i, j, c, p;
    HCodeType cd;
    for (i=0; i < n; i++)
    {
        cd.start = n-1;
        c = i;
        p = HuffNode[c].parent;
        while (p != -1)   //父结点存在
        {
            if (HuffNode[p].lchild == c)
                cd.bit[cd.start] = 0;
            else
                cd.bit[cd.start] = 1;
            cd.start--;   //求编码的低一位
            c=p;
            p=HuffNode[c].parent; // 设置下一循环条件
        } // end while
        // 保存求出的每个叶结点的哈夫曼编码和编码的起始位
        for (j=cd.start+1; j<n; j++)
        {
             HuffCode[i].bit[j] = cd.bit[j];
        }
        HuffCode[i].start = cd.start;
    }
}
//解码
void decodeing(char string[],HNodeType Buf[],int Num)
{
      int i,tmp=0,code[1024];
      int m=2*Num-1;
      char *nump;
      char num[1024];
      for(i=0;i<strlen(string);i++)
      {
          if(string[i]=='0')
            num[i]=0;
          else if(string[i] == '1')
            num[i]=1;
          else
             return;
      }// 转化为数字
      i=0;
      nump=&num[0];
      while(nump<(&num[strlen(string)]))
      {
        tmp=m-1;
        while((Buf[tmp].lchild!=-1)&&(Buf[tmp].rchild!=-1))
        {
           if(*nump==0)
           {
                tmp=Buf[tmp].lchild ;
           }
           else 
                tmp=Buf[tmp].rchild;
           nump++;
        }
          printf("%d",Buf[tmp].value);
     }
}

int main(void)
{
    HNodeType HuffNode[MAXNODE];     //定义一个结点结构体数组
    HCodeType HuffCode[MAXLEAF],  cd; // 定义一个编码结构体数组， 同时定义一个临时变量来存放求解编码时的信息
    int i, j, n;
    char pp[100];
    printf ("Please input n:\n");
    scanf ("%d", &n);
    // 输入n个节点
    node_input(HuffNode, n);
    // 构造哈夫曼树
    HuffmanTree(HuffNode, n);
    //编码
    encodeing(HuffNode,HuffCode,n);
    // 输出已保存好的所有存在编码的哈夫曼编码
    out_put(HuffCode,n);
    // 解码过程
    printf("Decoding?Please Enter code:\n");
    scanf("%s",&pp);
    decodeing(pp,HuffNode,n);
    return 0;
}

（1）注释： voidmin_two(HNodeTypeHuffNode[], constint&n,constint &i,int&x1,int&x2) ，可以通过最小堆 把算法复杂度降为O(nlogn)

（2）步骤分为：构造初始的哈夫曼树；哈夫曼编码；哈夫曼解码

（3）构造初始的哈夫曼树：根据输入的节点个数和weight值，并初始化parent  lchild rchild为-1，value值暂时空留；每一次根据当前两个最小的weight新建一个新的parent节点，该parent的左右孩子就是这两个值，weight是两者之和，其parent为-1，孩子的parent改为这个节点，重复直到……

（4）哈夫曼编码：遍历所有叶子节点（之前存在一个数组中），逆向编码再正向保存一下，从叶子开始往上找父节点；判断父节点是否存在，若存在，根据父节点判断是其左孩子还是右孩子。逆向编码再正向保存一下

（5）哈夫曼解码：就是应用的所在了，给你一个01序列，求出它的真正字符值。

二 其它相关的树的blog：

（1）关于二叉树的操作，大部分集中在前序、中序和后序遍历的基础之上的（前，中，后是按照根节点被访问的顺序定义的）；大部分是用递归的方法实现的，非递归得借助于队列或者栈来实现；注意递归的回退条件，以及返回值的类型（bool,int void）等；当返回值不够用的时候，就得借助于参数的传递了。

（2）这非常类似于图的操作，无非就是建立在BFS广度优先搜索和DFS深度优先搜索的基础之上的，增加一些附加的操作或者判断进行的。

（3）链表的操作，就是基于指针遍历的操作，当一个指针不能够解决问题时，就得需要一快一慢两个指针进行；删除等操作需要前向指针的。

（4）并查集也是一个不错的思想的。。。

 （5）二叉树的非递归前序遍历，前序遍历思想：先让根进栈，只要栈不为空，就可以做弹出操每次弹出一个结点，记得把它的左右结点都进栈，记得右子树先进栈，这样可以保证右子树在栈中总处于左子树的下面。二叉树的非递归中序遍历与前序类似，更改了遍历位置而已；后续就出入比较大啦，不知道啥时候该不该弹出；层次遍历就需要队列了

//二叉树结点的描述  
typedef struct BiTNode
{  
    char data;  
    struct BiTNode *lchild, *rchild;      //左右孩子  
}BiTNode,*BiTree;  
  
//按先序遍历创建二叉树  
//BiTree *CreateBiTree()     //返回结点指针类型  
//void CreateBiTree(BiTree &root)      //引用类型的参数  
void CreateBiTree(BiTNode **root)    //二级指针作为函数参数  
{  
    char ch; //要插入的数据  
    scanf("\n%c", &ch);
    //cin>>ch;  
    if(ch=='#')
        *root = NULL;
    else
    {
        *root = (BiTNode *)malloc(sizeof(BiTNode));
        (*root)->data = ch;
        printf("请输入%c的左孩子：",ch);
        CreateBiTree(&((*root)->lchild));
        printf("请输入%c的右孩子：",ch);
        CreateBiTree(&((*root)->rchild));
    }
}
  
//前序遍历的算法程序  
void PreOrder(BiTNode *root)
{  
    if(root==NULL)  
        return ;  
    printf("%c ", root->data); //输出数据  
    PreOrder(root->lchild); //递归调用，前序遍历左子树  
    PreOrder(root->rchild); //递归调用，前序遍历右子树  
}  
  
//中序遍历的算法程序  
void InOrder(BiTNode *root)  
{  
    if(root==NULL)
        return ;
    InOrder(root->lchild); //递归调用，前序遍历左子树  
    printf("%c ", root->data); //输出数据  
    InOrder(root->rchild); //递归调用，前序遍历右子树  
}  
  
//后序遍历的算法程序  
void PostOrder(BiTNode *root)
{
    if(root==NULL)
        return ;
    PostOrder(root->lchild);      //递归调用，前序遍历左子树  
    PostOrder(root->rchild);      //递归调用，前序遍历右子树  
    printf("%c ", root->data);    //输出数据    
}  
  

void PreOrder_Nonrecursive(BiTree T)     //先序遍历的非递归    
{  
    if(!T)    
        return ;    
    
    stack<BiTree> s;  
    s.push(T);  
  
    while(!s.empty())  
    {  
        BiTree temp = s.top();  
        cout<<temp->data<<" ";  
        s.pop();  
        if(temp->rchild)  
            s.push(temp->rchild);  
        if(temp->lchild)  
            s.push(temp->lchild);  
    }  
}  

void InOrderTraverse1(BiTree T)   // 中序遍历的非递归  
{  
    if(!T)  
        return ;  
    BiTree curr = T;    // 指向当前要检查的节点  
    stack<BiTree> s;
	while(curr != NULL || !s.empty())
	{
		while(curr != NULL)
		{
			s.push(curr);
			curr = curr->lchild;
		}//while
		if(!s.empty())
		{
			curr = s.top();
			s.pop();
			cout<<curr->data<<"  ";
			curr = curr->rchild;
		}
	}
}

 

void PostOrder_Nonrecursive1(BiTree T)  // 后序遍历的非递归    
{    
    stack<BiTree> S;    
    BiTree curr = T ;           // 指向当前要检查的节点  
    BiTree previsited = NULL;    // 指向前一个被访问的节点  
    while(curr != NULL || !S.empty())  // 栈空时结束    
    {    
        while(curr != NULL)            // 一直向左走直到为空  
        {    
            S.push(curr);    
            curr = curr->lchild;    
        }    
        curr = S.top();  
        // 当前节点的右孩子如果为空或者已经被访问，则访问当前节点  
        if(curr->rchild == NULL || curr->rchild == previsited)    
        {    
            cout<<curr->data<<"  ";    
            previsited = curr;    
            S.pop();    
            curr = NULL;    
        }    
        else  
            curr = curr->rchild;      // 否则访问右孩子  
    }    
}   
  
void PostOrder_Nonrecursive(BiTree T)  // 后序遍历的非递归     双栈法  
{    
    stack<BiTree> s1 , s2;    
    BiTree curr ;           // 指向当前要检查的节点  
    s1.push(T);  
    while(!s1.empty())  // 栈空时结束    
    {  
        curr = s1.top();  
        s1.pop();  
        s2.push(curr);  
        if(curr->lchild)  
            s1.push(curr->lchild);  
        if(curr->rchild)  
            s1.push(curr->rchild);  
    }  
    while(!s2.empty())  
    {  
        printf("%c ", s2.top()->data);  
        s2.pop();  
    }  
}  
  
  
int visit(BiTree T)  
{  
    if(T)  
    {  
        printf("%c ",T->data);  
        return 1;  
    }  
    else  
        return 0;  
}  
  
void LeverTraverse(BiTree T)   //方法一、非递归层次遍历二叉树   
{  
    queue <BiTree> Q;  
    BiTree p;  
    p = T;  
    if(visit(p)==1)  
        Q.push(p);  
    while(!Q.empty())  
    {  
        p = Q.front();  
        Q.pop();  
        if(visit(p->lchild) == 1)   
            Q.push(p->lchild);  
        if(visit(p->rchild) == 1)  
            Q.push(p->rchild);  
    }  
}  

int depth(BiTNode *T)   //树的深度  
{  
    if(!T)  
        return 0;  
    int d1,d2;  
    d1=depth(T->lchild);  
    d2=depth(T->rchild);  
    return (d1>d2?d1:d2)+1;  
    //return (depth(T->lchild)>depth(T->rchild)?depth(T->lchild):depth(T->rchild))+1;  
}  
int CountNode(BiTNode *T)  
{  
    if(T == NULL)  
        return 0;  
    return 1+CountNode(T->lchild)+CountNode(T->rchild);  
}  

（0）目录

由前序和中序构造一棵树 后续遍历

字典树Trie 之 基础模板（插入，查找，删除）

字典树（Trie） 之 统计单词的个数

图算法小结(prime与dijkstra对比)

图算法小结(并查集)

哈夫曼树 之 建树和编解码