《算法》筆記 17 - 數據壓縮

時間 2020-01-27

標籤算法筆記數據壓縮简体版

原文原文鏈接

讀寫二進制數據
基因組數據的壓縮
遊程編碼
- 位圖
霍夫曼壓縮
- 前綴碼和單詞查找樹
- 構造前綴碼的單詞查找樹
- 寫入和讀取單詞查找樹
- 使用前綴碼壓縮
- 使用前綴碼展開
LZW壓縮
- LZW的單詞查找樹
- LZW的單詞查找樹
- LZW壓縮的展開

對數據進行壓縮可以有效節省保存信息所需的空間和傳輸信息所需的時間。雖然計算機存儲設備的成本在不斷下降，但因爲須要存儲的數據在飛速膨脹，壓縮算法仍有很是重要的意義，由於與以往相比，數據被壓縮後節省的空間會更大。java

讀寫二進制數據

現代計算機系統中處理的全部類型的數據最終都是用二進制表示的，能夠將它們都看做一串比特的序列。c++

數據壓縮分爲無損壓縮和有損壓縮，前者在壓縮、展開後不會丟失任何信息，但後者否則。有損壓縮常被用於圖像、視頻、音樂的壓縮。對於無損壓縮算法，評價的標準爲壓縮率，壓縮率=壓縮後體積/原始體積；對於有損壓縮算法，評價標準除了壓縮率外，還有主觀的質量感覺等。
接下來只討論無損壓縮算法。算法

以前的算法設計輸入輸出時，使用的都是基於java基礎方法封裝的StdIn和StdOut，它們處理的是由Unicode編碼的字符流；但因爲壓縮算法會涉及到對比特流的操做，因此接下來使用BinaryStdIn和BinaryStdOut，BinaryStdIn.readBoolean()方法會從輸入中讀取一個比特並返回爲布爾值，BinaryStdOut.write(boolean b)方法則會向輸出中寫入一個比特。數組

基因組數據的壓縮

接下來從初級的基因組壓縮算法開始，由於表示基因組的字符集只含有A C T G四個字符。這種方法也適用於字符集大小固定且數量有限的場合。
若是將這四個字符直接用ASCII編碼，須要4×8=32位，但其實只須要用兩個位就能夠表示4個值（2^2=4）。這樣4個字符只須要2×4=8位就能夠了，壓縮率=8/32=25%。
由此可得對基因組數據的壓縮方法：ui

public static void compress(){
    Alphabet DNA=new Alphabet("ACTG");
    String s=BinaryStdIn.readString();
    int N=s.length();
    BinaryStdOut.write(N);
    
    for(int i=0;i<N;i++){
        int d=DNA.toIndex(s.charAt(i));
        BinaryStdOut.write(d,DNA.lgR());
    }
    BinaryStdOut.close();
}

實例化Alphabet類時，指定字符集只有ACTG這四個，DNA.lgR()就等於2，每次輸出2個比特。好比遇到字符A，就用0表示，二進制編碼爲00，字符B用1表示，二進制編碼爲01等等。this

展開時，每次讀取2個比特，轉換爲整型數字，而後根據這個數字去字符集中取得對應的字符。編碼

public static void expand(){
    Alphabet DNA=new Alphabet("ACTG");
    int w=DNA.lgR();
    int N=BinaryStdIn.readInt();
    for(int i=0;i<N;i++){
        char c=BinaryStdIn.readChar(w);
        StdOut.println("c="+c);
        char e=DNA.toChar(c);
        StdOut.println("e="+e);
        BinaryStdOut.write(DNA.toChar(c));
    }
    BinaryStdOut.close();
}

遊程編碼

比特流中最簡單的冗餘形式就是一長串重複的比特，遊程編碼就是利用這種冗餘來壓縮數據的經典方法，在對位圖的壓縮中有很好的效果。設計

位圖

位圖常常用於保存圖像和掃描文檔，下面是一張最簡單的位圖，分辨率爲32×48，圖像爲一個「q」字符，用按行排列的比特流來表示位圖數據，因此這張簡單的位圖是沒有顏色信息的，或者說只有兩種顏色。code

00000000000000000000000000000000
00000000000000000000000000000000
00000000000000011111110000000000
00000000000011111111111111100000
00000000001111000011111111100000
00000000111100000000011111100000
00000001110000000000001111100000
00000011110000000000001111100000
00000111100000000000001111100000
00001111000000000000001111100000
00001111000000000000001111100000
00011110000000000000001111100000
00011110000000000000001111100000
00111110000000000000001111100000
00111110000000000000001111100000
00111110000000000000001111100000
00111110000000000000001111100000
00111110000000000000001111100000
00111110000000000000001111100000
00111110000000000000001111100000
00111110000000000000001111100000
00111111000000000000001111100000
00111111000000000000001111100000
00011111100000000000001111100000
00011111100000000000001111100000
00001111110000000000001111100000
00001111111000000000001111100000
00000111111100000000001111100000
00000011111111000000011111100000
00000001111111111111111111100000
00000000011111111111001111100000
00000000000011111000001111100000
00000000000000000000001111100000
00000000000000000000001111100000
00000000000000000000001111100000
00000000000000000000001111100000
00000000000000000000001111100000
00000000000000000000001111100000
00000000000000000000001111100000
00000000000000000000001111100000
00000000000000000000001111100000
00000000000000000000001111100000
00000000000000000000001111100000
00000000000000000000011111110000
00000000000000000011111111111100
00000000000000000111111111111110
00000000000000000000000000000000
00000000000000000000000000000000

取這個位圖中的第5行來分析視頻

00000000001111000011111111100000

這條長度32的字符串中，含有：10個0 - 4個1 - 4個0 - 9個1 - 5個0。全部的比特字符串都是相似這樣，0和1交替出現，因此對於這條字符串，就能夠編碼爲10，4，4，9，5，若是用4比特表示長度，並以連續的0做爲開頭，就能夠獲得一個20位長的字符串（不包含逗號）：1010,0100,0100,1001,0101。壓縮率=20/32=62.5%。

4位編碼能表示的值只有0到15，在實際的應用中是不夠的，因此使用8位編碼，能夠表示0-255之間的遊程長度。若是遊程的長度超過256，就插入一個長度爲0的遊程，這樣能夠確保全部的遊程長度都不超過256。

使用遊程編碼壓縮的代碼以下：

public static void compress() {
    char cnt = 0;
    boolean b, old = false;
    while (!BinaryStdIn.isEmpty()) {
        b = BinaryStdIn.readBoolean();
        if (b != old) {
            BinaryStdOut.write(cnt);
            cnt = 0;
            old = !old;
        } else {
            if (cnt == 255) {
                BinaryStdOut.write(cnt);
                cnt = 0;
                BinaryStdOut.write(cnt);
            }
        }
        cnt++;
    }
    BinaryStdOut.write(cnt);
    BinaryStdOut.close();
}

算法會逐個讀取比特位，若是它和上一個比特相同，就把遊程計數器cnt加1；若是計數器已滿，就將其輸出爲編碼，而後計數器歸零，並輸出一個長度爲0的遊程來分割過長的相同編碼；若是它和上一個比特不一樣，就將計數器的值輸出而後歸零。

展開的代碼爲：

public static void expand() {
    boolean b = false;
    while (!BinaryStdIn.isEmpty()) {
        char cnt = BinaryStdIn.readChar();
        for (int i = 0; i < cnt; i++)
            BinaryStdOut.write(b);
        b = !b;
    }
    BinaryStdOut.close();
}

展開時每次讀取一個遊程的長度（8位編碼），先輸出比特0，按照遊程指定的長度輸出完畢後，切換狀態，繼續輸出。

遊程編碼被普遍用於位圖的壓縮，這種壓縮方式還有一項特殊的優點在於，隨着位圖分辨率的提升，它的效果也會大大提升。若是位圖分辨率增長一倍，它的總比特數將變爲原來的4倍，但遊程的數量只會變爲原來的2倍，由於橫向的比特數增長不會影響遊程的數量，只會影響遊程的長度，這樣壓縮後的比特數量變爲約原來的2倍，因此壓縮率減半。
但遊程編碼只在遊程較長時效果較好，若是遊程很短，這種算法可能反而會增長比特數。

霍夫曼壓縮

前綴碼和單詞查找樹

雖然遊程編碼在許多場景很是有效，但有的時候須要壓縮的數據特徵並不具備較長的遊程，好比英文文檔等天然語言文件，霍夫曼壓縮算法和LZW壓縮算法對這種特徵的數據也能取得很好的效果。
霍夫曼壓縮的主要思想是，放棄文本文件的普通保存方式，再也不使用7位或8位二進制數表示一個字符，而是用較少的比特表示出現頻率高的字符，用較多的比特表示出現頻率低的字符。
好比對於字符串 A B R A C A D A B R A，若是使用7位的ASCII字符編碼，那麼只出現了1次的D和出現了5次的A，佔用的比特數是同樣的。
若是能這樣編碼

A:0
B:1
R:00
C:01
D:10

那麼這個字符串的編碼就是0 1 00 0 01 0 10 0 1 00 0。只須要15位，而ASCII碼須要77位。但這種方法並不完整，由於它須要空格來區分字符，若是沒有空格，就會形成歧義，好比01，除了能夠解碼爲AB，還能夠解碼爲C。
若是可以讓全部字符編碼都不會成爲其餘字符編碼的前綴，就不須要專門的分隔符了。含有這種性質的編碼規則叫作前綴碼。
前綴碼的一種簡便表示方法就是單詞查找樹。

如圖所示的單詞查找樹，就是一種字符的編碼方式，它的左連接表示0，右連接表示1，每一個字符的編碼就是從根結點到該結點的路徑表示的比特字符串。
不一樣的單詞查找樹表示的前綴碼的壓縮率不相同，霍夫曼壓縮算法構造的單詞查找樹是最優的。

霍夫曼壓縮分爲5個步驟：

壓縮時：
- 構造前綴碼的單詞查找樹
- 將樹以字節流的形式輸出
- 使用構造的樹將字節流編碼爲比特流
展開時：
- 讀取單詞查找樹
- 使用該樹將比特流解碼

構造前綴碼的單詞查找樹

單詞查找樹的結點

public static class Node implements Comparable<Node> {
    private char ch;
    private int freq;
    private final Node left, right;

    Node(char ch, int freq, Node left, Node right) {
        this.ch = ch;
        this.freq = freq;
        this.left = left;
        this.right = right;
    }

    public boolean isLeaf() {
        return left == null && right == null;
    }

    public int compareTo(Node that) {
        return this.freq - that.freq;
    }
}

這份樹結點的實現中，除了用於表示左右結點的left、right和表示葉子節點中字符的ch，還增長了一個整型變量freq，用於統計字符出現的頻率。

構造單詞查找樹

霍夫曼算法是一個兩輪算法,爲了構造單詞查找樹，算法會先讀取一次整個輸入流，獲得每一個字符的頻率。
構造的第一步是建立一片由許多隻有一個結點的樹所組成的森林，每棵樹都表示輸入流中的一個字符。而後自底向上根據頻率構造單詞查找樹，找到兩個頻率最小的結點，建立一個包含着兩個子結點的新結點，新結點的頻率值爲兩個子結點的頻率值之和，不斷重複這個過程，直到全部子樹都合併爲一顆樹。

private static Node buildTrie(int[] freq) {
    MinPQ<Node> pq = new MinPQ<Node>();
    for (char c = 0; c < R; c++)
        if (freq[c] > 0)
            pq.insert(new Node(c, freq[c], null, null));
    while (pq.size() > 1) {
        Node x = pq.delMin();
        Node y = pq.delMin();
        Node parent = new Node('\0', x.freq + y.freq, x, y);
        pq.insert(parent);
    }
    return pq.delMin();
}

用最小優先隊列能夠方便快速的找到最小結點。

寫入和讀取單詞查找樹

寫入

霍夫曼壓縮算法須要在壓縮時將樹寫入比特流並在展開時讀取它。寫入時，對單詞查找樹進行前序遍歷，遇到內部結點時，寫入比特0，遇到葉子結點時，寫入比特1，緊接着是這個結點中字符的8爲ASCII碼。

private static void writeTrie(Node x) {
    if (x.isLeaf()) {
        BinaryStdOut.write(true);
        BinaryStdOut.write(x.ch);
        return;
    }
    BinaryStdOut.write(false);
    writeTrie(x.left);
    writeTrie(x.right);
}

讀取

在讀取比特字符串，從新構造單詞查找樹時，首先讀取一個比特以肯定當前結點的類型，若是是葉子結點，就讀取字符並建立一個葉子節點，若是是內部結點，就建立一個內部結點並遞歸地構造它的左右子樹。

private static Node readTrie() {
    if (BinaryStdIn.readBoolean())
        return new Node(BinaryStdIn.readChar(), 0, null, null);
    return new Node('\0', 0, readTrie(), readTrie());
}

使用前綴碼壓縮

在壓縮時，首先根據單詞查找樹定義的前綴碼來構造編譯表。爲了提高效率，使用由字符索引的數組st，st的大小爲字符集的大小。st中保存了單詞查找樹中包含的字符對應的比特字符串。
在構造編譯表時，會遞歸遍歷整顆樹，併爲每一個結點維護了一條從跟結點到它的路徑所對應的二進制字符串，0表示左連接，1表示右連接，每當到達一個葉子節點時，就將結點的編碼設爲它對應的比特字符串。

private static void buildCode(String[] st, Node x, String s) {
    if (x.isLeaf()) {
        st[x.ch] = s;
        return;
    }
    buildCode(st, x.left, s + '0');
    buildCode(st, x.right, s + '1');
}

編譯表創建後，壓縮的過程，就成了查找樹如字符所對應的編碼並寫入的過程。

public static void compress() {
    String s = BinaryStdIn.readString();
    char[] input = s.toCharArray();

    int[] freq = new int[R];
    for (int i = 0; i < input.length; i++)
        freq[input[i]]++;

    Node root = buildTrie(freq);
    String[] st = new String[R];
    buildCode(st, root, "");
    writeTrie(root);
    BinaryStdOut.write(input.length);
    for (int i = 0; i < input.length; i++) {
        String code = st[input[i]];
        for (int j = 0; j < code.length(); j++)
            if (code.charAt(j) == '1')
                BinaryStdOut.write(true);
            else
                BinaryStdOut.write(false);
    }
    BinaryStdOut.close();
}

使用前綴碼展開

在展開時，首先使用前述方法從比特流中還原單詞查找樹。而後根據比特流的輸入從跟結點開始向下移動，若是比特爲0，就移動到左子結點，反之就移動到右子結點。當遇到葉子結點時，輸出這個結點的字符並從新回到根結點。

public static void expand() {
    Node root = readTrie();
    int N = BinaryStdIn.readInt();
    for (int i = 0; i < N; i++) {
        Node x = root;
        while (!x.isLeaf())
            if (BinaryStdIn.readBoolean())
                x = x.right;
            else
                x = x.left;
        BinaryStdOut.write(x.ch);
    }
    BinaryStdOut.close();
}

LZW壓縮

LZW算法的基本思想和霍夫曼壓縮的思想正好相反。霍夫曼壓縮是爲輸入中的定長模式產生了變長的編碼編譯表；而LZW壓縮是爲輸入中的變長模式生成了一張定長的編碼編譯表。並且，LZW算法不須要在輸出中附上這張編譯表。

LZW壓縮算法的基礎是維護一張字符串鍵和編碼的編譯表。在符號表中，將128個ASCII碼的值初始化爲8位編碼，即在每一個字符的編碼值前面添加0。而後用16進制數字來表示編碼，那麼A的編碼就是41，R的是52等等。將80編碼保留爲文件借宿的標誌，並將81-FF的編碼值分配給在輸入中遇到的各類子字符串。
壓縮數據時，會反覆進行以下操做：

找出未處理的輸入在符號表中最長的前綴字符串s；
輸出s的8位編碼值；
繼續掃描s以後的一個字符c；
在符號表中將s+c（鏈接s和c）的值設爲下一個編碼值。

好比下圖所示爲處理輸入A B R A C ... B R A的過程，以及對應的三向單詞查找樹：

對於前7個字符，匹配的最長前綴只有1個字符，所以輸出這些字符對應的編碼，並將編碼81到87和產生的7個雙字符的字符串關聯。而後發現AB匹配了輸入的前最81，並將ABR添加到符號表中，而後是RA（輸出83並添加RAB），BR（輸出82並添加BRA）和ABR（輸出88並添加ABRA），最後只剩下A（輸出41）。

LZW的單詞查找樹

LZW算法會用到三向單詞查找樹，包含兩種操做：

找到輸入和符號表的全部鍵的最長前綴匹配；
將匹配的鍵和前瞻字符相連獲得一個新鍵，將新鍵和下一個編碼管理並添加到符號表中。

LZW壓縮的展開
在展開時，會維護一張關聯字符串和編碼值的符號表，這張表的逆表示壓縮時所用的符號表。在這張表總加入00到7F和全部單個ASCII字符的字符串的關聯條目，將第一個未關聯的編碼值設爲81。在遇到編碼80前，不斷重複如下操做：
輸出當前字符串val；
從輸入中讀取一個編碼x；
在符號表中將s設爲和x相關聯的值；
在符號表中將下一個未分配的編碼值設爲val+c，其中c爲s的首字母；
將當前字符串val設爲s；

最終LZW算法的實現以下，這份用於實際使用的代碼，採用的編碼寬度爲12位。

public class LZW {
    private static final int R = 256;
    private static final int L = 4096;
    private static final int W = 12;

    public static void compress() {
        String input = BinaryStdIn.readString();
        TST<Integer> st = new TST<Integer>();

        for (int i = 0; i < R; i++)
            st.put("" + (char) i, i);
        int code = R + 1;

        while (input.length() > 0) {
            String s = st.longestPrefixOf(input);
            BinaryStdOut.write(st.get(s), W);

            int t = s.length();
            if (t < input.length() && code < L)
                st.put(input.substring(0, t + 1), code++);
            input = input.substring(t);
        }

        BinaryStdOut.write(R, W);
        BinaryStdOut.close();
    }

    public static void expand() {
        String[] st = new String[L];
        int i;
        for (i = 0; i < R; i++)
            st[i] = "" + (char) i;
        st[i++] = " ";

        int codeword = BinaryStdIn.readInt(W);
        String val = st[codeword];
        while (true) {
            BinaryStdOut.write(val);
            codeword = BinaryStdIn.readInt(W);
            if (codeword == R)
                break;
            String s = st[codeword];
            if (i == codeword)
                s = val + val.charAt(0);
            if (i < L)
                st[i++] = val + s.charAt(0);
            val = s;
        }
        BinaryStdOut.close();
    }
}