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();
    }
}