13.5 赫夫曼編碼

基本介紹：

1. 赫夫曼編碼也翻譯為 哈夫曼編碼(Huffman Coding)，又稱霍夫曼編碼，是一種編碼方式，屬於程式演算法

2. 赫夫曼編碼是赫夫曼樹在電訊通訊中的經典應用一致

3. 赫夫曼編碼廣泛的應用與資料檔案壓縮，其 壓縮率通常在20%~90%之間

4. 赫夫曼是 可變字長編碼(VLC)的一種。Huffman與1952年提出一種編碼方式稱之為 最佳編碼

線上轉碼工具

赫夫曼編碼壓縮思路例：

1. 獲取一個字串i like like like java do you like a java

2. 然後統計各個字母出現的次數d:1 y:1 u:1 j:2 v:2 o:2 l:4 k:4 e:4 i:5 a:5 (空格):9

3. 按照上面字元出現的次數當作葉子節點權值構建一顆霍夫曼樹

4. 根據赫夫曼樹（ 構建的赫夫曼樹不一樣，編碼也可能不一樣，因為可能存在兩個相等的左右節點，所以赫夫曼樹可能不一樣，但是wpl是一樣的，都是最小的），給各個字元規定編碼，向左的路徑為0，向右的路徑為1，編碼如下：

   o:1000 u:10010 d:100110 y:100111 i:101 a:110 k:1110 e:1111 j:0000 v:0001 l:001 (空格):01(不難看出不存在一個編碼是另一個編碼的字首)

5. 按照上面的赫夫曼編碼，我們將i like like like java do you like a java字串對應的編碼（赫夫曼編碼是無失真壓縮）,通過赫夫曼長度變成 133，而使用 AscII

   碼出來的長度是359

(1) Node{data(存放資料), weight(權值), left 和 right}

(2) 得到 i like like like java do you like a java對應的byte[] 陣列

(3) 編寫一個方法，將準備構建赫夫曼樹的Node 節點放到 List , 形式[Node[data=97,weight=5], Node[data=32,weight=9]......],體現d:1 y:1 u:1 j:2 v:2 o:2 l:4 k:4 e:4 i:5 a:5 (空格):9

(4) 可以通過List建立對應的赫夫曼樹

package huffmancode;

import java.util.*;

public class HuffmanCode {
    public static void main(String[] args) {
        String content = "i like like like java do you like a java";
        byte[] contentBytes = content.getBytes();
        System.out.println(contentBytes.length);

        byte[] huffmanCodeBytes = huffmanZip(contentBytes);
        System.out.println("壓縮後的編碼為"+Arrays.toString(huffmanCodeBytes));
        System.out.println("長度為："+huffmanCodeBytes.length);
        // 分佈過程
/*
        List<Node> nodes = getNode(contentBytes);
        System.out.println(nodes);
        Node huffmanTreeRoot = createHuffmanTree(nodes);
        System.out.println("前序遍歷");
        huffmanTreeRoot.preOrder();

        // 測試是否生成了對應的赫夫曼編碼
        Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);
        System.out.println("~生成的赫夫曼編碼表："+ huffmanCodes);

        // 測試
        huffmanCodeBytes = zip(contentBytes, huffmanCodes);
        System.out.println("huffmanCodeBytes="+Arrays.toString(huffmanCodeBytes));

        // 傳送 HuffmanCodeBytes 陣列
*/
    }
    // 使用一個方法，將前面的方法封裝起來，便於我們的呼叫

    /**
     *
     * @param bytes 原始的字串對應的位元組陣列
     * @return 是經過 赫夫曼編碼 處理後的位元組陣列（壓縮後的陣列）
     */
    private static byte[] huffmanZip(byte[] bytes){
        List<Node> nodes = getNode(bytes);
        // 根據 nodes 建立赫夫曼樹
        Node huffmanTreeRoot = createHuffmanTree(nodes);
        // 根據赫夫曼樹建立赫夫曼編碼
        Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);
        // 根據生成的赫夫曼編碼，壓縮得到壓縮後的赫夫曼編碼位元組陣列
        byte[] huffmanCodeBytes = zip(bytes,huffmanCodes);
        return huffmanCodeBytes;
    }
    // 編寫一個方法，將一個字串對應的byte[] 陣列，通過生成的赫夫曼編碼表，返回一個赫夫曼編碼，壓縮後的byte[]陣列
    /**
     *
     * @param bytes 這是原始的字串對應的 byte[]
     * @param huffmanCodes  生成的赫夫曼編碼 map
     * @return 返回赫夫曼編碼處理後的 byte[]
     */
    private static byte[] zip(byte[] bytes, Map<Byte,String> huffmanCodes){

        // 1. 利用 huffmanCodes 將 bytes 轉成 赫夫曼編碼對應的字串
        StringBuilder stringBuilder = new StringBuilder();
        // 遍歷 bytes 陣列
        for (byte b: bytes){
            stringBuilder.append(huffmanCodes.get(b));
        }
        System.out.println(stringBuilder.toString());
        // 將 "101010001011111110..."轉成 byte[]
        // 統計返回的 byte[] huffmanCodeBytes 長度
        int len;
        // 下面程式碼一句話搞定就是 len = (stringBuilder.length() + 7) / 8
        if (stringBuilder.length() % 8 == 0){
            len = stringBuilder.length() / 8;
        } else {
            len = stringBuilder.length() / 8 + 1;
        }
        // 建立一個儲存壓縮後的 byte陣列
        byte[] huffmanCodeBytes = new byte[len];
        int index = 0; // 記錄是第幾個byte
        for (int i = 0; i < stringBuilder.length(); i += 8){
            // 因為是每8為對應一個byte
            String strByte;
            if (i + 8 > stringBuilder.length()){
                // 不夠8位了，那麼有多少取多少
                strByte = stringBuilder.substring(i);
            } else {
                strByte = stringBuilder.substring(i, i + 8);
            }

            // 將strByte轉成一個 byte 放入到 huffmanCodeBytes
            huffmanCodeBytes[index] = (byte)Integer.parseInt(strByte,2);
            index++;
        }
        return huffmanCodeBytes;
    }

    /**
     *
     * @param bytes 接受位元組陣列
     * @return  返回是一個list形式
     */
    private static List<Node> getNode(byte[] bytes){
        // 建立一個ArrayList
        ArrayList<Node> nodes = new ArrayList<>();
        // 儲存每個byte出現的次數  -> map
        Map<Byte,Integer> counts = new HashMap<>();
        for (byte b: bytes){
            Integer count = counts.get(b);
            if (count == null){
                // 說明map還沒有該字元資料
                counts.put(b,1);
            } else {
                counts.put(b, count+1);
            }
        }

        // 把每個鍵值對，轉成一個node物件並加入弄得集合
        // 遍歷map
        for (Map.Entry<Byte,Integer> entry:counts.entrySet()){
            nodes.add(new Node(entry.getKey(),entry.getValue()));
        }
        return nodes;
    }
    // 建立赫夫曼樹
    private static Node createHuffmanTree(List<Node> nodes){
        while(nodes.size() > 1){
            // 排序（從小到大）
            Collections.sort(nodes);
            // 取出左右節點
            Node leftNode = nodes.get(0);
            Node rightNode = nodes.get(1);

            Node parent = new Node(null,leftNode.weight + rightNode.weight);
            parent.left = leftNode;
            parent.right = rightNode;
            // 刪除左右節點
            nodes.remove(leftNode);
            nodes.remove(rightNode);
            // 將新的節點加入
            nodes.add(parent);

        }
        return nodes.get(0);
    }
    //前序遍歷
    private static void preOrder(Node root){
        if (root != null){
            root.preOrder();
        }else{
            System.out.println("赫夫曼樹為空");
        }
    }
    // 生成赫夫曼樹對應的赫夫曼編碼
    //思路：
    // 1. 將赫夫曼編碼表存放在 Map<Byte,String>
    static Map<Byte,String> huffmanCodes = new HashMap<Byte, String>();
    // 2. 在生成赫夫曼編碼表時，需要去拼接路徑，定義一個 StringBuilder 儲存某個葉子節點的路徑
    static StringBuilder stringBuilder = new StringBuilder();

    // 為了方便，過載getCodes
    private static Map<Byte,String> getCodes(Node root){
        if (root == null){
            return null;
        }
        // 處理root左子樹
        getCodes(root.left,"0",stringBuilder);
        // 處理root右子樹
        getCodes(root.right, "1", stringBuilder);

        return huffmanCodes;
    }
    /**
     * 功能：將傳入的node結點的所有葉子節點的赫夫曼編碼得到，並放入到huffmanCodes
     * @param node  傳入的節點（預設跟結點開始）
     * @param code  代表路徑；左子節點代表0，右子節點表示1
     * @param stringBuilder 用於拼接路徑的
     */
    private static void getCodes(Node node, String code, StringBuilder stringBuilder){
        StringBuilder stringBuilder2 = new StringBuilder(stringBuilder);
        // 將code加入到 stringBuilder2
        stringBuilder2.append(code);
        if (node != null){ // 如果 node == null 不處理
            // 判斷當前 node 是葉子節點還是非葉子節點
            if (node.data == null){
                // 非葉子節點，遞迴處理
                // 向左遞迴
                getCodes(node.left,"0",stringBuilder2);
                // 向右遞迴
                getCodes(node.right,"1",stringBuilder2);
            } else {
                // 說明是葉子節點
                // 就表示找到了某個葉子節點
                huffmanCodes.put(node.data,stringBuilder2.toString());
            }

        }
    }

}
// 建立Node,存放資料和權值
class Node implements Comparable<Node>{
    Byte data; // 存放資料本身看，比如'a' = 97 ' (空格)'= 32
    int weight; // 權值，表示字元出現的次數
    Node left;
    Node right;

    public Node(Byte data, int weight) {
        this.data = data;
        this.weight = weight;
    }

    @Override
    public int compareTo(Node o) {
        // 按照從小到大排序
        return this.weight - o.weight;
    }

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                ", weight=" + weight +
                '}';
    }
    //前序遍歷
    public void preOrder(){
        System.out.println(this);
        if (this.left != null){
            this.left.preOrder();
        }
        if (this.right != null){
            this.right.preOrder();
        }
    }

}