经典数据结构之字母树

字母树（TrieTree）是一种数据结构，可以实现O(s.length)的时间插入、删除、查找。

相比映射（map），字母树不存在哈希碰撞，实现相对简单。

“字母”其实是个泛指概念，字母树的索引可以是任何的串，只要组成串的元素是有限个。但如果组成串的元素太多，就不是很适合用字母树了，因为可能会造成大量空间浪费，但是时间性能还是很稳定。

以下是我自己实现的一个C#版本的泛型字母树，代码来自我做ACM题目时候用C++写的粗糙版本（只针对一个题目写的版本），没经过严格测试，各位朋友如果发现错误，还望不吝赐教。

/**//// <summary>
/// 泛型字母树，忽略大小写
/// </summary>
/// <typeparam name="T">泛型类型</typeparam>
public class TrieTree<T> {
    private class TrieNode {
        fields#region fields

        private TrieNode[] m_Childs;
        private T m_Value;
        private bool m_HasValue;

        #endregion

        constructors#region constructors

        /**//// <summary>
        /// 创建字母树结点，元素被赋值为该类型的默认值
        /// </summary>
        public TrieNode() : this(default(T)) { m_HasValue = false; }

        /**//// <summary>
        /// 创建字母树结点
        /// </summary>
        /// <param name="elem">该结点的元素</param>
        public TrieNode(T elem) {
            m_Childs = new TrieNode[26];
            m_Value = elem;
            m_HasValue = true;
        }

        #endregion

        properties#region properties

        /**//// <summary>
        /// 子节点
        /// </summary>
        public TrieNode[] Childs { get { return m_Childs; } }

        /**//// <summary>
        /// 节点的值
        /// </summary>
        public T Value {
            get { return m_Value; }
            set { m_Value = value; }
        }

        /**//// <summary>
        /// 结点是否有值
        /// </summary>
        public bool HasValue {
            get { return m_HasValue; }
            set { m_HasValue = value; }
        }

        #endregion
    }

    fields#region fields

    private TrieNode root = new TrieNode();

    #endregion

    private methods#region private methods

    TrieNode findNode(string key) {
        TrieNode node = root;
        foreach (char c in key) {
            int i = (c >= 'A' && c <= 'Z') ? (int)(c - 'A' + 'a') : (int)(c - 'a');
            if (node.Childs[i] == null) node.Childs[i] = new TrieNode();
            node = node.Childs[i];
        }
        return node;
    }

    #endregion

    public methods#region public methods

    /**//// <summary>
    /// 插入
    /// </summary>
    /// <param name="key">键</param>
    /// <param name="value">值</param>
    public void Insert(string key, T value) {
        TrieNode node = findNode(key);
        if (node.HasValue) return;
        node.Value = value;
        node.HasValue = true;
    }

    /**//// <summary>
    /// 查找，若不存在，则插入
    /// </summary>
    /// <param name="key">键</param>
    /// <param name="value">结点不存在时所赋的值</param>
    /// <returns>查找结果</returns>
    public T FindOrInsert(string key, T value) {
        TrieNode node = findNode(key);
        if (!node.HasValue) {
            node.Value = value;
            node.HasValue = true;
        }
        return node.Value;
    }

    /**//// <summary>
    /// 查找，若不存在，则返回默认值
    /// </summary>
    /// <param name="key">键</param>
    /// <param name="defaultValue">默认值</param>
    /// <returns>查找结果</returns>
    public T Find(string key, T defaultValue) {
        TrieNode node = findNode(key);
        if (node.HasValue) return node.Value;
        return defaultValue;
    }

    #endregion

    indexer#region indexer

    /**//// <summary>
    /// 获取或设置某个键对应的值
    /// </summary>
    /// <param name="key">键</param>
    /// <returns>查找结果，若不存在，则返回该泛型类型的默认值</returns>
    public T this[string key] {
        get { return Find(key, default(T)); }
        set {
            TrieNode node = findNode(key);
            node.HasValue = true;
            node.Value = value;
        }
    }

    #endregion
}