哈弗曼树及其操作

1.哈弗曼树的节点声明

package com.neusoft.Tree;

public class HuffmanNode {
    public int weight;
    //加入哈夫曼树的标志，flag=0表示该节点没有加入哈夫曼树，=1表示加入
    public int flag;
    public HuffmanNode parent,lchild,rchild;
    public HuffmanNode() {
        this(0);
    }
    public HuffmanNode(int weight){
        this.weight=weight;
        flag=0;
        parent=lchild=rchild=null;
    }
}

点击可复制代码

package com.neusoft.Tree;

public class HuffmanNode {
    public int weight;
    //加入哈夫曼树的标志，flag=0表示该节点没有加入哈夫曼树，=1表示加入
    public int flag;
    public HuffmanNode parent,lchild,rchild;
    public HuffmanNode() {
        this(0);
    }
    public HuffmanNode(int weight){
        this.weight=weight;
        flag=0;
        parent=lchild=rchild=null;
    }
}

2.哈夫曼编码的构建及测试

package com.neusoft.Tree;
/**
 * @author zhao-chj
 * 哈夫曼树及其操作
 */
public class HuffmanTree {
    
    //求哈夫曼编码的算法，w存放n个字符的权值
    public int[][] huffmanCoding (int[] w){
        int n= w.length;//哈夫曼树的字符个数
        int m=2*n-1;//哈夫曼树的节点个数
        HuffmanNode[] HN =new HuffmanNode[m];
        int i=0;
        for (i = 0;  i< n; i++) {
            HN[i] = new HuffmanNode(w[i]);//构造n个具有权值的节点
        }
        for (i = n;  i< m; i++) {
            HuffmanNode min1=selectMin(HN,i-1);
            min1.flag=1;//表示已标记
            HuffmanNode min2=selectMin(HN, i-1);
            min2.flag=1;
            //构造min1和min2的父节点，并且修改权值
            HN[i] =new HuffmanNode();
            min1.parent=HN[i];
            min2.parent=HN[i];
            HN[i].lchild=min1;
            HN[i].rchild=min2;
            HN[i].weight=min1.weight+min2.weight;
        }
        //从叶子节点到根逆向求每个字符的哈夫曼编码
        int[][] HuffCode =new int[n][n];//分配n个字符编码存储空间
        for (int j = 0; j <n; j++) {
            int start=n-1;//编码的开始位置，初始化为数组的结尾
            for (HuffmanNode c=HN[j],p=c.parent; p!=null; c=p,p=p.parent) {
                //从叶子结点到根逆向求解编码
                if (p.lchild.equals(c)) {//左孩子编码为0
                    HuffCode[j][start--] =0;
                }else {
                    //右孩子编码为1
                    HuffCode[j][start--]=1;
                }
                HuffCode[j][start]=-1;//编码的开始标志为-1
            }
        }
        return HuffCode;
    }
    /**
     * 在HN[0...i-1]选择不再哈夫曼树中且weight最小的节点
     */
    private HuffmanNode selectMin(HuffmanNode[] HN, int end) {
        HuffmanNode min=HN[end];
        for (int i = 0; i < end; i++) {
            HuffmanNode h=HN[i];
            if (h.flag==0&&h.weight<min.weight) {
                //不再哈夫曼树中且weight最小的节点
                min=h;
            }
        }
        return min;
    }
    public static void main(String[] args) {
        int [] w={23,11,5,3,29,14,7,8};
        HuffmanTree T =new HuffmanTree();//构造哈夫曼树
        int [][] HN=T.huffmanCoding(w);//求哈夫曼编码
        System.out.println("哈夫曼编码为：");
        for (int i = 0; i < HN.length; i++) {
            System.out.print(w[i]+" ");
            for (int j = 0; j < HN[i].length; j++) {
                if (HN[i][j] ==-1 ) {//数组结尾标志
                    for (int k = j+1; k < HN[i].length; k++) {
                        System.out.print(HN[i][k]);
                    }
                    break;
                }
            }
            System.out.println();
        }
    }
}

点击可复制代码

package com.neusoft.Tree;
/**
 * @author zhao-chj
 * 哈夫曼树及其操作
 */
public class HuffmanTree {
    
    //求哈夫曼编码的算法，w存放n个字符的权值
    public int[][] huffmanCoding (int[] w){
        int n= w.length;//哈夫曼树的字符个数
        int m=2*n-1;//哈夫曼树的节点个数
        HuffmanNode[] HN =new HuffmanNode[m];
        int i=0;
        for (i = 0;  i< n; i++) {
            HN[i] = new HuffmanNode(w[i]);//构造n个具有权值的节点
        }
        for (i = n;  i< m; i++) {
            HuffmanNode min1=selectMin(HN,i-1);
            min1.flag=1;//表示已标记
            HuffmanNode min2=selectMin(HN, i-1);
            min2.flag=1;
            //构造min1和min2的父节点，并且修改权值
            HN[i] =new HuffmanNode();
            min1.parent=HN[i];
            min2.parent=HN[i];
            HN[i].lchild=min1;
            HN[i].rchild=min2;
            HN[i].weight=min1.weight+min2.weight;
        }
        //从叶子节点到根逆向求每个字符的哈夫曼编码
        int[][] HuffCode =new int[n][n];//分配n个字符编码存储空间
        for (int j = 0; j <n; j++) {
            int start=n-1;//编码的开始位置，初始化为数组的结尾
            for (HuffmanNode c=HN[j],p=c.parent; p!=null; c=p,p=p.parent) {
                //从叶子结点到根逆向求解编码
                if (p.lchild.equals(c)) {//左孩子编码为0
                    HuffCode[j][start--] =0;
                }else {
                    //右孩子编码为1
                    HuffCode[j][start--]=1;
                }
                HuffCode[j][start]=-1;//编码的开始标志为-1
            }
        }
        return HuffCode;
    }
    /**
     * 在HN[0...i-1]选择不再哈夫曼树中且weight最小的节点
     */
    private HuffmanNode selectMin(HuffmanNode[] HN, int end) {
        HuffmanNode min=HN[end];
        for (int i = 0; i < end; i++) {
            HuffmanNode h=HN[i];
            if (h.flag==0&&h.weight<min.weight) {
                //不再哈夫曼树中且weight最小的节点
                min=h;
            }
        }
        return min;
    }
    public static void main(String[] args) {
        int [] w={23,11,5,3,29,14,7,8};
        HuffmanTree T =new HuffmanTree();//构造哈夫曼树
        int [][] HN=T.huffmanCoding(w);//求哈夫曼编码
        System.out.println("哈夫曼编码为：");
        for (int i = 0; i < HN.length; i++) {
            System.out.print(w[i]+" ");
            for (int j = 0; j < HN[i].length; j++) {
                if (HN[i][j] ==-1 ) {//数组结尾标志
                    for (int k = j+1; k < HN[i].length; k++) {
                        System.out.print(HN[i][k]);
                    }
                    break;
                }
            }
            System.out.println();
        }
    }
}

3.测试及运行结果