Coursera 算法二 week 5 BurrowsWheeler

本打算周末完成这次作业，但没想到遇到了hard deadline，刚开始看不懂题意，后来发现算法4书上有个类似的问题，才理解了题意。最后晚上加班，上课加班，还好在11:35也就是课程结束前25分钟完成了这次作业。。。

本次作业学到的知识点：

1、java中两个类对象比较相等用equals，因此String对象也应用equals方法，而非“==”。

2、读取命令行参数用args[i]，读取文件中的数据才用StdIn等。

3、String对象的长度用方法length，数组的长度用length()。

4、类似于int在泛型中用Integer类，char在泛型中应用Charactor类。

5、用Arrays.sort方法对数组进行自定义排序，首先数组应为基本类型对应的类，然后要重载compare方法，这里参考别人的代码使用了匿名内部类，详见CircularSuffixArray类中构造函数。而对基本类型的数组排序，函数参数为数组名即可（见BurrowsWheeler类44行）。

作业中难以理解的一些地方：

1、后缀数组排序是指将每一行中的后缀字符数组看做字符串进行排序。

2、不需要讲后缀数组存储起来，因为如果字符数组在第n行，那么数组就以输入字符串中的第n个字符开始，从而根据输入字符串就可确定此字符数组。

3、BurrowsWheeler类的逆变换中，通过t数组构造一个<字符，字符在t数组中的下标的队列>的符号表，就可以方便的求出next数组。

 import java.util.List;
 import java.util.ArrayList;
 import edu.princeton.cs.algs4.BinaryStdIn;
 import edu.princeton.cs.algs4.BinaryStdOut;
 
 public class MoveToFront {
     // apply move-to-front encoding, reading from standard input and writing to standard output
     public static void encode()
     {
         List<Character> list = new ArrayList<Character>();
         for (int i = 0; i < 256; i++)
             list.add((char)i);
         while (!BinaryStdIn.isEmpty())
         {
             char c = BinaryStdIn.readChar();
             int index = list.indexOf(c);
             BinaryStdOut.write(index, 8);
             list.remove(index);
             list.add(0, c);
         }
         BinaryStdOut.close();
     }
 
     // apply move-to-front decoding, reading from standard input and writing to standard output
     public static void decode()
     {
         List<Character> list = new ArrayList<Character>();
         for (int i = 0; i < 256; i++)
             list.add((char)i);
         while (!BinaryStdIn.isEmpty())
         {
             int index = BinaryStdIn.readChar();
             char c = list.get(index);
             BinaryStdOut.write(c);
             list.remove(index);
             list.add(0, c);
         }
         BinaryStdOut.close();
     }
 
     // if args[0] is '-', apply move-to-front encoding
     // if args[0] is '+', apply move-to-front decoding
     public static void main(String[] args)
     {
         if (args[0].equals("-")) encode();
         if (args[0].equals("+")) decode();
     }
 }

 import java.util.Arrays;
 import java.util.Comparator;
 
 public class CircularSuffixArray {
     private String input;
     private Integer index[];
    // circular suffix array of s
    public CircularSuffixArray(String s)
    {
        if (s == null) throw new java.lang.IllegalArgumentException();
        input = s;
        index = new Integer[s.length()];
        for (int i = 0; i < s.length(); i++)
            index[i] = i;
        Arrays.sort(index, new Comparator<Integer>() {
            public int compare(Integer first, Integer second)
            {
                int p = first, q = second;
                for (int i = 0; i < input.length(); i++)
                {
                    if (p >= input.length()) p = 0;
                    if (q >= input.length()) q = 0;
                    if (input.charAt(p) > input.charAt(q)) return 1;
                    if (input.charAt(p) < input.charAt(q)) return -1;
                    p++;
                    q++;
                }
                return 0;
            }
        });
    }
    // length of s
    public int length()
    {
        return index.length;
    }
    // returns index of ith sorted suffix
    public int index(int i)
    {
        if (i < 0 || i > input.length() - 1)
            throw new java.lang.IllegalArgumentException();
        return index[i];
    }
    // unit testing (required)
    public static void main(String[] args)
    {
        CircularSuffixArray csa = new CircularSuffixArray("ABRACADABRA!");
        for (int i = 0; i < csa.length(); i++)
            System.out.println(csa.index(i));
    }
 }

 import edu.princeton.cs.algs4.BinaryStdIn;
 import edu.princeton.cs.algs4.BinaryStdOut;
 import java.util.Arrays;
 import edu.princeton.cs.algs4.Queue;
 import edu.princeton.cs.algs4.ST;
 
 public class BurrowsWheeler {
     // apply Burrows-Wheeler transform, reading from standard input and writing to standard output
     public static void transform()
     {
         String input = BinaryStdIn.readString();
         CircularSuffixArray csa = new CircularSuffixArray(input);
         for (int i = 0; i < csa.length(); i++)
             if (csa.index(i) == 0)
                 BinaryStdOut.write(i);
         for (int i = 0; i < csa.length(); i++)
         {
             int index = csa.index(i) - 1;
             if (index < 0) index = csa.length() - 1;
             char c = input.charAt(index);
             BinaryStdOut.write(c);
         }
         BinaryStdOut.close();
     }
 
     // apply Burrows-Wheeler inverse transform, reading from standard input and writing to standard output
     public static void inverseTransform()
     {
         int first = BinaryStdIn.readInt();
         String chars = BinaryStdIn.readString();
         char[] t = chars.toCharArray();
         chars = null;
         int i = 0, size = t.length;
         ST<Character, Queue<Integer>> st = new ST<Character, Queue<Integer>>();
         for (i = 0; i < size; i++)
         {
             if (st.contains(t[i])) st.get(t[i]).enqueue(i);
             else {
                 Queue<Integer> q = new Queue<Integer>();
                 q.enqueue(i);
                 st.put(t[i], q);
             }
         }
         Arrays.sort(t);
         int next[] = new int[size];
         for (i = 0; i < size; i++)
             next[i] = st.get(t[i]).dequeue();
         for (i = 0; i < size; i++)
         {
             BinaryStdOut.write(t[first]);
             first = next[first];
         }
         BinaryStdOut.close();
     }
 
     // if args[0] is '-', apply Burrows-Wheeler transform
     // if args[0] is '+', apply Burrows-Wheeler inverse transform
     public static void main(String[] args)
     {
         if (args[0].equals("-")) transform();
         if (args[0].equals("+")) inverseTransform();
     }
 }