java 哈夫曼编码

//哈夫曼树类
public class HaffmanTree {
    //最大权值
    static final int MAXVALUE=1000;
    int nodeNum ; //叶子结点个数
    
    public HaffmanTree(int n)
    {
       this.nodeNum = n;
    }
    
    //构造哈夫曼树算法
    public void haffman(int[] weight,HaffNode[] nodes)//权值数组，所有节点数组
    {
        int n = this.nodeNum;
        //m1,m2,表示最小的两个权值，x1,x2,表示最小两个权值对应的编号,m1表示最小，m2表示次小
        int m1,m2,x1,x2; 
        
        //初始化所有的结点，对应有n个叶子结点的哈夫曼树，有2n-1个结点。
        for(int i=0;i < 2*n-1;i++)
        {
            HaffNode temp = new HaffNode();
            //初始化n个叶子结点，就是输入的节点。0、1、2、3是叶子节点也是输入的节点
            if(i < n)
            {
               temp.weight = weight[i];    
            }
            else
            {
               temp.weight = 0;    
            }
            temp.parent = 0;
            temp.flag = 0;
            temp.leftChild = -1;
            temp.rightChild = -1;
            nodes[i] = temp;
        }
        
        for(int i=0;i<n-1;i++){//初始化n-1个非叶子结点，n-1表示要循环n-1次求的n-1个数。
           m1 = m2 = MAXVALUE;
           x1 = x2 =0;
           for(int j=0;j< n+i;j++)//求得这n-1个数时，每次都是从0到n+i-1,并且flag=0的，flag=1表示已经加入到二叉树。
           {   //以下2步是找出权值最小的2个
               if(nodes[j].weight<m1 && nodes[j].flag==0)//if成立了else、else if就不进去了。
               {
                //m1,x1初始值为第一个元素，后面如果比m1要小，则m1指向更小的，原来m1指向的现在由m2指向，
                //如果后面比m1大比m2小，则m2指向这个比m1大比m2小的，
                //也就是说m1指向最小的，m2指向第2小的。
                  m2 = m1;
                  x2 = x1;
                  m1 = nodes[j].weight;
                  x1 = j;
               }
               else if(nodes[j].weight<m2 && nodes[j].flag ==0)
               {
                  m2 = nodes[j].weight;
                  x2 = j;
               }
           }
           //将权值最小的2个组合成一个2插树
           nodes[x1].parent = n+i;
           nodes[x2].parent = n+i;
           nodes[x1].flag = 1;
           nodes[x2].flag = 1;
           nodes[n+i].weight = nodes[x1].weight + nodes[x2].weight;
           nodes[n+i].leftChild = x1;
           nodes[n+i].rightChild = x2;
        }
        /*
        初始化数组之后：[1,3,5,7,4,9,16]
        编码：100、101、11、0
        */
    }
    
    //哈弗曼编码算法
    public void haffmanCode(HaffNode[] nodes,Code[] haffCode)
    {
        int n = this.nodeNum;
        Code code = new Code(n);//4
        int child,parent;
        
        for(int i=0;i<n; i++)//给前面n个输入的节点进行编码
        {
           code.start = n-1;//3
           code.weight = nodes[i].weight;//1
           child = i;//0
           parent = nodes[child].parent;
           //从叶子节点向上走来生成编码，画图即可。
           while(parent!=0)
           {
              if(nodes[parent].leftChild == child)
              {
                  code.bit[code.start] = 0;
              }
              else
              {
                  code.bit[code.start] = 1;
              }
              
              code.start--; 
              child = parent;
              parent = nodes[child].parent;
           }
           
           Code temp = new Code(n);
           for(int j=code.start+1;j < n;j++)
           {
               temp.bit[j] = code.bit[j];
           }
           temp.weight = code.weight;
           temp.start = code.start;
           haffCode[i] = temp;
        }
    }
}




//哈夫曼树的结点类
public class HaffNode {
   
    int weight; //权值
    int parent ;//他的双亲
    int flag ;//标志，是否为叶子节点
    int leftChild; //他的左孩子
    int rightChild;//他的右孩子
    
    HaffNode()
    {
        
    }
    
}



//哈夫曼编码类
public class Code {

    int[] bit;  //编码的数组
    int start;  //编码的开始下标
    int weight; //权值
    Code(int n){
        bit = new int[n];
        start = n-1;
    }
}




public class Test {

    public static void main(String[] args) {
        
        int n = 4;
        int[] weight = {1,3,5,7};
        HaffmanTree haffTree = new HaffmanTree(n);
        HaffNode[] nodes = new HaffNode[2*n-1];
        Code[] codes = new Code[n]; 
        //构造哈夫曼树
        haffTree.haffman(weight, nodes);
        //生成哈夫曼编码
        haffTree.haffmanCode(nodes, codes);
        
        //打印哈夫曼编码
        for(int i=0;i<n;i++)
        {
            System.out.print("Weight="+codes[i].weight+" Code=");
            for(int j=codes[i].start+1;j<n;j++)
            {
               System.out.print(codes[i].bit[j]);    
            }
            System.out.println();
        }
    }

}

哈夫曼树：

带权路径长度是做小的，要使一棵二叉树的带权路径长度WPL值最小，必须使权值越大的叶结点越靠近根结点。哈夫曼提出的构造哈夫曼树构造算法为：
（1）由给定的n个权值{w1,w2,…,wn}构造n棵只有根 结点的二叉树，从而得到一个二叉树森林F={T1,T2,…,Tn}。
（2）在二叉树森林F中选取根结点的权值最小和次小的两棵二叉树作为新的二叉树的左右子树构造新的二叉树，新的二叉树的根结点权值为左右子树根结点权值之和。
（3）在二叉树森林F中删除作为新二叉树左右子树的两棵二叉树，将新二叉树加入到二叉树森林F中。
（4）重复步骤（2）和（3），当二叉树森林F中只剩下一棵二叉树时，这棵二叉树就是所构造的哈夫曼树。

 

哈夫曼编码问题：

哈夫曼树可用于构造代码总长度最短的编码方案。具体构造方法如下：
设需要编码的字符集合为{d1,d2,…,dn}，各个字符在电文中出现的次数集合为{w1,w2,…,wn}，以d1,d2,…,dn作为叶结点，以w1,w2,…,wn作为各叶结点的权值构造一棵二叉树，规定哈夫曼树中的左分支为0，右分支为1，则从根结点到每个叶结点所经过的分支对应的0和1组成的序列便为该结点对应字符的编码。这样的代码总长度最短的不等长编码称之为哈夫曼编码。