Trie树的分析与实现

 字典树

       又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。（From baike）

它有三个基本性质：

(1)根节点不存储字符
(2)除根节点外每一个节点都只存储一个字符
(3)从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串，每个节点的所有子节点包含的字符都不相同。

Java实现代码(注释详细):

package com.wxisme.trietree;

/**
 *Trie树的实现
 *@author wxisme
 *@time 2015-10-13 下午9:48:30
 */
public class TrieTree {
    
    private final int SIZE = 26;//字符出现的种类数,以所有的小写字母为例
    
    private int nodeNumber;//子节点的个数
    
    private int depth;//树的深度
    
    private TrieNode root;//树根
    
    public TrieTree() {
        this.nodeNumber = 0;
        this.depth = 0;
        this.root = new TrieNode();
    }
    
    /**
     * 节点结构
     * @author wxisme
     *
     */
    private class TrieNode {
        private char val;//节点值
        
        private TrieNode son[];//子节点数组
        
        private boolean isEnd;//是否有以此节点为结束字符的单词
        
        private int pearNumber;//节点出现的次数
        
        public TrieNode() {
            this.isEnd = false;
            this.pearNumber = 0;
            this.son = new TrieNode[SIZE];
        }
    }
    
    /**
     * 向Trie中插入一个word
     * @param word
     */
    public void insert(String word) {
        char[] wordChars = word.toCharArray();
        
        TrieNode node = this.root;
        
        for(char ch : wordChars) {
            int pos = ch - 'a';
            //如果相应位置为空则创建
            if(node.son[pos] == null) {
                node.son[pos] = new TrieNode();
                node.son[pos].val = ch;
                node.pearNumber = 1;//第一次出现
                this.nodeNumber ++;
            }
            else {//已经有该字符
                node.pearNumber ++;
            }
            node = node.son[pos];
        }
        node.isEnd = true;
        this.depth = Math.max(this.depth, word.length());
    }
    
    /**
     * 查找是否存在单词word
     * @param word
     * @return 结果
     */
    public boolean search(String word) {
        char[] wordChars = word.toCharArray();
        
        TrieNode node = this.root;
        
        for(char ch : wordChars) {
            int pos = ch - 'a';
            if(node.son[pos] != null) {
                node = node.son[pos];//继续向下查找
            }
            else {
                return false;
            }
        }
        
        return node.isEnd;
    }
    
    /**
     * 查找是否存在以word为前缀的单词，和search()类似，只是不用判断边界。
     * @param word
     * @return 结果
     */
    public boolean searchPrefix(String word) {
        char[] wordChars = word.toCharArray();
        
        TrieNode node = this.root;
        
        for(char ch : wordChars) {
            int pos = ch - 'a';
            if(node.son[pos] != null) {
                node = node.son[pos];//继续向下查找
            }
            else {
                return false;
            }
        }
        
        return true;
    }
    
    /**
     * 统计单词出现的次数
     * @param word
     * @return 结果
     */
    public int wordCount(String word) {
        char[] wordChars = word.toCharArray();
        
        TrieNode node = this.root;
        
        for(char ch : wordChars) {
            int pos = ch - 'a';
            if(node.son[pos] == null) {
                return 0;
            }
            else {
                node = node.son[pos];
            }
        }
        
        return node.isEnd?node.pearNumber:0;
    }

    
    /**
     * 统计以word为前缀的单词个数
     * @param word
     * @return 结果
     */
    public int wordPrefixCount(String word) {
        char[] wordChars = word.toCharArray();
        
        TrieNode node = this.root;
        
        for(char ch : wordChars) {
            int pos = ch - 'a';
            if(node.son[pos] == null) {
                return 0;
            }
            else {
                node = node.son[pos];
            }
        }
        
        return node.pearNumber;
    }
    
    /**
     * 深度优先遍历Trie树
     * @param root
     */
    public void traversal(TrieNode root) {
        if(root == null) {
            return;
        }
        for(TrieNode node : root.son) {
            System.out.println(node.val);
            traversal(node);
        }
    }

    public int getNodeNumber() {
        return nodeNumber;
    }

    public int getDepth() {
        return depth;
    }

    public TrieNode getRoot() {
        return root;
    }
    
}

 Leetcode应用：http://www.cnblogs.com/wxisme/p/4875309.html    http://www.cnblogs.com/wxisme/p/4876980.html