《算法》第三章部分程序 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("
<put> i < 0 || i >= d.
");
        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("
<get> i < 0 || i >= d.
");
        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("
<dot> dimension disagree.
");
        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("
<plus> dimension disagree.
");
        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));
    }
}