哈希表+双向链表的组合使用

在一个老牌通信公司工作几年,做的核心网项目开发,整天关注的是call flow,所参与的项目基本和MM和Call Control相关,

大多重点在项目开发逻辑,以及信令的解析和分析上。

公司内部代码有很多优秀的设计细节,和架构方式,只不过平时在此宏观的架构的基础上添加新代码,使用优秀简洁的接口,很少

仔细分析这些代码的优势所在。其中包括网络通信,进程间通信,以及多线程,共享内存,进程管理,状态机,以及定时器,

各种log机制。

最近有了一些闲暇时间,准备细细阅读基础代码,将一些优秀的设计理念和方法,加以整理总结。


首先看一下常用的hash表与双向链表结组合使用,这样的组合一般使用在网络通讯中,接收端收到大量的新数据消息,

将消息先存储到hash中,查询快捷,方便。


哈希表是由一个表头加上若干个节点组成,每个节点都是一个双向链表,数据对象实际是存储在哈希表节点的双向链表节点中。

由于每个节点都是一个双向链表,链表的每个节点中存储数据。

这样的好处是,如果随机产生的hash值如果相同,也可以使用,也不用重新产生命中的相同的hash值,可以直接存入对应的双向链表中。

这需要一个很好的散列化的hash函数,将数据对象均匀分布到节点的链表中。


哈希表的表头中定义了:

1. 哈希表的节点的最大个数变量

2. 产生哈希值的哈希函数指针变量的定义

3. 用于查找的对比函数指针变量的定义

4. 定义存储节点的数组

5. 存储数据对象的个数

双向链表定义:

1. 带有双向指针的表头

2. 带有双向指针的表尾

3. 带有双向链表中存储数据的个数


哈希表的表头定义如下:

/**
 * data structure of hash table
 */
typedef struct _HASHTABLE
{
        /// static configurable data of hash table
        int             numBuckets;     /// number of bucket in this hash table
        HASHFUNCPTR     hashFunc;       /// hash function from key to bucket
        COMPFUNCPTR     cmpFunc;        /// comparison function to the key of the object
        DLIST_P         bucketArray;    /// array of buckets in this hash table

        /// dynamic data of hash table
        int             numObjects;     /// number of objects in this hash table
} HASHTABLE_T, *HASHTABLE_P;


双向链表的定义如下:

/**
 *
 * The double linked list is used to manage the list of objects for specific purpose.
 * It allows the user to insert the object into or remove it from the list dynamically.
 *
 * To link them together, the object MUST contain GEN_NODE_T as the first element in its
 * structure, so that we can cast the pointer to the object to the GEN_NODE_P. 
 *
 * The structure of double linked list looks like the following.
 *
 *		+----------+         +----------+                         +----------+
 *     NULL <---+-- prev   |<--------+-- prev   |<--------       <--------+-- prev   |
 *		+----------+         +----------+           ...           +----------+
 *		|   next --+-------->|   next --+-------->       -------->|   next --+--->NULL
 *		+----------+         +----------+                         +----------+
 *		|   data   |         |   data   |                         |   data   |
 *		+----------+         +----------+                         +----------+
 *		     ^                                                         ^
 *        	     |                                                         |
 *   		     |                                                         |       
 *  		 head(list)                                                tail(list)    
 *
 */

/**
 * data structure of double linked list
 */
typedef struct _DLIST
{
	/// dynamic data of this list
	GEN_NODE_P	head;		/// pointer to the head node of this list
	GEN_NODE_P	tail;		/// pointer to the tail node of this list
	int		numObjects;	/// current number of nodes in this list
} DLIST_T, *DLIST_P;

/**
 * data structure of general purpose node used in double linked list
 *
 */
typedef struct _GEN_NODE {
        struct _GEN_NODE        *prev;          /// pointer to the previous node in the list
        struct _GEN_NODE        *next;          /// pointer to the next node in the list
} GEN_NODE_T, *GEN_NODE_P;



哈希表的创建:创建函数中有带入两个函数指针类型的函数,一个是hash函数,一个是对比函数,在头文件中事先定义好对应的函数指针。

哈希函数指针的定义

typedef unsigned int    (* HASHFUNCPTR)(const void *key);
对比函数指针的定义
typedef int     (* COMPFUNCPTR)(const void * obj, const void *key);

HASHTABLE_P HashTable_create(int numBuckets, HASHFUNCPTR hashFunc, COMPFUNCPTR cmpFunc)
{
        HASHTABLE_P ht = NULL;

        assert((hashFunc != NULL) && (cmpFunc != NULL) && (numBuckets > 0));

        ht = (HASHTABLE_P)calloc(1, sizeof(HASHTABLE_T) + sizeof(DLIST_T) * numBuckets);

        if (ht != NULL) {
                ht->numBuckets = numBuckets;
                ht->hashFunc = hashFunc;
                ht->cmpFunc = cmpFunc;
                ht->bucketArray = (DLIST_P)(ht + 1);
        }

        return ht;
}

这个函数是创建整个哈希表,为哈希表申请内存空间,包括哈希表的表头,还同时创建了numBuckets个双向链表。

在此用的申请空间的函数是calloc,在申请完空间后,会自动将空间清空。这是一个好的使用方法。

将哈希函数和对比函数的函数指针,赋入函数。

具体使用方法如下:

/* Max Number of Active CSFB CALL in Queue */
#define MAX_CSFB_CALL           4096

        g_pPgrHash  = HashTable_create(MAX_CSFB_CALL, s102PgrHash, s102PgrCmp);</span>
        if (g_pPgrHash  == NULL)
        {
                UX_ID_ELOG(ES1020623, "Unable to HashTable_create g_pPgrHash \n");
                UXTPCU(A21_KILL_SIG);
        }



销毁整个哈希表:销毁整个hash表,可以先调用清空此哈希表中所有数据的值,然后将申请的hash表的内存空间free掉。

void HashTable_destroy(HASHTABLE_P ht, FREEFUNCPTR freeFunc)
{
        assert(ht != NULL);

        // delete all the object from each bucket
        HashTable_delAllObjs(ht, freeFunc);

        // release the memory for hashtable
        free(ht);

        return;
}



哈希表插入数据:

可以根据查找函数HashTable_getBucket(),此函数的功能是根据key值,调用hash函数,产生hash值,返回对应数组中双向链表的地址。

然后调用双向链表的插入函数,将数据加入到双向链表的表尾处。

int HashTable_addObj(HASHTABLE_P ht, void *key, void *obj)
{
        DLIST_P bucket = NULL;

        assert((ht != NULL) && (key != NULL) && (obj != NULL));

        bucket = HashTable_getBucket(ht, key);
        if (bucket == NULL) return HASHTABLE_ERROR_HASHFAIL;

        if (DList_addObjTail(bucket, obj) != DLIST_NO_ERROR) {
                return HASHTABLE_ERROR_INSERTFAIL;
        }

        ht->numObjects++;
        return HASHTABLE_NO_ERROR;
}


双向链表添加数据的函数如下:

int DList_addObjTail(DLIST_P list, void *obj)
{
        assert((list != NULL) && (obj != NULL));

        GEN_NODE_P node = (GEN_NODE_P)obj;
        node->prev = list->tail;
        node->next = NULL;

        if (list->tail == NULL) {
                if ((list->head != NULL) || (list->numObjects != 0)) {
                        return DLIST_ERROR_INCONSISTENT;
                }

                list->head = node;
        } else {
                node->prev->next = node;
        }

        list->tail = node;
        list->numObjects++;

        return DLIST_NO_ERROR;
}

OBJ即为插入的数据对象,此数据对象有个要求,此数据结构的第一个变量必须是GEN_NODE_T      link;   

双向链表可以从head往里插入数据,也可从tail处插入数据。

此次是从tail处插入数据。

1. 首先将数据对象的首地址强制转换成节点类型,这就是为什么数据对象的结构体的第一个变量为什么必须是GEN_NODE_T 类型的缘故,将数据前后链接。

2. 从结尾处插入数据,将此节点的前驱指向双向链表的tail,将此节点的后继设为空。

3. 由于是双向链表,前一个数据,需要将后继改为新加入的节点,如果此链表为空,可直接将链表的头指向此数据对象节点。

4.从结尾出插入数据,新加入的数据即为tail,将链表的tail指向新加入的数据节点

5. 将链表中数据对象的个数加1


使用方法如下:

                       // add this csr into hash table with given key
                        retVal = HashTable_addObj(g_pCsrHash, (void *)mnidPtr, (void *)&g_s102csr[objId]);

                        if (retVal != HASHTABLE_NO_ERROR) {
                                UX_ID_ELOG( ES1020576, "Failed to call HashTable_addObj to add the csr index %d : retval: %d", objI\
d, retVal);
                                /// free the Correlation Id for other request message
                                Allocator_freeObject(g_pCsrIdleList, objId);
                                index = -1;
                        }


哈希表查找数据:

void *HashTable_findObj(HASHTABLE_P ht, void *key, DLIST_P *bucket)
{
        DLIST_P bkt = NULL;
        void    *obj = NULL;

        assert((ht != NULL) && (key != NULL));

        bkt = HashTable_getBucket(ht, key);
        if (bkt != NULL) {
                obj = DList_findObj(bkt, ht->cmpFunc, key);
        }

        if (bucket != NULL) *bucket = bkt;

        return obj;
}

根据查找函数HashTable_getBucket 获取key值应该放得节点位置

根据key值,调用hash函数,产生hash值,返回对应数组中双向链表的地址。

根据对比key,在此双向链表中查询此对象key值,如果找到,返回对应节点的地址。

根据节点地址,可获取此节点中对象的数据。

从双向链表中查找数据的函数如下:

void* DList_findObj(DLIST_P list, COMPFUNCPTR cmpFunc, void *key)
{
        assert((list != NULL) && (cmpFunc != NULL) && (key != NULL));

        GEN_NODE_P      node = list->head;
        int             count = 0;

        while ((node != NULL) && (count < list->numObjects)) {
                if ((* cmpFunc)((void *)node, key) == 0) return (void *)node;
                count++;
                node = node->next;
        }

        return NULL;
}
通过对比函数将key值和链表中的数据key值进行对比,返回节点地址。


哈希表删除一条数据:

void *HashTable_removeObj(HASHTABLE_P ht, void *key)
{
        DLIST_P bucket = NULL;
        void    *obj = NULL;

        assert((ht != NULL) && (key != NULL));

        obj = HashTable_findObj(ht, key, &bucket);

        if (obj != NULL) {
                if (bucket != NULL) {
                        DList_removeObj(bucket, obj);
                        ht->numObjects--;
                } else {
                        return NULL;
                }
        }

        return obj;
}

在此哈希表中删除一条数据包含了哈希表查找数据,然后再双向链表中将此数据删除,hash表中数据总个数减1。


双向链表删除一个对象的函数如下:

void DList_removeObj(DLIST_P list, void *obj)
{
        assert(list != NULL);

        GEN_NODE_P node = (GEN_NODE_P)obj;

        if (node == NULL) return;

        if (node->prev == NULL) {
                // if the object is the head of list, set the head to the next object
                list->head = node->next;
        } else {
                // otherwise, let the previous one links to the next object
                node->prev->next = node->next;
        }

        if (node->next == NULL) {
                // if the object is the tail of list, set the tail to the previous object
                list->tail = node->prev;
        } else {
                // otherwise, let the next one links to the previous object
                node->next->prev = node->prev;
        }

        // clear the linkage of this object
        node->prev = NULL;
        node->next = NULL;

        list->numObjects--;
        return;
}

删除一个对象的流程如下:

1. 首先将数据对象的首地址强制转换成节点类型,这就是为什么数据对象的结构体的第一个变量为什么必须是GEN_NODE_T 类型的缘故,将数据前后链接,便于操作。

2. 如果要删除的节点的前驱是空,表明此节点为head,将此节点的后继设为head即可

3. 如果要删除的节点的前驱不是空,将此节点前驱的后继指向此节点的后继。

4. 如果要删除的节点的后继是空,表明此节点为tail,将此节点的前驱设为tail即可

5.  如果要删除的节点的后继不是空,将此节点后继的前驱设为此节点的前驱

6. 将此节点前驱后继,设为null

7.链表中的数据总个数减1


清空整个哈希表:

void HashTable_delAllObjs(HASHTABLE_P ht, FREEFUNCPTR freeFunc)
{
        int i;

        assert(ht != NULL);

        for (i=0; i<ht->numBuckets; i++) {
                DList_delAllObjs(&ht->bucketArray[i], freeFunc);
        }

        ht->numObjects = 0;

        return;
}

获取哈希表中存储数据对象的个数:

int HashTable_getSize(HASHTABLE_P ht)
{
        assert(ht);

        if (ht->numObjects < 0) return HASHTABLE_ERROR_INCONSISTENT;
        return ht->numObjects;
}

根据key值获取哈希表数据节点的位置:

DLIST_P HashTable_getBucket(HASHTABLE_P ht, void *key)
{
        int slot = 0;

        assert((ht != NULL) && (key != NULL));

        slot = (* ht->hashFunc)(key);
        if ((slot < 0) || (slot >= ht->numBuckets)) return NULL;

        return &ht->bucketArray[slot];
}

根据key值,调用hash函数,产生hash值,返回对应数组中双向链表的地址。


以上为hash表的操作中套用双向链表的操作方法。

阅读更多
换一批

没有更多推荐了,返回首页