复习系列2-DS二叉树——Huffman编码与解码

题目描述

1、问题描述

给定n个字符及其对应的权值，构造Huffman树，并进行huffman编码和译（解）码。

构造Huffman树时，要求左子树根的权值小于、等于右子树根的权值。

进行Huffman编码时，假定Huffman树的左分支上编码为‘0’，右分支上编码为‘1’。

2、算法

构造Huffman树算法：

⑴ 根据给定的n个权值(w1, w2, …, wn)构成n棵二叉树的集合F={T1, T2, …, Tn}，其中每棵二叉树Ti中只有一个权值为wi的根结点。

⑵ 在F中选取两棵根结点的权值最小的树，作为左、右子树构造一棵新的二叉树，且置其根结点的权值为其左、右子树权值之和。

⑶ 在F中删除这两棵树，同时将新得到的二叉树加入F中。

(4) 重复⑵, ⑶，直到F只含一棵树为止。

3、Huffman编码算法：

⑴ 从Huffman树的每一个叶子结点开始。

⑵ 依次沿结点到根的路径，判断该结点是父亲结点的左孩子还是右孩子，如果是左孩子则得到编码‘0’，否则得到编码‘1’，先得到的编码放在后面。

⑶ 直到到达根结点，编码序列即为该叶子结点对应的Huffman编码。

4、Huffman译（解）码算法：

⑴ 指针指向Huffman树的根结点，取第一个Huffman码。

⑵ 如果Huffman码为‘0’，将指针指向当前结点的左子树的根结点；如果Huffman码为‘1’，将指针指向当前结点的右子树的根结点。

⑶ 如果指针指向的当前结点为叶子结点，则输出叶子结点对应的字符；否则，取下一个Huffman码，并返回⑵。

⑷ 如果Huffman码序列未结束，则返回⑴继续译码。

输入

第一行测试次数

第2行：第一组测试数据的字符个数n，后跟n个字符

第3行：第一组测试数据的字符权重

待编码的字符串s1

编码串s2

其它组测试数据类推

输出

第一行~第n行,第一组测试数据各字符编码值

第n+1行，串s1的编码值

第n+2行，串s2的解码值，若解码不成功，输出error!

其它组测试数据类推

样例输入

2

 5 A B C D E

15 4 4 3 2

ABDEC

00000101100

4 A B C D

7 5 2 4

ABAD

1110110

样例输出

A :1

B :010

C :011

D :001

E :000

1010001000011

error!

A :0

B :10

C :110

D :111

0100111

DAC

提示

 

import java.util.*;

/**
 * @author: Liu Canbin
 * @date: 2019/1/4
 */

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int times = scanner.nextInt();
        for (int i = 0; i <times ; i++) {
            int n = scanner.nextInt();
            Node[] tree = new Node[2*n-1];//静态链表
            for (int j = 0; j <tree.length ; j++) {
                tree[j] = new Node();//使用自定义类的数组时，需要new
            }
            for (int j = 0; j < n; j++) {
                tree[j].sign = scanner.next();
            }
            for (int j = 0; j <n ; j++) {
                tree[j].value =scanner.nextInt();
                //初始化
                tree[j].left = -1;
                tree[j].parent = -1;
                tree[j].code = "";
            }
            //建立哈夫曼树,(n)-->(2n-1)，存放非叶子节点
            for (int j = 0; j <n-1 ; j++) {//循环n-1次即可
                // 0，2存放临时值，1，3存放最小值和次小值
                int[] min = {0x3f3f,0,0x3f3f,0};
                //一层循环查找最小值和次小值
                for (int k = 0; k <n+j ; k++) {
                    if (tree[k].value<min[0] && tree[k].parent==-1){//小于最小值
                        min[2] = min[0];
                        min[3] = min[1];
                        min[1] = k;
                        min[0] = tree[k].value;
                    }else if (tree[k].value<min[2] && tree[k].parent==-1){
                        min[3] = k;
                        min[2] = tree[k].value;
                    }
                }
                //给合并后的根赋值
                tree[min[1]].parent = n+j;
                tree[min[3]].parent = n+j;
                tree[n+j].value = tree[min[1]].value + tree[min[3]].value;
                tree[n+j].left = min[1];
                tree[n+j].right = min[3];
                tree[n+j].parent = -1;
                tree[n+j].code = "";
            }
//            //测试建树是否成功
//            for (int j = 0; j < 2*n-1; j++) {
//                System.out.print(tree[j].value+" ");
//            }
//            System.out.println();
            //编码
            for (int j = 0; j <n ; j++) {
                int k = j;
                //根节点不编码
                while (tree[k].parent!=-1){
                    if (tree[tree[k].parent].left == k){//左孩子
                        tree[j].code = "0"+tree[j].code;
                        k = tree[k].parent;
                    }else if (tree[tree[k].parent].right == k){//右孩子
                        tree[j].code = "1"+tree[j].code;
                        k = tree[k].parent;
                    }
                }
            }
            for (int j = 0; j <n ; j++) {
                System.out.println(tree[j].sign+" :"+tree[j].code.toString());
            }
            //根据输入的字符串进行编码
            String s1 = scanner.next();
            int j = 0;
            while (!s1.isEmpty()){
                for (j=0; j <n ; j++) {
                    if (s1.charAt(0) == tree[j].sign.charAt(0)){
                        System.out.print(tree[j].code);
                        break;
                    }
                }
                s1 = s1.substring(1,s1.length());
            }
            System.out.println();
            //解码输入的字符串
            String s2 = scanner.next();
            String sout="";
            int p = 2*n-2;//root
            while(!s2.isEmpty()){
                if (s2.charAt(0) == '0'){
                    p = tree[p].left;
                }else if (s2.charAt(0) == '1'){
                    p = tree[p].right;
                }
                if (tree[p].left==-1 ){
                    sout = sout + tree[p].sign;
                    p = 2*n-2;
                }
                s2 = s2.substring(1);
            }
            if (p == 2*n-2){
                System.out.println(sout);
            }else {
                System.out.println("error!");
            }
        }


    }
}

class Node {
    int value;
    String sign;
    int left;
    int right;
    int parent;
    String code;
//    StringBuffer code;
//
//    public void setCode(StringBuffer code) {
//        this.code = code;
//    }
}