Hash

书上的代码 整理一下

 /*
 * Copyright (c) 2000-2008
 * Author: Weiming Zhou
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  
 */

#ifndef __HASHLIST_H__
#define __HASHLIST_H__

#ifdef __cplusplus
extern "C" {
#endif

#define MINIUM_BUCKET_COUNT   32


typedef struct HASHLISTNODE_st {
    struct HASHLISTNODE_st *pListNext;   /* 链表的后向节点指针 */
    struct HASHLISTNODE_st *pListPrev;   /* 链表的前向节点指针 */
    struct HASHLISTNODE_st *pBucketNext; /* 哈希表的链接指针 */
    void             *pData;             /* 数据指针 */
} HASHLISTNODE;

typedef struct HASHLIST_st {
    HASHLISTNODE **ppBuckets;    /* 哈希表的索引表 */
    UINT         uBucketCount;   /* 索引表的大小 */
    HASHLISTNODE *pHead;         /* 链表的头指针 */
    HASHLISTNODE *pTail;         /* 链表的尾指针 */
    UINT         uNodeCount;     /* 哈希链表中的节点个数 */
} HASHLIST;


HASHLIST *HashList_Create(UINT uBucketCount);

void HashList_Destroy(HASHLIST *pHashList, 
                       DESTROYFUNC DestroyFunc);

INT HashList_InsertHead(HASHLIST *pHashList, void *pData, HASHFUNC HashFunc);

INT HashList_Delete(HASHLIST *pHashList, 
                    void           *pData,
                    HASHFUNC        HashFunc,
                    COMPAREFUNC     HashCompareFunc, 
                    DESTROYFUNC     DestroyFunc);


HASHLISTNODE *HashList_FindNode(HASHLIST *pHashList, 
                                void *pData, 
                                HASHFUNC HashFunc, 
                                COMPAREFUNC CompareFunc);

void *HashList_FindData(HASHLIST *pHashList, 
                        void *pData, 
                        HASHFUNC HashFunc, 
                        COMPAREFUNC CompareFunc);

INT HashList_InsertSort(HASHLIST *pHashList, COMPAREFUNC CompareFunc);


UINT        HashStr( void *str, UINT str_len, UINT numBuckets );
UINT        HashStrCompare( void *str1, UINT str1_len, void *str2, UINT str2_len );
void        HashFree(void *pData, UINT uDataLen);

#ifdef __cplusplus
}
#endif

#endif /* __HASHLIST_H__ */


/*
 * Copyright (c) 2000-2008
 * Author: Weiming Zhou
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  
 */

#include <stdlib.h>
#include "CapiGlobal.h"
#include "HashList.h"


/**    哈希链表的创建函数

    @param    UINT uBucketCount - 索引表的大小    
    @return    HASHLIST * - 成功返回哈希表的指针，失败返回NULL    
*/
HASHLIST *HashList_Create(UINT uBucketCount)
{
    HASHLIST    *pHashList;

    /* 假设uBucketCount最小值不能低于MINIUM_BUCKET_COUNT */
    if ( uBucketCount < MINIUM_BUCKET_COUNT )
    {
        uBucketCount = MINIUM_BUCKET_COUNT;
    }

    pHashList = (HASHLIST *)malloc(sizeof(HASHLIST));
    if ( pHashList != NULL)
    {
        /* 创建哈希链表里的哈希表的索引表并初始化哈希表 */
        pHashList->ppBuckets = (HASHLISTNODE **)malloc(uBucketCount 
            * sizeof(HASHLISTNODE *));
        if ( pHashList->ppBuckets == NULL )
        {
            free(pHashList);
            return NULL;
        }
        memset((void *)pHashList->ppBuckets, 0, 
            uBucketCount * sizeof(HASHLISTNODE *));

        /* 初始化哈希表里面的双向链表 */
        pHashList->pHead = NULL;
        pHashList->pTail = NULL;
        pHashList->uBucketCount = uBucketCount;
        pHashList->uNodeCount = 0;
    }

    return pHashList;
}


/**    哈希链表的释放函数

    @param    HASHLIST *pHashList - 哈希链表指针    
    @param  DESTROYFUNC DestroyFunc - 数据释放回调函数    
    @return    void - 无    
*/
void HashList_Destroy(HASHLIST *pHashList, 
                      DESTROYFUNC DestroyFunc )
{
    UINT uIndex;
    if ( pHashList == NULL )
    {
        return;
    }

    for ( uIndex = 0; uIndex < pHashList->uBucketCount; uIndex++ )
    {
        HASHLISTNODE    *pNode;
        pNode = pHashList->ppBuckets[uIndex];
        while ( pNode != NULL )
        {
            HASHLISTNODE *pNodeToFree;

            pNodeToFree = pNode;
            pNode = pNode->pBucketNext;
            if ( DestroyFunc != NULL && pNodeToFree->pData != NULL )
            {
                (*DestroyFunc)(pNodeToFree->pData);
            }

            free(pNodeToFree);
        }
    }

    free(pHashList->ppBuckets);
    free(pHashList);

    return;
}


/**    哈希链表的数据插入函数，同时插入到哈希表和链表中，
    插入链表时是插入在链表的头部

    @param    HASHLIST *pHashList - 哈希链表指针    
    @param    void *pData - 要插入的数据指针    
    @param    HASHFUNC HashFunc - 哈希函数    
    @return    INT - CAPI_FAILED表示失败，CAPI_SUCCESS表示成功    
*/
INT HashList_InsertHead(HASHLIST *pHashList, void *pData, HASHFUNC HashFunc)
{
    HASHLISTNODE    *pNode;
    UINT            uBucketIndex;

    if ( pHashList == NULL || pData == NULL )
    {
        return CAPI_FAILED;
    }

    /* 生成哈希链表的节点 */
    pNode = (HASHLISTNODE *)malloc(sizeof(HASHLISTNODE));
    if ( pNode == NULL )
    {
        return CAPI_FAILED;
    }
    pNode->pData = pData;
    pNode->pBucketNext = NULL;
    pNode->pListPrev = NULL;
    pNode->pListNext = pHashList->pHead;

    /* 插入到哈希表中 */
    uBucketIndex = (*HashFunc)(pData, pHashList->uBucketCount);

    if ( pHashList->ppBuckets[uBucketIndex] == NULL )
    {
        pHashList->ppBuckets[uBucketIndex] = pNode;
    }
    else
    {
        HASHLISTNODE    *pTempNode;
        pTempNode = pHashList->ppBuckets[uBucketIndex];
        while ( pTempNode->pBucketNext != NULL )
        {
            pTempNode = pTempNode->pBucketNext;
        }
        pTempNode->pBucketNext = pNode;
    }

    /* 插入到链表中 */
    if ( pHashList->pHead == NULL )
    {
        pHashList->pHead = pNode;
        pHashList->pTail = pNode;
    }
    else
    {
        pNode->pListNext = pHashList->pHead;
        pHashList->pHead->pListPrev = pNode;
        pHashList->pHead = pNode;
    }

    pHashList->uNodeCount += 1;

    return CAPI_SUCCESS;
}


/**    哈希链表的单个节点删除函数，要同时从哈希表和链表中删除

    @param    HASHLIST *pHashList - 哈希链表指针    
    @param  void           *pData - 数据指针    
    @param  HASHFUNC        HashFunc - 哈希函数    
    @param  COMPAREFUNC     CompareFunc - 数据比较函数    
    @param  DESTROYFUNC     DestroyFunc - 数据释放函数    
    @return    INT - CAPI_FAILED表示失败，CAPI_SUCCESS表示成功        
*/
INT HashList_Delete(HASHLIST *pHashList, 
                    void           *pData,
                    HASHFUNC        HashFunc,
                    COMPAREFUNC     CompareFunc, 
                    DESTROYFUNC     DestroyFunc)
{
    HASHLISTNODE    *pNode;
    HASHLISTNODE    *pPrevNode;
    UINT            uIndex;

    if ( pHashList == NULL || HashFunc == NULL 
        || CompareFunc == NULL )
    {
        return CAPI_FAILED;
    }

    uIndex = (*HashFunc)(pData, pHashList->uBucketCount);
    pNode = pHashList->ppBuckets[uIndex];
    pPrevNode = NULL;

    while ( pNode != NULL )
    {
        if ( (*CompareFunc)(pNode->pData, pData ) == 0 )
        {
            if (pPrevNode == NULL )
            {
                pHashList->ppBuckets[uIndex] = pNode->pBucketNext;
            }
            else
            {
                pPrevNode->pBucketNext = pNode->pBucketNext;
            }

            /* 从链表中删除节点 */
            if ( pNode->pListPrev != NULL )
            {
                pNode->pListPrev->pListNext = pNode->pListNext;
            }
            else
            {
                /* pNode 是链表头指针 */
                pHashList->pHead = pNode->pListNext;
            }

            if ( pNode->pListNext != NULL )
            {
                pNode->pListNext->pListPrev = pNode->pListPrev;
            }
            else
            {
                /* 现在在链表尾部 */
                pHashList->pTail = pNode;
            }

            if ( pNode->pData != NULL && DestroyFunc != NULL )
            {
                (*DestroyFunc)(pNode->pData);
            }

            free(pNode);

            pHashList->uNodeCount -= 1;

            return CAPI_SUCCESS;
        }
        pPrevNode = pNode;
        pNode = pNode->pBucketNext;
    }

    return CAPI_FAILED;
}


/**    哈希链表的查找节点函数

    @param    HASHLIST *pHashList - 哈希链表指针    
    @param    void *pData - 要查找的数据指针    
    @param    HASHFUNC HashFunc - 哈希函数    
    @param    COMPAREFUNC CompareFunc - 数据比较函数    
    @return    HASHLISTNODE * - 成功返回查找到的哈希链表节点指针，
                             失败返回NULL    
*/
HASHLISTNODE *HashList_FindNode(HASHLIST *pHashList, 
                                void *pData, 
                                HASHFUNC HashFunc, 
                                COMPAREFUNC CompareFunc)
{
    HASHLISTNODE    *pNode;
    UINT            uIndex;

    if ( pHashList == NULL || HashFunc == NULL 
        || CompareFunc == NULL )
    {
        return NULL;
    }

    uIndex = (*HashFunc)(pData, pHashList->uBucketCount);
    pNode = pHashList->ppBuckets[uIndex];

    /* try to find the key from the HashTable */
    while ( pNode != NULL )
    {
        if ( (*CompareFunc)(pNode->pData, pData) == 0 )
        {
            /* 发现匹配的节点，返回节点指针 */
            return pNode;
        }
        pNode = pNode->pBucketNext;
    }

    /* 没有找到的情况下，返回NULL */
    return NULL;
}

 
/**    哈希链表的查找数据函数

    @param    HASHLIST *pHashList - 哈希链表指针    
    @param    void *pData - 要查找的数据指针    
    @param    HASHFUNC HashFunc - 哈希函数    
    @param    COMPAREFUNC CompareFunc - 数据比较函数    
    @return    void * - 成功返回查找到的数据指针，失败返回NULL    
*/
void *HashList_FindData(HASHLIST *pHashList, 
                        void *pData, 
                        HASHFUNC HashFunc, 
                        COMPAREFUNC CompareFunc)
{
    HASHLISTNODE    *pNode;
    UINT            uIndex;

    if ( pHashList == NULL || HashFunc == NULL 
        || CompareFunc == NULL )
    {
        return NULL;
    }

    uIndex = (*HashFunc)(pData, pHashList->uBucketCount);
    pNode = pHashList->ppBuckets[uIndex];

    /* try to find the key from the HashTable */
    while ( pNode != NULL )
    {
        if ( (*CompareFunc)(pNode->pData, pData) == 0 )
        {
            /* 发现匹配的节点，返回节点指针 */
            return pNode->pData;
        }
        pNode = pNode->pBucketNext;
    }

    /* 没有找到的情况下，返回NULL */
    return NULL;
}


/**    哈希链表的插入排序函数，用插入排序算法对哈希链表里的链表进行排序

    @param    HASHLIST *pHashList - 哈希链表指针    
    @param    COMPAREFUNC CompareFunc - 数据比较函数    
    @return    INT - CAPI_FAILED表示失败，CAPI_SUCCESS表示成功     
*/
INT HashList_InsertSort(HASHLIST *pHashList, COMPAREFUNC CompareFunc)
{
    HASHLISTNODE    *pNode;

    if ( pHashList == NULL || CompareFunc == NULL )
    {
        return 0;
    }

    pNode = pHashList->pHead;
    if ( pNode == NULL )
    {
        /* 没有节点在链表中，把它当作已经排好了序 */
        return 1;
    }

    while ( pNode->pListNext != NULL )
    {
        if ( (*CompareFunc)( pNode->pListNext->pData, pNode->pData ) < 0 )
        {
            HASHLISTNODE    *pTempNode;
            pTempNode = pNode->pListPrev;
            while ( pTempNode != NULL )
            {
                if ( (*CompareFunc)( pNode->pListNext->pData, 
                    pTempNode->pData ) >= 0 )
                {
                    HASHLISTNODE    *pCurNode;

                    /* 将节点弹出来 */
                    pCurNode = pNode->pListNext;
                    pNode->pListNext = pNode->pListNext->pListNext;
                    if ( pCurNode->pListNext != NULL )
                    {
                        pCurNode->pListNext->pListPrev = pNode;
                    }

                    /* 将节点插入到对应位置上 */
                    pCurNode->pListNext = pTempNode->pListNext;
                    pCurNode->pListPrev = pTempNode;
                    pTempNode->pListNext->pListPrev = pCurNode;
                    pTempNode->pListNext = pCurNode;
                    
                    break;
                }
                pTempNode = pTempNode->pListPrev;
            }

            /* 如果所有数据都大于该节点数据，将该节点插入到链表头部 */
            if ( pTempNode == NULL )
            {
                HASHLISTNODE    *pCurNode;

                /* 将节点弹出来 */
                pCurNode = pNode->pListNext;
                pNode->pListNext = pNode->pListNext->pListNext;
                if ( pCurNode->pListNext != NULL )
                {
                    pCurNode->pListNext->pListPrev = pNode;
                }

                /* 将节点插入链表头部 */
                pCurNode->pListPrev = NULL;
                pCurNode->pListNext = pHashList->pHead;
                pHashList->pHead = pCurNode;
            }
        }
        else
        {
            pNode = pNode->pListNext;
        }
    }

    return 1;
}



/*
 *    HashString( void *str )
 *    Calculate the hash value of a string.
 *    Parameters:
 *        void *str,        the string that need calculate.
 *    Return Values:
 *        the hash value of the string.
 */
UINT HashStr( void *str, UINT str_len, UINT numBuckets )
{
    char    *s;
//    int        i;
    int        hashval;
    int        ret;
    int        j;

//    strupr( (char *)str );
    s = (char *)str;
    hashval = 0;

#if 0
    for ( i = 0; i < 5 && s[i] != '\0'; i++ )
    {
        hashval += hashval << 3;
        hashval += s[i] ;
    }
#endif
    j = 0;
    ret = 0;
    while ( *s != '\0' )
    {
        if ( j == 5 )
        {
            j = 0;
            ret += hashval;
            hashval = 0;
        }
        hashval += hashval << 3;
//        hashval += tolower( (unsigned char)*s );
        s++;
        j++;
    }
    ret += hashval;

    return ret % numBuckets;
}

/*
 *    StrCompare( )
 *    Compare if two string is equal.
 *    Return Values:
 *        1        equal
 *        0        not equal
 */
UINT HashStrCompare( void *str1, UINT str1_len, void *str2, UINT str2_len )
{
    return stricmp( (char *)str1, (char *)str2 );
}

void HashFree(void *pData, UINT uDataLen)
{
    free( pData );
}

 /*
 * Copyright (c) 2000-2008
 * Author: Weiming Zhou
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  
 */

#ifndef __HASHTABLE_H__
#define __HASHTABLE_H__

#ifdef __cplusplus
extern "C" {
#endif

#define        HASHTABLE_SIZE        32767
#define        MAX_SEARCH_DEEP        30



typedef struct HASHTABLE {
    SINGLENODE **ppBucket;        /* 索引表指针 */
    UINT         uBucketCount;    /* 索引表的大小. */
    UINT         uNodeCount;        /* 表中的实际节点个数. */

    UINT        uCurBucketNo;   /* 当前要执行的Bucket序号 */
    SINGLENODE *pCurEntry;      /* 当前bucket中的下一个要执行的节点条目 */ 
} HASHTABLE;



/*** Hash Table operation functions ***/
HASHTABLE * HashTable_Create(UINT uBucketCount);

void    HashTable_Destroy(HASHTABLE *pTable, 
                          DESTROYFUNC DestroyFunc );

INT     HashTable_Insert( HASHTABLE *pTable, 
                          void *pData, 
                          HASHFUNC HashFunc);

void *  HashTable_Find(HASHTABLE *pTable, 
                       void *pData, 
                       HASHFUNC HashFunc,
                       COMPAREFUNC CompareFunc);

INT     HashTable_Delete(HASHTABLE *pTable, 
                         void *pData, 
                         HASHFUNC HashFunc,
                         COMPAREFUNC CompareFunc,
                         DESTROYFUNC DataDestroyFunc );

void    HashTable_EnumBegin(HASHTABLE *pTable);
void *  HashTable_EnumNext(HASHTABLE *pTable);




#ifdef __cplusplus
}
#endif

#endif /* __HASHTABLE_H__ */


/*
 * Copyright (c) 2000-2008
 * Author: Weiming Zhou
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  
 */

#include <stdlib.h>
#include <string.h>
#include "CapiGlobal.h"
#include "HashTable.h"


/**    哈希表的创建函数

    @param    UINT uBucketCount - 索引的大小    
    @return    HASHTABLE * - 成功返回哈希表的指针，失败返回NULL    
*/
HASHTABLE *    HashTable_Create(UINT uBucketCount)
{
    HASHTABLE    *pTable;

    if ( uBucketCount == 0 )
    {
        return NULL;
    }
    
    pTable = (HASHTABLE *)malloc( sizeof(HASHTABLE) );
    if ( pTable == NULL )
    {
        return NULL;
    }

    pTable->uNodeCount = 0;
    pTable->uBucketCount = uBucketCount;

    pTable->ppBucket = (SINGLENODE **)malloc( uBucketCount 
        * sizeof(SINGLENODE *));

    if (pTable->ppBucket == NULL)
    {
        free( pTable );
        return NULL;
    }

    memset(pTable->ppBucket, 0, uBucketCount * sizeof(SINGLENODE *));

    pTable->pCurEntry = NULL;
    pTable->uCurBucketNo = 0;

    return pTable;
}


/**    哈希表的释放函数

    @param    HASHTABLE *pTable - 哈希表指针    
    @param    DESTROYFUNC DestroyFunc - 数据释放函数，为NULL时只释放节点辅助
                                      空间，不释放数据    
    @return    void - 无    
*/
void HashTable_Destroy( HASHTABLE *pTable, 
                        DESTROYFUNC DestroyFunc)
{
    SINGLENODE **ppBucket;
    SINGLENODE  *pNode;
    SINGLENODE  *pFreeNode;
    UINT i;


    if ( pTable == NULL )
    {
        return;
    }
    ppBucket = pTable->ppBucket;
    for ( i = 0; i < pTable->uBucketCount; i++ ) 
    {
        pNode = ppBucket[i];
        while ( pNode != NULL )
        {
            if ( DestroyFunc != NULL )
            {
                (*DestroyFunc)(pNode->pData);
            }
            pFreeNode = pNode;
            pNode = pNode->pNext;
            free(pFreeNode);
        }
    }
    free(ppBucket);

    /* 将ppbucket设成空指针以避免哈希表被重新使用时造成内存泄漏 */
    pTable->ppBucket = NULL;

    free( pTable );
}


/**    哈希表的插入函数

    @param    HASHTABLE *pTable - 哈希表指针    
    @param    void *pData - 数据指针，其中包含关键词信息    
    @param    ASHFUNC HashFunc - 哈希函数，用来计算关键词的索引    
    @return    INT (by default) - CAPI_SUCCESS表示成功，CAPI_FAILED表示失败    
*/
INT    HashTable_Insert( HASHTABLE *pTable, 
                    void *pData, 
                    HASHFUNC HashFunc )
{
    UINT        uIndex;
    SINGLENODE    *pNode;
    SINGLENODE    *pNewNode;

    if ( pTable == NULL || pData == NULL || HashFunc == NULL )
    {
        return CAPI_FAILED;
    }

    uIndex = (*HashFunc)( pData, pTable->uBucketCount );
    pNode = (pTable->ppBucket)[uIndex];

    pNewNode = (SINGLENODE *)malloc( sizeof(SINGLENODE) );

    if ( pNewNode == NULL )
    {
    return CAPI_FAILED;
    }
    
    /* 将新节点插入到链表的头部 */
    pNewNode->pData = pData;
    pNewNode->pNext = pNode;

    (pTable->ppBucket)[uIndex] = pNewNode;
    pTable->uNodeCount += 1;

    return CAPI_SUCCESS;
}


/**    哈希表的查找函数

    @param    HASHTABLE *pTable - 哈希表指针    
    @param  void *pData - 包含关键词信息的数据指针    
    @param  HASHFUNC HashFunc - 哈希表的计算索引函数    
    @param  COMPAREFUNC CompareFunc - 关键词比较函数    
    @return    void * - 查到的数据指针，未查到返回NULL    
*/
void *    HashTable_Find(HASHTABLE *pTable, 
                               void *pData, 
                               HASHFUNC HashFunc,
                               COMPAREFUNC CompareFunc)
{
    UINT            uIndex;
    SINGLENODE *    pNode;

    if ( pTable == NULL || HashFunc == NULL || CompareFunc == NULL )
    {
        return NULL;
    }

    uIndex = (*HashFunc)( pData, pTable->uBucketCount );
    pNode = (pTable->ppBucket)[uIndex];
    
    /* 在 HASHTABLE 中进行查找 */
    while ( pNode != NULL )
    {
        if ( (*CompareFunc)( pNode->pData, pData) == 0 )
        {
            /* 已经找到了关键词，返回 */
            return pNode->pData;
        }
        pNode = pNode->pNext;
    }

    return NULL;
}


/**    哈希表的删除函数

    @param    HASHTABLE *pTable - 哈西表指针    
    @param  void *pData - 包含关键词信息的数据指针    
    @param  HASHFUNC HashFunc - 哈希函数，用来计算关键词的索引    
    @param  COMPAREFUNC CompareFunc - 关键词比较函数    
    @param  DESTROYFUNC DataDestroyFunc - 数据释放函数    
    @return    INT - CAPI_FAILED表示失败，CAPI_SUCCESS表示成功    
*/
INT HashTable_Delete(HASHTABLE *pTable, 
                     void *pData, 
                     HASHFUNC HashFunc,
                     COMPAREFUNC CompareFunc,
                     DESTROYFUNC DataDestroyFunc )

{
    UINT            uIndex;
    SINGLENODE *    pNode;
    SINGLENODE *    pPrevNode;

    if ( pTable == NULL || pData == NULL || HashFunc == NULL 
        || CompareFunc == NULL )
    {
        return CAPI_FAILED;
    }

    uIndex = (*HashFunc)( pData, pTable->uBucketCount );
    pNode = (pTable->ppBucket)[uIndex];
    pPrevNode = pNode;

    /* 从哈希表中查找 */
    while ( pNode != NULL )
    {
        if ( (*CompareFunc)( pNode->pData, pData ) == 0 )
        {
            if ( pPrevNode == pNode )
            {
                pTable->ppBucket[uIndex] = pNode->pNext;
            }
            else
            {
                pPrevNode->pNext = pNode->pNext;
            }

            /* 删除对应节点 */
            if ( DataDestroyFunc != NULL )
            {
                (*DataDestroyFunc)(pNode->pData);
            }
            free(pNode);

            pTable->uNodeCount -= 1;

            return 1;
        }

        pPrevNode = pNode;
        pNode = pNode->pNext;
    }

    return 0;
}


/**    哈希表的逐个节点遍历初始化函数

    @param    HASHTABLE *pTable - 哈希表指针    
    @return    void - 无    
*/
void HashTable_EnumBegin(HASHTABLE *pTable)
{
    pTable->uCurBucketNo = 0;
    pTable->pCurEntry = pTable->ppBucket[0];
}


/**    哈希表的逐个节点遍历函数

    @param    HASHTABLE *pTable - 哈希表指针    
    @return    void * - 遍历到的节点的数据指针    
*/
void * HashTable_EnumNext(HASHTABLE *pTable)
{
    void *pData;

    while ( pTable->pCurEntry == NULL )
    {
        pTable->uCurBucketNo += 1;
        if ( pTable->uCurBucketNo >= pTable->uBucketCount )
        {
            return NULL;
        }
        pTable->pCurEntry = pTable->ppBucket[pTable->uCurBucketNo];
    }

    pData = pTable->pCurEntry->pData;

    pTable->pCurEntry = pTable->pCurEntry->pNext;

    return pData;
}


/**    哈希表的计算整数的索引函数

    @param    UINT uKey - 关键词    
    @param    UINT uBucketCount - 哈希表的大小，用来做整除的模    
    @return    UINT - 索引值    
*/
UINT HashInt( void *pKey, UINT uBucketCount )
{
    return ((UINT)pKey) % uBucketCount;
}


/**    字符串类型数据的关键词索引计算函数
    将字符串折叠成每5个字符一段，每段看成是8进制整数，将各段相加后再取余数

    @param    void *pStr - 字符串指针    
    @param    UINT uBucketCount - 最大桶的个数，实际上被用来做为整除的模    
    @return    UINT - 字符串关键词的索引    
*/
UINT HashString( void *pStr, UINT uBucketCount )
{
    unsigned char    *psz;
    UINT    uHashValue;
    UINT    uRet;
    UINT    i;

    psz = (unsigned char *)pStr;
    uHashValue = 0;

    i = 0;
    uRet = 0;
    while ( *psz != '\0' )
    {
        if ( i == 5 )
        {
            i = 0;
            uRet += uHashValue;
            uHashValue = 0;
        }
        uHashValue += uHashValue << 3;
        uHashValue += (UINT)tolower( *psz );
        psz++;
        i++;
    }

    uRet += uHashValue;

    return uRet % uBucketCount;
}


/*
 *    HashBin( void *str )
 *    Calculate the hash value of a string.
 *    Parameters:
 *        void *str,        the string that need calculate.
 *    Return Values:
 *        the hash value of the string.
 */
UINT HashBin( void *pData, UINT uLength, UINT uBucketCount )
{
    unsigned char    *psz;
    UINT    uHashValue;
    UINT    uRet;
    UINT    i;
    UINT    j;

    psz = (unsigned char *)pData;
    uHashValue = 0;


    j = 0;
    uRet = 0;
    i = 0;
    while ( i < uLength )
    {
        if ( j == 5 )
        {
            j = 0;
            uRet += uHashValue;
            uHashValue = 0;
        }
        uHashValue += uHashValue << 3;
        uHashValue += (UINT)tolower( *psz );
        psz++;
        j++;
        i++;
    }

    uRet += uHashValue;

    return uRet % uBucketCount;
}


/*
 *    BinCompare( )
 *    Compare if two binary data is equal.
 *    Return Values:
 *        1        equal
 *        0        not equal
 */
UINT                
BinCompare( void *str1, int str1_len, void *str2, int str2_len )
{
    char    *psz1, *psz2;
    int        i;

    if ( str1_len != str2_len )
    {
        return 0;
    }

    psz1 = (char *)str1;
    psz2 = (char *)str2;

    i = 0;
    while ( i < str1_len )
    {
        if ( *psz1 != *psz2 )
        {
            return 0;
        }
        psz1++;
        psz2++;
        i++;
    }

    return 1;
}


/*
 *    StrCompare( )
 *    Compare if two string is equal.
 *    Return Values:
 *        1        pStr1 greater than pStr2
 *        0        pStr1 equal to pStr2
 *      -1      pStr1 less than pStr2
 */
INT StrCompare( void *pStr1, void *pStr2 )
{
    return stricmp( (char *)pStr1, (char *)pStr2 );
}

 /*
 * Copyright (c) 2000-2008
 * Author: Weiming Zhou
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  
 */

#ifndef __HASHRBTREE_H__
#define __HASHRBTREE_H__


#ifdef __cplusplus
extern "C" {
#endif

#if 0
typedef struct HASHRBTREENODE_st {
    struct HASHRBTREENODE_st *pLeft;
    struct HASHRBTREENODE_st *pRight;
    struct HASHRBTREENODE_st *pParent;
    INT                      nColor;
    
    struct HASHRBTREENODE_st *pNext;

    void    *pKey;
    UINT    ukeyLen;
    void    *pData;
    UINT    uDataLen;
} HASHRBTREENODE;
#endif


typedef struct HASHRBTREENODE_st {
    RBTREENODE  TreeNode;
    struct HASHRBTREENODE_st *pNext;
} HASHRBTREENODE;

typedef struct HASHRBTREE_st {
    RBTREE          *pTree;         /* 红黑树的指针 */  
    HASHRBTREENODE **ppBucket;     /* 哈希表的索引 */
    UINT         uBucketCount;  /* 哈希表索引中桶的数量 */        
} HASHRBTREE;

HASHRBTREE *HashRBTree_Create(UINT uBucketCount);
void HashRBTree_Destroy(HASHRBTREE *pHashRBTree, DESTROYFUNC DestroyFunc);


INT HashRBTree_Insert(HASHRBTREE *pHashRBTree, void *pData, HASHFUNC HashFunc,
                      COMPAREFUNC CompareFunc, DESTROYFUNC DestroyFunc);

INT HashRBTree_Delete(HASHRBTREE *pHashRBTree, void *pData, 
                      HASHFUNC HashFunc, 
                      COMPAREFUNC CompareFunc,
                      DESTROYFUNC DestroyFunc);

void * HashRBTree_HashFind(HASHRBTREE *pHashRBTree, void *pData, 
                           HASHFUNC HashFunc, 
                           COMPAREFUNC CompareFunc );

void * HashRBTree_TreeFind(HASHRBTREE *pHashRBTree, void *pData, 
                           COMPAREFUNC CompareFunc );

void HashRBTree_EnumBegin(HASHRBTREE *pHashRBTree);

void *HashRBTree_EnumNext(HASHRBTREE *pHashRBTree);




#ifdef __cplusplus
}
#endif

#endif /* __HASHRBTREE_H__ */


/*
 * Copyright (c) 2000-2008
 * Author: Weiming Zhou
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  
 */

#include <stdlib.h>
#include "CapiGlobal.h"
#include "BinTree.h"
#include "RBTree.h"
#include "HashRBTree.h"


/**    哈希红黑树的节点创建函数

    @param    void *pData - 数据指针    
    @return    static HASHRBTREENODE * - 成功返回创建的节点指针，失败返回NULL    
*/
static HASHRBTREENODE *HashRBTreeNode_Create( void *pData )
{
    HASHRBTREENODE *pNewNode;

    pNewNode = (HASHRBTREENODE *)malloc(sizeof(HASHRBTREENODE));
    if ( pNewNode != NULL )
    {
        RBTREENODE     *pTreeNode;

        pTreeNode = &(pNewNode->TreeNode);

        pTreeNode->pLeft = NULL;
        pTreeNode->pRight = NULL;
        pTreeNode->nMagic = RBTREE_COLOR_RED;
        pTreeNode->pData = pData;
        pTreeNode->pParent = NULL;

        pNewNode->pNext = NULL;
    }
    return pNewNode;
}

/**    哈希红黑树的创建函数

    @param    UINT uBucketNum - 哈希表的bucket数量    
    @return    HASHRBTREE * - 成功返回哈希红黑树指针，失败返回NULL。    
*/
HASHRBTREE *HashRBTree_Create(UINT uBucketCount)
{
    HASHRBTREE  *pHashRBTree;

    if ( uBucketCount == 0 )
    {
        return NULL;
    }

    pHashRBTree = (HASHRBTREE *)malloc( sizeof(HASHRBTREE) );
    if ( pHashRBTree != NULL )
    {
        pHashRBTree->ppBucket = (HASHRBTREENODE **)malloc( uBucketCount 
            * sizeof(HASHRBTREENODE *) );
        if ( pHashRBTree->ppBucket != NULL )
        {
            pHashRBTree->pTree = RBTree_Create();
            if ( pHashRBTree->pTree == NULL )
            {
                free( pHashRBTree->ppBucket );
                free( pHashRBTree );
                pHashRBTree = NULL;
            }
            else
            {
                memset(pHashRBTree->ppBucket, 0, uBucketCount * sizeof(HASHRBTREENODE *));
                pHashRBTree->uBucketCount = uBucketCount;
            }
        }
        else
        {
            free( pHashRBTree );
            pHashRBTree = NULL;
        }
    }
    return pHashRBTree;
}

/**    哈希红黑树的释放函数

    @param    HASHRBTREE *pHashRBTree - 哈希红黑树指针    
    @param    DESTROYFUNC DestroyFunc - 数据释放函数    
    @return    void - 无    
*/
void HashRBTree_Destroy(HASHRBTREE *pHashRBTree, DESTROYFUNC DestroyFunc)
{
    /* 哈希红黑树中，我们只要按红黑树的释放方法将所有节点释放即可 */
    if ( pHashRBTree != NULL && pHashRBTree->pTree != NULL )
    {
        RBTree_Destroy( pHashRBTree->pTree, DestroyFunc );

        /* 释放哈希表时，由于节点已经被释放了, 因此不需要释放节点 */
        free(pHashRBTree->ppBucket);
        free(pHashRBTree);
    }
}


/**    哈希红黑树的插入函数

    @param    HASHRBTREE *pHashRBTree - 哈希红黑树指针    
    @param    void *pData - 数据指针    
    @param    HASHFUNC HashFunc - 哈希函数    
    @param    COMPAREFUNC CompareFunc - 数据比较函数    
    @param    DESTROYFUNC DestroyFunc - 数据释放函数    
    @return    INT - CAPI_FAILED表示失败，CAPI_SUCCESS表示成功。    
*/
INT HashRBTree_Insert(HASHRBTREE *pHashRBTree, void *pData, HASHFUNC HashFunc,
                      COMPAREFUNC CompareFunc, DESTROYFUNC DestroyFunc)
{
    UINT        uIndex;

    INT nRet = CAPI_FAILED;
    if ( pHashRBTree != NULL )
    {
        HASHRBTREENODE  *pNewNode;

        pNewNode = (HASHRBTREENODE *)HashRBTreeNode_Create( pData );
        if ( pNewNode == NULL )
        {
            return CAPI_FAILED;
        }

        /* 先将节点插入到红黑树中 */
        nRet = RBTree_Inter_Insert(pHashRBTree->pTree, 
            (RBTREENODE *)pNewNode, CompareFunc);
        if ( nRet == CAPI_SUCCESS )
        {
            HASHRBTREENODE  *pNode;

            /* 在红黑树中插入成功后，再将其插入到哈希表中 */
            uIndex = (*HashFunc)( pData, pHashRBTree->uBucketCount );
            pNode = (HASHRBTREENODE *)(pHashRBTree->ppBucket[uIndex]);

            /* 在哈希表中查找对应节点 */
            while ( pNode != NULL )
            {
                if ( (*CompareFunc)( (pNode->TreeNode).pData, pData) == 0 )
                {
                    /* 哈希表中存在相同数据的节点，将节点的数据用新的数据覆盖 */
                    (*DestroyFunc)( (pNode->TreeNode).pData );
                    (pNode->TreeNode).pData = pData;

                    return nRet;
                }
                pNode = pNode->pNext;
            }

            /* 将新生成的节点插入到BUCKET的头部 */
            pNode = (HASHRBTREENODE *)pHashRBTree->ppBucket[uIndex];
            pNewNode->pNext = pNode;
            pHashRBTree->ppBucket[uIndex] = (HASHRBTREENODE *)pNewNode;
        }
    }

    return nRet;
}

/**    哈希红黑树的删除函数

    @param    HASHRBTREE *pHashRBTree - 哈希红黑树指针    
    @param    void *pData - 数据指针    
    @param    HASHFUNC HashFunc - 哈希函数    
    @param    COMPAREFUNC CompareFunc - 数据比较函数    
    @param    DESTROYFUNC DestroyFunc - 数据释放函数    
    @return    INT - 成功返回CAPI_SUCCESS, 失败返回CAPI_FAILED    
*/
INT HashRBTree_Delete(HASHRBTREE *pHashRBTree, void *pData, 
                      HASHFUNC HashFunc, 
                      COMPAREFUNC CompareFunc,
                      DESTROYFUNC DestroyFunc)
{
    UINT    uIndex;
    HASHRBTREENODE  *pNode;
    HASHRBTREENODE  *pPrevNode;

    uIndex = (*HashFunc)( pData, pHashRBTree->uBucketCount );
    pNode = (HASHRBTREENODE *)(pHashRBTree->ppBucket[uIndex]);
    pPrevNode = pNode;

    /* 在哈希表中删除对应的节点，注意这里因为还要在红黑树中删除对应数据的节点，
     * 因此节点内存必须在删除红黑树时才能释放.
     */
    while ( pNode != NULL )
    {
        if ( (*CompareFunc)( (pNode->TreeNode).pData, pData ) == 0 )
        {
            if ( pPrevNode == pNode )
            {
                pHashRBTree->ppBucket[uIndex] = pNode->pNext;
            }
            else
            {
                pPrevNode->pNext = pNode->pNext;
            }

            break;
        }

        pPrevNode = pNode;
        pNode = pNode->pNext;
    }    

    /* 在红黑树中将对应节点删除 */
    return RBTree_Delete(pHashRBTree->pTree, pData, CompareFunc, DestroyFunc);
}

/**    哈希红黑树的按红黑树查找方法进行查找的函数

    @param    HASHRBTREE *pHashRBTree - 哈希红黑树指针    
    @param    void *pData - 要查找的数据    
    @param    HASHFUNC HashFunc - 哈希函数    
    @param    COMPAREFUNC CompareFunc - 数据比较函数    
    @return    void * - 成功返回查找到的数据指针，失败返回NULL    
*/
void * HashRBTree_HashFind(HASHRBTREE *pHashRBTree, void *pData, 
                       HASHFUNC HashFunc, COMPAREFUNC CompareFunc )
{
    UINT                uIndex;
    HASHRBTREENODE *    pNode;

    /* 参数校验 */
    if ( pHashRBTree == NULL || pData == NULL 
        || HashFunc == NULL || CompareFunc == NULL )
    {
        return NULL;
    }

    uIndex = (*HashFunc)( pData, pHashRBTree->uBucketCount );
    pNode = (HASHRBTREENODE *)(pHashRBTree->ppBucket[uIndex]);
    
    /* 在哈希表冲突链中进行查找 */
    while ( pNode != NULL )
    {
        if ( (*CompareFunc)( (pNode->TreeNode).pData, pData) == 0 )
        {
            /* 找到了对应的数据，返回找到的数据指针 */
            return (pNode->TreeNode).pData;
        }
        pNode = pNode->pNext;
    }

    return NULL;
}


/**    哈希红黑树的按红黑树查找方法进行查找的函数

    @param    HASHRBTREE *pHashRBTree - 哈希红黑树指针    
    @param    void *pData - 要查找的数据    
    @param    COMPAREFUNC CompareFunc - 数据比较函数    
    @return    void * - 成功返回查找到的数据指针，失败返回NULL    
*/
void * HashRBTree_TreeFind(HASHRBTREE *pHashRBTree, void *pData, 
                           COMPAREFUNC CompareFunc )
{
    return RBTree_Find(pHashRBTree->pTree, pData, CompareFunc);
}


/**    哈希红黑树的逐个节点遍历初始化函数

    @param    HASHRBTREE *pHashRBTree - 哈希红黑树指针    
    @return    void - 无    
*/
void HashRBTree_EnumBegin(HASHRBTREE *pHashRBTree)
{
    RBTree_EnumBegin(pHashRBTree->pTree);
}


/**    哈希红黑树的逐个节点遍历函数，按照红黑树的遍历方法进行遍历

    @param    HASHRBTREE *pHashRBTree - 哈希红黑树指针    
    @return    void * - 数据指针    
*/
void *HashRBTree_EnumNext(HASHRBTREE *pHashRBTree)
{
    return RBTree_EnumNext(pHashRBTree->pTree);
}

/*
 * Copyright (c) 2000-2008
 * Author: Weiming Zhou
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  
 */

#ifndef __HASHAVLTREE_H__
#define __HASHAVLTREE_H__


#ifdef __cplusplus
extern "C" {
#endif

typedef BINTREEBASENODE AVLTREENODE;

typedef struct HASHAVLTREE_st {
    AVLTREENODE **ppBucket;    /* 索引表指针 */
    UINT     uBucketCount;    /* 索引表的大小. */
    UINT     uNodeCount;    /* 表中的实际节点个数. */
    
    UINT        uCurBucketNo;   /* 当前要执行的Bucket序号 */
    AVLTREENODE *pCurEntry;      /* 当前bucket中的下一个要执行的节点条目 */ 
} HASHAVLTREE;


HASHAVLTREE *HashAVLTree_Create(UINT uBucketCount);
void HashAVLTree_Destroy(HASHAVLTREE *pHashAVLTree, DESTROYFUNC DestroyFunc);


INT HashAVLTree_Insert(HASHAVLTREE *pHashAVLTree, void *pData, HASHFUNC HashFunc,
                      COMPAREFUNC CompareFunc);

INT HashAVLTree_Delete(HASHAVLTREE *pHashAVLTree, void *pData, 
                      HASHFUNC HashFunc, 
                      COMPAREFUNC CompareFunc,
                      DESTROYFUNC DestroyFunc);

void * HashAVLTree_Find(HASHAVLTREE *pHashAVLTree, void *pData, 
                       HASHFUNC HashFunc, 
                       COMPAREFUNC CompareFunc );

void HashAVLTree_EnumBegin(HASHAVLTREE *pHashAVLTree);

void *HashAVLTree_EnumNext(HASHAVLTREE *pHashAVLTree);




#ifdef __cplusplus
}
#endif

#endif /* __HASHAVLTREE_H__ */


/*
 * Copyright (c) 2000-2008
 * Author: Weiming Zhou
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  
 */

#include <windows.h>
#include "capiglobal.h"
#include "BinTree.h"
#include "AVLTree.h"
#include "HashAVLTree.h"

/**    哈希AVL树的创建函数

    @param    UINT uBucketCount - 哈希AVL树中BUCKET数量    
    @return    HASHAVLTREE * - 失败返回NULL,成功返回创建的哈希AVL树指针    
*/
HASHAVLTREE *HashAVLTree_Create(UINT uBucketCount)
{
    HASHAVLTREE    *pTree;
    
    if ( uBucketCount == 0 )
    {
        return NULL;
    }
    
    pTree = (HASHAVLTREE *)malloc( sizeof(HASHAVLTREE) );
    if ( pTree == NULL )
    {
        return NULL;
    }
    
    pTree->uNodeCount = 0;
    pTree->uBucketCount = uBucketCount;
    
    pTree->ppBucket = (AVLTREENODE **)malloc( uBucketCount 
        * sizeof(AVLTREENODE *));
    
    if (pTree->ppBucket == NULL)
    {
        free( pTree );
        return NULL;
    }
    
    memset(pTree->ppBucket, 0, uBucketCount * sizeof(AVLTREENODE *));
    
    pTree->pCurEntry = NULL;
    pTree->uCurBucketNo = 0;
    
    return pTree;
}

/**    哈希AVL树的释放函数
        将哈希AVL树中所有数据和节点及整个哈希AVL树整体释放掉

    @param    HASHAVLTREE *pHashAVLTree - 要释放的哈希AVL树指针    
    @param    DESTROYFUNC DestroyFunc - 数据释放回调函数    
    @return    void - 无    
*/
void HashAVLTree_Destroy(HASHAVLTREE *pHashAVLTree, DESTROYFUNC DestroyFunc)
{
    AVLTREENODE **ppBucket;
    AVLTREENODE  *pNode;
    UINT i;
    
    if ( pHashAVLTree == NULL )
    {
        return;
    }
    ppBucket = pHashAVLTree->ppBucket;
    for ( i = 0; i < pHashAVLTree->uBucketCount; i++ ) 
    {
        pNode = ppBucket[i];
        BinTreeBaseNode_Destroy(pNode, DestroyFunc);
    }
    free(ppBucket);
    
    /* 将ppbucket设成空指针以避免哈希表被重新使用时造成内存泄漏 */
    pHashAVLTree->ppBucket = NULL;
    
    free( pHashAVLTree );    
}


/**    哈希AVL树的插入函数

    @param    HASHAVLTREE *pHashAVLTree - 哈希AVL树指针    
    @param    void *pData - 要插入的数据指针    
    @param    HASHFUNC HashFunc - 哈希函数    
    @param    COMPAREFUNC CompareFunc - 数据比较回调函数    
    @return    INT - 失败返回CAPI_FAILED,成功返回CAPI_SUCCESS.    
*/
INT HashAVLTree_Insert(HASHAVLTREE *pHashAVLTree, void *pData, 
                       HASHFUNC HashFunc, COMPAREFUNC CompareFunc)
{
    UINT    uIndex;
    
    if ( pHashAVLTree == NULL || pData == NULL || HashFunc == NULL )
    {
        return CAPI_FAILED;
    }
    
    uIndex = (*HashFunc)( pData, pHashAVLTree->uBucketCount );
    
    /* 将新节点插入到链表的头部 */
    AVLTreeNode_Insert(&((pHashAVLTree->ppBucket)[uIndex]), pData, CompareFunc);
    
    pHashAVLTree->uNodeCount += 1;
    
    return CAPI_SUCCESS;
}

/**    哈希AVL树的节点删除函数

    @param    HASHAVLTREE *pHashAVLTree - 哈希AVL树指针    
    @param    void *pData - 数据指针    
    @param    HASHFUNC HashFunc - 哈希函数    
    @param    COMPAREFUNC CompareFunc - 数据比较回调函数    
    @param    DESTROYFUNC DestroyFunc - 数据释放回调函数    
    @return    INT - 失败返回CAPI_FAILED,成功返回CAPI_SUCCESS.    
*/
INT HashAVLTree_Delete(HASHAVLTREE *pHashAVLTree, void *pData, 
                      HASHFUNC HashFunc, 
                      COMPAREFUNC CompareFunc,
                      DESTROYFUNC DestroyFunc)
{
    UINT        uIndex;
    
    if ( pHashAVLTree == NULL || pData == NULL || HashFunc == NULL 
        || CompareFunc == NULL )
    {
        return CAPI_FAILED;
    }
    
    uIndex = (*HashFunc)( pData, pHashAVLTree->uBucketCount );

    if ( AVLTreeNode_Delete(&((pHashAVLTree->ppBucket)[uIndex]), pData, 
        CompareFunc, DestroyFunc) != CAPI_NOT_FOUND )
    {
        pHashAVLTree->uNodeCount -= 1;
    }

    return CAPI_SUCCESS;
}

/**    哈希AVL树的查找函数

    @param    HASHAVLTREE *pHashAVLTree - 哈希AVL树指针    
    @param    void *pData - 要查找的数据指针    
    @param    HASHFUNC HashFunc - 哈希函数    
    @param    COMPAREFUNC CompareFunc - 数据比较回调函数    
    @return    void * - 失败返回NULL，成功返回找到的节点中的数据指针    
*/
void * HashAVLTree_Find(HASHAVLTREE *pHashAVLTree, void *pData, 
                       HASHFUNC HashFunc, 
                       COMPAREFUNC CompareFunc )
{
    UINT            uIndex;
    AVLTREENODE *   pNode;
    
    if ( pHashAVLTree == NULL || HashFunc == NULL || CompareFunc == NULL )
    {
        return NULL;
    }
    
    uIndex = (*HashFunc)( pData, pHashAVLTree->uBucketCount );
    pNode = (pHashAVLTree->ppBucket)[uIndex];

    return BinTree_Find(pNode, pData, CompareFunc);
}


/**    哈希AVL树的逐个节点遍历开始函数

    @param    HASHAVLTREE *pHashAVLTree - 哈希AVL树指针    
    @return    void - 无    
*/
void HashAVLTree_EnumBegin(HASHAVLTREE *pHashAVLTree)
{
    AVLTREENODE *pCursor;

    pHashAVLTree->uCurBucketNo = 0;
    pCursor = pHashAVLTree->ppBucket[0];
    
    if ( pCursor != NULL )
    {
        while ( pCursor->pLeft != NULL )
        {
            pCursor = pCursor->pLeft;
        }
    }
    pHashAVLTree->pCurEntry = pCursor;
}

/**    哈希AVL树的逐个节点遍历函数

    @param    HASHAVLTREE *pHashAVLTree - 哈希AVL树指针    
    @return    void * - 返回遍历的节点数据指针，如果遍历完则返回NULL.    
*/
void *HashAVLTree_EnumNext(HASHAVLTREE *pHashAVLTree)
{
    void *pData;
    AVLTREENODE *pCursor;
    
    pCursor = pHashAVLTree->pCurEntry;
    while ( pCursor == NULL )
    {
        pHashAVLTree->uCurBucketNo += 1;
        if ( pHashAVLTree->uCurBucketNo >= pHashAVLTree->uBucketCount )
        {
            return NULL;
        }
        pCursor = pHashAVLTree->ppBucket[pHashAVLTree->uCurBucketNo];
    }
    
    if ( pCursor == NULL )
    {
        return NULL;
    }

    while ( pCursor->pLeft != NULL )
    {
        pCursor = pCursor->pLeft;
    }

    pData = pCursor->pData;
    
    if ( pCursor->pRight != NULL )
    {
        pCursor = pCursor->pRight;
        while ( pCursor->pLeft != NULL )
        {
            pCursor = pCursor->pLeft;
        }
    }
    else
    {
        AVLTREENODE *pParent = pCursor->pParent;
        while ( pParent != NULL && pParent->pRight == pCursor )
        {
            pCursor = pParent;
            pParent = pParent->pParent;
        }
        pCursor = pParent;
    }
    pHashAVLTree->pCurEntry = pCursor;
    
    return pData;    
}