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;
}

測試結果：

以上僅是我個人的觀點，代碼也僅僅是練練手而已，不保證理論和實現完全正確，僅供參考。