使用伸展树（SplayTree）统计单词频率的Java实现

伸展树（Splay Tree）是特殊的二叉搜索树。

伸展树在查询时进行旋转，使得刚刚查到的节点成为树根，越频繁使用的节点会越靠近树根，这样可以加快访问速度。关于伸展树的介绍很多，在了解二叉树和AVL树后，伸展树的原理会比较好理解。本文不再介绍伸展树，而是统计各个单词在一篇文章中出现的频率，并将它们构造成伸展树。

1、构造二叉搜索树

二叉搜索树节点：

/**
 * Node of Binary Search Tree
 * @author cuiods
 */
public class BSTNode<T extends Comparable<? super T>> {
    protected T data;
    protected BSTNode<T> left, right;

    public BSTNode() {
        this(null, null, null);
    }

    public BSTNode(T data) {
        this(data, null, null);
    }

    public BSTNode(T data, BSTNode left, BSTNode right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }
}

二叉搜索树：

/**
 * Binary Search Tree
 * @author cuiods
 */
public class BSTree<T extends Comparable<? super T>> {
    protected BSTNode<T> root;

    public T search(T data) {
        return search(root, data);
    }

    public void insert(T data) {
        BSTNode<T> p = root, prev = null;
        while (p != null) {
            prev = p;
            if (p.data.compareTo(data) < 0) {
                p = p.right;
            } else {
                p = p.left;
            }
        }
        if (root == null) {
            root = new BSTNode<T>(data);
        } else if (prev.data.compareTo(data) < 0) {
            prev.right = new BSTNode<T>(data);
        } else {
            prev.left = new BSTNode<T>(data);
        }
    }

    public void inorder() {
        inorder(root);
    }

    protected void inorder(BSTNode<T> node) {
        if (node != null) {
            inorder(node.left);
            visit(node.data);
            inorder(node.right);
        }
    }

    protected T search(BSTNode<T> p, T data) {
        while (p != null) {
            if (data.equals(p.data)) {
                return data;
            } else if (data.compareTo(p.data) < 0) {
                p = p.left;
            } else {
                p = p.right;
            }
        }
        return null;
    }

    protected void visit(T node) {
        System.out.println(node.toString() + " ");
    }
}

2、构造伸展树

主要实现的是伸展树的插入和搜索方法，最核心的是伸展方法，借鉴：

http://www.cnblogs.com/skywang12345/p/3604286.html

伸展树节点：

/**
 * node of splay tree
 * @author cuiods
 */
public class SplayTreeNode<T extends Comparable<? super T>> extends BSTNode<T> {

    public SplayTreeNode() {
        right = left = null;
    }
    public SplayTreeNode(T data) {
        this(data,null,null);
    }
    public SplayTreeNode(T data, SplayTreeNode<T> left, SplayTreeNode<T> right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }
}

伸展树：

/**
 * splay tree implement
 * http://www.cnblogs.com/skywang12345/p/3604286.html
 * @author cuiods
 */
public abstract class SplayTree<T extends Comparable<? super T>> extends BSTree<T> {

    /**
     * 处理插入时遇到相同的节点
     * @param data 插入时已经存在的节点
     */
    protected abstract void handleSame(T data);

    @Override
    public void insert(T key) {
        SplayTreeNode<T> z=new SplayTreeNode<T>(key);

        // 插入节点
        root = insert((SplayTreeNode<T>) root, z);
        // 将节点(key)旋转为根节点
        root = splay((SplayTreeNode<T>) root, key);
    }

    @Override
    public T search(T key) {
        T result = super.search(key);
        splay(key);
        return result;
    }

    private void splay(T key) {
        root = splay((SplayTreeNode<T>) root, key);
    }


    /*
    * 旋转key对应的节点为根节点，并返回根节点。
    *
    * 注意：
    *   (a)：伸展树中存在"键值为key的节点"。
    *          将"键值为key的节点"旋转为根节点。
    *   (b)：伸展树中不存在"键值为key的节点"，并且key < tree.key。
    *      b-1 "键值为key的节点"的前驱节点存在的话，将"键值为key的节点"的前驱节点旋转为根节点。
    *      b-2 "键值为key的节点"的前驱节点不存在的话，则意味着，key比树中任何键值都小，那么此时，将最小节点旋转为根节点。
    *   (c)：伸展树中不存在"键值为key的节点"，并且key > tree.key。
    *      c-1 "键值为key的节点"的后继节点存在的话，将"键值为key的节点"的后继节点旋转为根节点。
    *      c-2 "键值为key的节点"的后继节点不存在的话，则意味着，key比树中任何键值都大，那么此时，将最大节点旋转为根节点。
    */
    private SplayTreeNode<T> splay(SplayTreeNode<T> tree, T data) {
        if (tree == null)
            return null;

        SplayTreeNode<T> N = new SplayTreeNode<T>();
        SplayTreeNode<T> l = N;
        SplayTreeNode<T> r = N;
        SplayTreeNode<T> c;

        for (;;) {
            int cmp = data.compareTo(tree.data);
            if (cmp < 0) {
                if (tree.left == null)
                    break;
                if (data.compareTo(tree.left.data) < 0) {
                    c = (SplayTreeNode<T>) tree.left;                           /* rotate right */
                    tree.left = c.right;
                    c.right = tree;
                    tree = c;
                    if (tree.left == null)
                        break;
                }
                r.left = tree;                               /* link right */
                r = tree;
                tree = (SplayTreeNode<T>) tree.left;
            } else if (cmp > 0) {
                if (tree.right == null)
                    break;
                if (data.compareTo(tree.right.data) > 0) {
                    c = (SplayTreeNode<T>) tree.right;                          /* rotate left */
                    tree.right = c.left;
                    c.left = tree;
                    tree = c;
                    if (tree.right == null)
                        break;
                }
                l.right = tree;                              /* link left */
                l = tree;
                tree = (SplayTreeNode<T>) tree.right;
            } else {
                break;
            }
        }
        l.right = tree.left;                                /* assemble */
        r.left = tree.right;
        tree.left = N.right;
        tree.right = N.left;
        return tree;
    }

    /*
    * 将结点插入到伸展树中，并返回根节点
    *
    * 参数说明：
    *     tree 伸展树的
    *     z 插入的结点
    */
    private SplayTreeNode<T> insert(SplayTreeNode<T> tree, SplayTreeNode<T> z) {
        int cmp;
        SplayTreeNode<T> y = null;
        SplayTreeNode<T> x = tree;

        // 查找z的插入位置
        while (x != null) {
            y = x;
            cmp = z.data.compareTo(x.data);
            if (cmp < 0)
                x = (SplayTreeNode<T>) x.left;
            else if (cmp > 0)
                x = (SplayTreeNode<T>) x.right;
            else {
                handleSame(z.data);
                return tree;
            }
        }

        if (y==null)
            tree = z;
        else {
            cmp = z.data.compareTo(y.data);
            if (cmp < 0)
                y.left = z;
            else
                y.right = z;
        }

        return tree;
    }


}

3、统计单词频率

特殊的单词伸展树：

/**
 * word splay tree
 * @author cuiods
 */
public class WordSplay extends SplayTree<Word>{

    private int differentWords, wordCount;

    @Override
    protected void handleSame(Word data) {
        data.setFreq(data.getFreq()+1);
    }

    @Override
    protected void visit(Word word) {
        super.visit(word);
        differentWords ++;
        wordCount += word.getFreq();
    }

    public void run(InputStream inputStream, String fileName) {
        int ch = 1;
        Word p = null;
        try {
            while (ch >-1) {
                while (true) {
                    if (ch > -1 && !Character.isLetter((char) ch))
                        ch = inputStream.read();
                    else break;
                }
                if (ch == -1) break;
                String s = "";
                while (ch > -1 && Character.isLetter((char) ch)) {
                    s += Character.toUpperCase((char) ch);
                    ch = inputStream.read();
                }
                insert(new Word(s));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        inorder();
        System.out.println("\nFile "+fileName+" contains "+ wordCount + " words among which "+differentWords+" are different.\n");
    }
}

单词类：

/**
 * @author cuiods
 */
public class Word implements Comparable<Word>{

    private String word;
    private int freq = 1;

    public Word(String w) {
        word = w;
    }

    public String getWord() {
        return word;
    }

    public void setWord(String word) {
        this.word = word;
    }

    public int getFreq() {
        return freq;
    }

    public void setFreq(int freq) {
        this.freq = freq;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Word word1 = (Word) o;

        return word != null ? word.equals(word1.word) : word1.word == null;

    }

    @Override
    public int compareTo(Word o) {
        return word.compareTo(o.word);
    }

    @Override
    public String toString() {
        return "Word{" +
                "word='" + word + '\'' +
                '}';
    }
}

使用单词伸展树统计：

/**
 * splay word test
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = null;
        String fileName = "";
        try {
            if (args.length == 0) {
                System.out.print("Enter a file name: ");
                Scanner scanner = new Scanner(System.in);
                fileName = scanner.nextLine();
                inputStream = new FileInputStream(fileName);
            } else {
                inputStream = new FileInputStream(args[0]);
                fileName = args[0];
            }
            WordSplay splay = new WordSplay();
            splay.run(inputStream,fileName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}