C++ TrieTree（字典树）容器的实现

最近研究了一下C++线程池，在网上看了一下别人的代码，写的很不错，参见：http://www.cnblogs.com/lidabo/p/3328646.html

其中，他用了STL的set容器管理线程池中的线程，在线程池运行的过程中需要频繁的进行插入、查找和删除的操作，我个人觉得这些操作会是线程池中的很大的时间开销，想起了大学老师讲过的一个TireTree(字典树)的数据结构，利用多叉树

可以快速的实现元素的插入、查找和删除，稍加改动也可以支持自动排序，唯一的缺点就是多叉树的结构空间开销较大，所以要控制好内存操作，防止内存泄露。

经测试，再插入元素和删除元素的方面，TrieTree比set有明显优势，在相同的元素数量下，内存开销也不过是set的1.5~2倍，时间却是1/10左右。

#ifndef _MY_TRIE_TREE
#define _MY_TRIE_TREE

template<class T,class K>
class TrieTree{
public:
    TrieTree();
    virtual ~TrieTree();
    bool insert(T *data,K key,bool overwrite = false);
    bool remove(K key,bool free_memory = false);
    bool find(K key,T *& pData);
private:
    enum
    {
        Dimension = 10,
    };
    typedef struct tagNode 
    {
        tagNode *child[Dimension];
        T *data;
        tagNode()
        {
            for(int i = 0;i < Dimension;i++)
            {
                child[i] = NULL;
            }
            data = NULL;
        }
        ~tagNode()
        {
            if(child == NULL)
            {
                delete[] child;
            }
            if(data != NULL)
            {
                delete data;
            }
        }
    }Node;
    Node *m_pHead;
    unsigned int m_nElementCnt;
    unsigned int m_nNodeCnt;
    void destory(Node *p_head);
public:
    void free();
    void dump();
    void trival( Node *pNode,int &nodeCnt );
};

template<class T,class K>
bool TrieTree<T, K>::find( K key,T *& pData )
{
    int m = 0;
    Node **p_find = NULL;
    if(m_pHead == NULL)
    {
        return false;
    }
    p_find = &m_pHead;
    while( key > 0 )
    {
        m = key%10;
        if((*p_find) != NULL)
        {
            p_find = &(*p_find)->child[m];
        }
        else
        {
            break;
        }
        key /= 10;
    }
    if((*p_find) != NULL)
    {
        // 数据为空
        if((*p_find)->data == NULL)
        {
            return false;
        }
        pData = (*p_find)->data;
        return true;
    }
    else
    {
        return false;
    }
}

template<class T,class K>
void TrieTree<T, K>::free()
{
    destory(m_pHead);
}

template<class T,class K>
void TrieTree<T, K>::destory( Node *p_head )
{
    if(p_head != NULL)
    {
        for(int i = 0;i < Dimension;i++)
        {
            destory(p_head->child[i]);
        }
        delete p_head;
        m_nNodeCnt--;
    }
}


template<class T,class K>
void TrieTree<T, K>::trival( Node *pNode,int &nodeCnt )
{
    if(pNode != NULL)
    {
        nodeCnt++;
        if(pNode->data != NULL)
        {
            //cout<<*(pNode->data)<<" ";
        }
        for(int i = 0;i < Dimension;i++)
        {
            trival(pNode->child[i],nodeCnt);
        }
    }
}

template<class T,class K>
void TrieTree<T, K>::dump()
{
    int nodeCnt = 0;
    trival(m_pHead,nodeCnt);
    cout<<endl;
    //cout<<endl<<"size = "<<sizeof(Node)<< " * "<<nodeCnt<<" = "<<sizeof(Node)*nodeCnt<<endl;
    //cout<<endl<<"data = "<<sizeof(T)<< " * "<<m_nElementCnt<<" = "<<sizeof(T)*m_nElementCnt<<endl;
    //cout<<endl<<"rate = "<<((double)sizeof(T) * m_nElementCnt)/(sizeof(Node)*nodeCnt)<<endl;
    cout<<"m_nNodeCnt = "<<m_nNodeCnt;
    cout<<",m_nElementCnt = "<<m_nElementCnt;
    cout<<",nodeCnt = "<<nodeCnt<<endl;
}

template<class T,class K>
TrieTree<T,K>::TrieTree()
{
    m_pHead = new Node();
    m_nElementCnt = 0;
    m_nNodeCnt = 1;
}


template<class T,class K>
TrieTree<T,K>::~TrieTree()
{
    destory(m_pHead);
}

template<class T,class K>
bool TrieTree<T, K>::remove( K key ,bool free_memory)
{
    int m = 0;
    Node **p_find = NULL;
    if(m_pHead == NULL)
    {
        return false;
    }
    p_find = &m_pHead;
    while( key > 0 )
    {
        m = key%10;
        if((*p_find) != NULL)
        {
            p_find = &(*p_find)->child[m];
        }
        else
        {
            break;
        }
        key /= 10;
    }
    if((*p_find) != NULL)
    {
        // 不释放节点空间
        if( free_memory == false )
        {
            if((*p_find)->data == NULL)
            {
                return false;
            }
            delete (*p_find)->data;
            (*p_find)->data = NULL;
            m_nElementCnt--;
            return true;
        }
        // 释放节点空间
        else
        {
            //并不是所有节点都能释放，没有子节点的节点才能释放
            bool hasChild  = false;
            for(int i = 0;i < Dimension;i++)
            {
                if((*p_find)->child[i] != NULL)
                {
                    hasChild = true;
                }
            }
            // 释放节点,直接delete
            if(hasChild == false)
            {
                delete (*p_find);
                (*p_find) = NULL;
                m_nElementCnt--;
                m_nNodeCnt--;
            }
            // 不能释放节点，释放data，data = NULL
            else
            {
                if((*p_find)->data == NULL)
                {
                    return false;
                }
                T *pData = (*p_find)->data;
                (*p_find)->data = NULL;
                delete pData;
                pData = NULL;
                m_nElementCnt--;
                return true;
            }
        }
    }
    else
    {
        return false;
    }
}

template<class T,class K>
bool TrieTree<T, K>::insert( T *data,K key,bool overwrite)
{
    int m = 0;
    Node **p_find = NULL;
    if(m_pHead == NULL)
    {
        return false;
    }
    p_find = &m_pHead;
    while( key > 0 )
    {
        m = key%10;
        if((*p_find) == NULL)
        {
            (*p_find) = new Node();
            m_nNodeCnt++;
        }
        p_find = &(*p_find)->child[m];
        key /= 10;
    }
    if((*p_find) == NULL)
    {
        (*p_find) = new Node();
        (*p_find)->data = data;
        m_nNodeCnt++;
        m_nElementCnt++;
        return true;
    }
    else
    {
        if((*p_find)->data == NULL)
        {
            (*p_find)->data = data;
            m_nElementCnt++;
            return true;
        }
        else
        {
            if(overwrite == false)
            {
                return false;
            }
            else
            {
                (*p_find)->data = data;
                m_nElementCnt++;
                return true;
            }
        }
    }
}

#endif

测试代码：

void test1()
{
    int cnt = 0;
    time_t s,e;
    int n = 10,m = 0;
    TrieTree<R,int> a;
    set<R*> b;
    for(m = 1;m < 7;m++)
    {
        cout<<"item count:"<<n<<endl;
        s = clock();
        for(int i = 1;i < n;i++)
        {
            R *r = new R(i);
            a.insert(r,i);
        }
        //a.dump();
        for(int i = 1;i < n/2;i++)
        {
            a.remove(i,true);
        }
        e = clock();
        cout<<"TrieTree Use Time:"<<e-s<<endl;
        s = clock();
        for(int i = 1;i < n;i++)
        {
            R *r = new R(i);
            b.insert(r);
        }
        b.clear();
        e = clock();
        cout<<"Set Use Time:"<<e-s<<endl;
        cout<<"-------------------"<<endl;
        n*=10;
    }
}
int main()
{
    test1();
    system("pause");
    return 0;
}

测试结果：

以上仅是我个人的观点，代码也仅仅是练练手而已，不保证理论和实现完全正确，仅供参考。