《算法》第三章部分程序 part 6

▶ 书中第三章部分程序，加上自己补充的代码，包含双向索引表、文建索引、稀疏向量类型

● 双向索引表

 package package01;

 import edu.princeton.cs.algs4.ST;
 import edu.princeton.cs.algs4.Queue;
 import edu.princeton.cs.algs4.In;
 import edu.princeton.cs.algs4.StdIn;
 import edu.princeton.cs.algs4.StdOut;

 public class class01
 {
     private class01() {}

     public static void main(String[] args)
     {
         String filename  = args[0];
         String separator = args[1];
         In in = new In(filename);

         ST<String, Queue<String>> st = new ST<String, Queue<String>>();
         ST<String, Queue<String>> ts = new ST<String, Queue<String>>(); // 反向索引

         for(;in.hasNextLine();)
         {
             String line = in.readLine();
             String[] fields = line.split(separator);
             String key = fields[0];
             for (int i = 1; i < fields.length; i++) // 一个 key 对应多个值，分别存放，以后可以根据值反向查找键
             {
                 String val = fields[i];
                 if (!st.contains(key))
                     st.put(key, new Queue<String>());
                 if (!ts.contains(val))
                     ts.put(val, new Queue<String>());
                 st.get(key).enqueue(val);
                 ts.get(val).enqueue(key);
             }
         }
         StdOut.println("Done indexing");
         for(;!StdIn.isEmpty();)                     // 交互式查找，可以正向也可以反向
         {
             String query = StdIn.readLine();
             if (st.contains(query))
             {
                 for (String vals : st.get(query))
                     StdOut.println("  " + vals);
             }
             if (ts.contains(query))
             {
                 for (String keys : ts.get(query))
                     StdOut.println("  " + keys);
             }
         }
     }
 }

● 文件索引

 package package01;

 import java.io.File;
 import edu.princeton.cs.algs4.SET;
 import edu.princeton.cs.algs4.ST;
 import edu.princeton.cs.algs4.In;
 import edu.princeton.cs.algs4.StdIn;
 import edu.princeton.cs.algs4.StdOut;

 public class class01
 {
     private class01() {}

     public static void main(String[] args)
     {
         ST<String, SET<File>> st = new ST<String, SET<File>>();
         StdOut.println("Indexing files");
         for (String filename : args)
         {
             StdOut.println("  " + filename);
             File file = new File(filename);
             for(In in = new In(file);!in.isEmpty();)
             {
                 String word = in.readString();
                 if (!st.contains(word))
                     st.put(word, new SET<File>());
                 SET<File> set = st.get(word);
                 set.add(file);
             }
         }
         for(;StdIn.isEmpty();)                  // 交互式查找包含特定单词的文件
         {
             String query = StdIn.readString();
             if (st.contains(query))
             {
                 SET<File> set = st.get(query);
                 for (File file : set)
                     StdOut.println("  " + file.getName());
             }
         }
     }
 }

● 稀疏向量类型

 package package01;

 import edu.princeton.cs.algs4.ST;
 import edu.princeton.cs.algs4.StdOut;

 public class class01
 {
     private int d;                   // 向量维数
     private ST<Integer, Double> st;  // 向量 index - value 对

     public class01(int dim)
     {
         d = dim;
         st = new ST<Integer, Double>();
     }

     public void put(int i, double value)
     {
         if (i < 0 || i >= d)
             throw new IllegalArgumentException("\n<put> i < 0 || i >= d.\n");
         if (value == 0.0)
             st.delete(i);
         else
             st.put(i, value);
     }

     public double get(int i)
     {
         if (i < 0 || i >= d)
             throw new IllegalArgumentException("\n<get> i < 0 || i >= d.\n");
         return (st.contains(i)) ? st.get(i) : 0.0;
     }

     public int nnz()
     {
         return st.size();
     }

     @Deprecated
     public int dimension() { return d; }

     public double dot(class01 that)
     {
         if (d != that.d)
             throw new IllegalArgumentException("\n<dot> dimension disagree.\n");
         double sum = 0.0;
         if (st.size() <= that.st.size())       // 遍历元素较少的向量，去元素较多的向量中查找
         {
             for (int i : st.keys())
             {
                 if (that.st.contains(i))
                     sum += get(i) * that.get(i);
             }
         }
         else
         {
             for (int i : that.st.keys())
             {
                 if (st.contains(i))
                     sum += get(i) * that.get(i);
             }
         }
         return sum;
     }

     public double dot(double[] that)
     {
         double sum = 0.0;
         for (int i : st.keys())
             sum += that[i] * get(i);
         return sum;
     }

     public double magnitude()
     {
         return Math.sqrt(dot(this));
     }

     public class01 scale(double alpha)
     {
         class01 c = new class01(d);
         for (int i : st.keys())
             c.put(i, alpha * get(i));
         return c;
     }

     public class01 plus(class01 that)
     {
         if (d != that.d)
             throw new IllegalArgumentException("\n<plus> dimension disagree.\n");
         class01 c = new class01(d);                 // 新建一个向量存放结果
         for (int i : st.keys())
             c.put(i, get(i));
         for (int i : that.st.keys())
             c.put(i, that.get(i) + c.get(i));
         return c;
     }

     public String toString()                        // toString 接口
     {
         StringBuilder s = new StringBuilder();
         for (int i : st.keys())
             s.append("(" + i + ", " + st.get(i) + ") ");
         return s.toString();
     }

     public static void main(String[] args)
     {
         class01 a = new class01(10);
         class01 b = new class01(10);
         a.put(3, 0.50);
         a.put(9, 0.75);
         a.put(6, 0.11);
         a.put(6, 0.00);
         b.put(3, 0.60);
         b.put(4, 0.90);
         StdOut.println("a = " + a);
         StdOut.println("b = " + b);
         StdOut.println("a dot b = " + a.dot(b));
         StdOut.println("a + b   = " + a.plus(b));
     }
 }