《算法》第五章部分程序 part 8

▶ 书中第五章部分程序，包括在加上自己补充的代码，适用于基因序列的 2-Bit 压缩算法，行程长压缩算法，Huffman 压缩算法，LZW 压缩算法

● 适用于基因序列的 2-Bit 压缩算法

 package package01;

 import edu.princeton.cs.algs4.BinaryStdIn;
 import edu.princeton.cs.algs4.BinaryStdOut
 import edu.princeton.cs.algs4.Alphabet;

 public class class01
 {
     private class01() {}

     public static void compress()   // 压缩，ATGC 每个字母只用 00、01、10、11 之一来表示
     {
         Alphabet DNA = Alphabet.DNA;
         String s = BinaryStdIn.readString();
         int n = s.length();
         BinaryStdOut.write(n);
         for (int i = 0; i < n; i++)
             BinaryStdOut.write(DNA.toIndex(s.charAt(i)), 2);            // 找到字母在字母表 DNA 中的索引（0 ~ 3），转化为两位二进制字符
         BinaryStdOut.close();                                           // 关闭二进制流，补齐字符字节，防止出错
     }

     public static void expand()     // 扩展
     {
         Alphabet DNA = Alphabet.DNA;
         int n = BinaryStdIn.readInt();
         for (int i = 0; i < n; i++)
             BinaryStdOut.write(DNA.toChar(BinaryStdIn.readChar(2)), 8); // 读入两位二进制字符，作为索引得到对应的字母，转为 Byte 写出
         BinaryStdOut.close();
     }

     public static void main(String[] args)
     {
         if (args[0].equals("-"))    // '-' 表压缩，'+' 表扩展
             compress();
         else if (args[0].equals("+"))
             expand();
         else
             throw new IllegalArgumentException("\n<main> Illegal command.\n");
     }
 }

● 行程长压缩算法，注意输入和输出都是二进制串

 package package01;

 import edu.princeton.cs.algs4.BinaryStdIn;
 import edu.princeton.cs.algs4.BinaryStdOut;

 public class class01
 {
     private static final int R = 256;   // 最大行程长
     private static final int LG_R = 8;  // log(R)，为了表示最大行程长需要的 Bit 数

     private class01() {}

     public static void compress()
     {
         char run = 0;                                   // 累计扫描相同的字符数，初始化为 0
         for (boolean b = false; !BinaryStdIn.isEmpty();)// 默认第 1 个字符为 false
         {
             if (BinaryStdIn.readBoolean() != b)         // 与上一个字符不同
             {
                 BinaryStdOut.write(run, LG_R);          // 以规定的 Bit 宽度写入累计行程长
                 run = 1;                                // 累计扫描数设定为 1
                 b = !b;                                 // 翻转字符 b
             }
             else                                        // 与上一个字符相同
             {
                 if (run == R - 1)                       // 累计扫描述已经最大，需要切成两截分别记录
                 {
                     BinaryStdOut.write(run, LG_R);      // 先写入长为 R-1 的行程
                     run = 0;
                     BinaryStdOut.write(run, LG_R);      // 再插入一个长为 0 的行程
                 }
                 run++;                                  // 计数器自加 1
             }
         }
         BinaryStdOut.write(run, LG_R);
         BinaryStdOut.close();
     }

     public static void expand()
     {
         for (boolean b = false; !BinaryStdIn.isEmpty();)// 默认第 1 个字符为 false
         {
             int run = BinaryStdIn.readInt(LG_R);        // 按规定的 Bit 宽度读入一个行程长
             for (int i = 0; i < run; i++)               // 向输出中写行程长个数的字符 b
                 BinaryStdOut.write(b);
             b = !b;                                     // 翻转字符 b
         }
         BinaryStdOut.close();
     }    

     public static void main(String[] args)
     {
         if (args[0].equals("-"))
             compress();
         else if (args[0].equals("+"))
             expand();
         else
             throw new IllegalArgumentException("\n<main> Illegal command.\n");
     }
 }

● Huffman 压缩算法

 package package01;

 import edu.princeton.cs.algs4.BinaryStdIn;
 import edu.princeton.cs.algs4.BinaryStdOut;
 import edu.princeton.cs.algs4.MinPQ;

 public class class01
 {
     private static final int R = 256;                       // 字符表基数

     private class01() { }

     private static class Node implements Comparable<Node>   // Trie 树节点
     {
         private final char ch;                              // 字符，频率和左右子树
         private final int freq;
         private final Node left, right;

         Node(char inputCh, int inputFreq, Node inputLeft, Node inputRight)
         {
             ch = inputCh;
             freq = inputFreq;
             left = inputLeft;
             right = inputRight;
         }

         private boolean isLeaf()                            // 是否为叶节点
         {
             return (left == null) && (right == null);
         }

         public int compareTo(Node that)                     // 两节点相比较
         {
             return this.freq - that.freq;
         }
     }

     public static void compress()
     {
         char[] input = BinaryStdIn.readString().toCharArray();
         int[] freq = new int[R];                            // 统计字母频率
         for (int i = 0; i < input.length; i++)
             freq[input[i]]++;
         Node root = buildTrie(freq);                        // 用频率表建立 Trie 树
         String[] st = new String[R];                        // 建立查找表，将字符映射到 01 串
         buildCode(st, root, "");
         writeTrie(root);                                    // 首先写入 Trie 树用于解压
         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++)
                 BinaryStdOut.write(code.charAt(j) != '0');  // code[j] == '0' 则条件不成立，写个 0，反之写个 1
         }
         BinaryStdOut.close();
     }

     public static void expand()
     {
         Node root = readTrie();                             // 首先读取 Trie 树
         int length = BinaryStdIn.readInt();                 // 读取输入串的长度
         for (int i = 0; i < length; i++)                    // 解压过程，循环每次处理一个字符
         {
             Node x = root;
             for (; !x.isLeaf(); x = (BinaryStdIn.readBoolean() ? x.right : x.left));    // 顺着Trie 树往下直到叶节点
             BinaryStdOut.write(x.ch, 8);                                                // 输出叶节点对应的字符
         }
         BinaryStdOut.close();
     }

     private static Node buildTrie(int[] freq)               // 用频率表建立 Trie 树，返回根节点
     {
         MinPQ<Node> pq = new MinPQ<Node>();                 // 初始化所有字母节点，入队
         for (char i = 0; i < R; i++)
         {
             if (freq[i] > 0)
                 pq.insert(new Node(i, freq[i], null, null));
         }
         if (pq.size() == 1)                                 // 只有一个字母的情况，原文不是 '\0' 则插入 '\0'，不然插入 '\1'
             pq.insert(new Node(freq['\0'] == 0 ? '\0' : '\1', 0, null, null));

         for (; pq.size() > 1;)                              // 每次合并两个频率最小的节点并入队，直到队列中只剩一个元素
         {
             Node left = pq.delMin(), right = pq.delMin();
             Node parent = new Node('\0', left.freq + right.freq, left, right);
             pq.insert(parent);
         }
         return pq.delMin();                                 // 最后剩下的节点就是根节点，其 freq 即为总字符数
     }

     private static void buildCode(String[] st, Node x, String s)    // 遍历以 x 为根节点的树，每到达叶节点就对查找表 st 赋字符串值，当前字符串前缀为 s
     {
         if (x.isLeaf())
             st[x.ch] = s;                                   // x.ch 是叶节点对应的字母（如 a = 97），将查找表中该索引位置的值设为遍历进来时得到的 01 串
         else
         {
             buildCode(st, x.left, s + '0');                 // 往左遍历，串上加一个 '0'
             buildCode(st, x.right, s + '1');                // 往左遍历，串上加一个 '1'
         }
     }

     private static void writeTrie(Node x)   // 将 x 为根节点的 Trie 树写成字符串
     {
         if (x.isLeaf())                     // x 是叶节点，写个 1，后跟字符的 8 Bit 二进制表示，然后递归回退
         {
             BinaryStdOut.write(true);
             BinaryStdOut.write(x.ch, 8);
             return;
         }
         BinaryStdOut.write(false);          // x 不是叶节点，写个 0，然后分别遍历 x 的左右子节点
         writeTrie(x.left);
         writeTrie(x.right);
     }

     private static Node readTrie()          // 读取 Trie 树，注意频率没有用，全都设为 -1
     {
         if (BinaryStdIn.readBoolean())      // 当前位是 1 则说明接下来是叶节点，一次性读入 8 Bit，转成 char
             return new Node(BinaryStdIn.readChar(), -1, null, null);
         else                                // 当前位是 0 则说明还没有到叶节点，左右子节点分别向下递归
             return new Node('\0', -1, readTrie(), readTrie());
     }

     public static void main(String[] args)
     {
         if (args[0].equals("-"))
             compress();
         else if (args[0].equals("+"))
             expand();
         else
             throw new IllegalArgumentException("\n<main> Illegal command.\n");
     }
 }

● LZW 压缩算法

 package package01;

 import edu.princeton.cs.algs4.BinaryStdIn;
 import edu.princeton.cs.algs4.BinaryStdOut;
 import edu.princeton.cs.algs4.TST;

 public class class01
 {
     private static final int R = 256;   // 字符表基数
     private static final int W = 12;    // 编码宽度（Bit）
     private static final int L = 4096;  // 编码表大小， L = 2^W

     private class01() {}

     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);
         for (int code = R + 1; input.length() > 0;)         // st[R] 标记 EOF，st[R+1] ~ st[L-1] 记录新的编码
         {
             String s = st.longestPrefixOf(input);           // 在输入中寻找目前掌握的最长前缀
             BinaryStdOut.write(st.get(s), W);               // 把当前最长前缀的编码写到输出中，指定宽度 W
             int t = s.length();
             if (t < input.length() && code < L)             // 刚才找到的前缀短于原文剩余长度，且编译表还没填满
                 st.put(input.substring(0, t + 1), code++);  // 连着刚才找到的前缀以及 1 个前瞻字符一起编码为编译表的新一项
             input = input.substring(t);                     // 砍掉原文前 t 字符，用于下一次扫描
         }
         BinaryStdOut.write(R, W);                           // 最后写上字符表基数
         BinaryStdOut.close();
     }

     public static void expand()
     {
         String[] st = new String[L];
         for (int i = 0; i < R; i++)             // 初始化编译表的前 R 项
             st[i] = "" + (char)i;
         st[R] = "";                             // st[R] 标记 EOF（这里没用）

         int codeword = BinaryStdIn.readInt(W);  // 读入定宽字符，如果读入的字符就是字符集基数，说明正文部分是空的，不用解压
         if (codeword == R)
             return;
         String val = st[codeword];              // 从编译表中找到原文，第一个定宽字符的原文肯定是单字符
         for (int i = R + 1;;)                        // i 指向当前编译表中的首个空白项
         {
             BinaryStdOut.write(val);            // 找到的原文写到输出流
             codeword = BinaryStdIn.readInt(W);  // 读取下一个定宽字符，同 for 之前的部分
             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);    // 连着之前的原文以及当前原文的第 1 个字符一起编码为编译表的新一项
             val = s;                            // 当前原文保存到 val 中，用于下次编码
         }
         BinaryStdOut.close();
     }

     public static void main(String[] args)
     {
         if (args[0].equals("-"))
             compress();
         else if (args[0].equals("+"))
             expand();
         else
             throw new IllegalArgumentException("\n<main> Illegal command.\n");
     }
 }