trie树-前缀树

http://www.cnblogs.com/huangxincheng/archive/2012/11/25/2788268.html

trie，又称前缀树或字典树，是一种有序树

一：概念

     下面我们有and,as,at,cn,com这些关键词，那么如何构建trie树呢？

从上面的图中，我们或多或少的可以发现一些好玩的特性。

      第一：根节点不包含字符，除根节点外的每一个子节点都包含一个字符。

      第二：从根节点到某一节点，路径上经过的字符连接起来，就是该节点对应的字符串。

      第三：每个单词的公共前缀作为一个字符节点保存。

 

二：使用范围

     既然学Trie树，我们肯定要知道这玩意是用来干嘛的。

     第一：词频统计。

            可能有人要说了，词频统计简单啊，一个hash或者一个堆就可以打完收工，但问题来了，如果内存有限呢？还能这么

             玩吗？所以这里我们就可以用trie树来压缩下空间，因为公共前缀都是用一个节点保存的。

     第二: 前缀匹配

            就拿上面的图来说吧，如果我想获取所有以"a"开头的字符串，从图中可以很明显的看到是：and,as,at，如果不用trie树，

            你该怎么做呢？很显然朴素的做法时间复杂度为O(N²) ，那么用Trie树就不一样了，它可以做到h，h为你检索单词的长度，

            可以说这是秒杀的效果。

举个例子：现有一个编号为1的字符串”and“，我们要插入到trie树中，采用动态规划的思想，将编号”1“计入到每个途径的节点中，

              那么以后我们要找”a“，”an“，”and"为前缀的字符串的编号将会轻而易举。

package jd;

import java.util.HashMap;
import java.util.Map.Entry;

/**
 * 前缀树的实现
 * 
 * @author li
 * 
 */
public class TrieTree {
    /**
     * 前缀树节点
     * 
     * @author li
     * 
     */
    private class Node {
        private int prefixNum;// 以该字符串为前缀的字符数
        private Node[] childNodes;
        private boolean isLeaf;// 是否为单词
        private int dumplicateNum;// 该字符串重复出现的次数(单词重复出现次数)

        public Node() {
            prefixNum = 0;
            isLeaf = false;
            dumplicateNum = 0;
            childNodes = new Node[26];
        }
    }

    private Node root;// 根节点

    public TrieTree() {
        root = new Node();

    }

    public void insert(String word) {
        insert(this.root, word);
    }

    /**
     * 插入单词
     * 
     * @param root
     * @param word
     */
    public void insert(Node root, String word) {
        word = word.toLowerCase();
        char[] chars = word.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            int index = chars[i] - 'a';// 对应的下标
            if (root.childNodes[index] == null) {
                root.childNodes[index] = new Node();
            }
            root.childNodes[index].prefixNum++;
            if (i == chars.length - 1) {
                root.childNodes[index].isLeaf = true;// 单词
                root.childNodes[index].dumplicateNum++;// 该单词出现的个数
            }
            root = root.childNodes[index];
        }

    }

    /**
     * 获取以prefixStr为前缀的字符串
     * 
     * @param prefixStr
     * @return
     */
    private HashMap<String, Integer> getPrefixString(Node root, String prefixStr) {
        prefixStr = prefixStr.toLowerCase();
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        char[] prefixs = prefixStr.toCharArray();
        for (int i = 0; i < prefixs.length; i++) {
            int index = prefixs[i] - 'a';
            if (root.childNodes[index] != null) {
                root = root.childNodes[index];
            } else {
                return null;
            }
        }
        dfs(root, prefixStr, map);
        return map;

    }

    public HashMap<String, Integer> getPrefixString(String prefixStr) {

        return getPrefixString(root, prefixStr);

    }

    /**
     * 深度优先遍历
     * 
     * @param root
     *            :根节点
     * @param map
     */
    private HashMap<String, Integer> dfs(Node root, String prefixs,
            HashMap<String, Integer> map) {
        if (root == null) {
            return null;
        }
        if (root.isLeaf) {
            map.put(prefixs, root.dumplicateNum);

        }
        Node[] nodes = root.childNodes;
        for (int i = 0; i < nodes.length; i++) {
            if (nodes[i] != null) {
                char c = (char) (i + 'a');
                String tempStr = prefixs + c;
                dfs(root.childNodes[i], tempStr, map);
            }

        }
        return map;

    }

    /**
     * 遍历所有的字符串
     * 
     * @return
     */
    public HashMap<String, Integer> dfs() {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        return dfs(this.root, "", map);
    }

    /**
     * 删除节点
     * 
     * @param word
     */
    public boolean delete(String word) {
        // 不存在该单词则删除
        Node p = root;
        if (!searchWord(word)) {
            return false;
        }
        word = word.toLowerCase();
        char[] chars = word.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            int index = chars[i] - 'a';
            Node[] nodes = p.childNodes;
            if (nodes[index].prefixNum == 1) {
                nodes[index] = null;
                return true;
            } else {
                nodes[index].prefixNum--;
                p = nodes[index];
            }
        }
        if (p.dumplicateNum == 1) {
            p.isLeaf = false;
        }
        p.dumplicateNum--;
        return true;

    }

    /**
     * 
     * @param root
     * @param word
     * @return
     */
    private boolean searchWord(Node root, String word) {
        if (root == null) {
            return false;
        }
        word = word.toLowerCase();
        char[] chars = word.toCharArray();

        for (int i = 0; i < chars.length; i++) {
            int index = chars[i] - 'a';
            Node[] nodes = root.childNodes;
            if (nodes[index] != null) {
                root = nodes[index];
            } else {
                return false;
            }

        }
        if (!root.isLeaf) {
            return false;
        }
        return true;

    }

    public boolean searchWord(String word) {
        return searchWord(root, word);

    }

    public static void main(String[] args) {
        TrieTree trieTree = new TrieTree();
        trieTree.insert("gab");
        trieTree.insert("gb");
        trieTree.insert("gb");
        trieTree.insert("gbc");
        trieTree.insert("gbc");
        trieTree.insert("go");
        trieTree.insert("go");
        trieTree.insert("goa");
        for (Entry<String, Integer> entry : trieTree.getPrefixString("g")
                .entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());

        }
        trieTree.delete("gb");
        System.out.println("***************");
        for (Entry<String, Integer> entry : trieTree.getPrefixString("g")
                .entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());

        }

    }
}