（第五章 1）组合——从DList到HashTable

最新推荐文章于 2023-07-28 21:35:19 发布
最新推荐文章于 2023-07-28 21:35:19 发布
阅读量404 收藏
点赞数
分类专栏： 系统程序员-成长计划 文章标签： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chuanwang66/article/details/84400165
版权

       在HashTable中，用到了DList来解决冲突，我们不用重新实现其内部的DList，只需将已经实现的双向链表DList组合到HashTable中使用即可。下面给出工程的全部代码：



就不再解释其中每个文件干嘛的了，我懂的。 依次来看看：

 

1. Makefile

-D name: Predefine name as a macro. (man gcc可以看到)

 

2. typedef.h

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

#ifndef TYPEDEF_H
#define TYPEDEF_H

typedef enum _Ret
{
	RET_OK,
	RET_OOM,
	RET_STOP,
	RET_INVALID_PARAMS,
	RET_FAIL
}Ret;

typedef void     (*DataDestroyFunc)(void* ctx, void* data);
typedef int      (*DataCompareFunc)(void* ctx, void* data);
typedef Ret      (*DataVisitFunc)(void* ctx, void* data);
typedef int       (*DataHashFunc)(void* data);

#ifdef __cplusplus
#define DECLS_BEGIN extern "C" {
#define DECLS_END   }
#else
#define DECLS_BEGIN
#define DECLS_END
#endif/*__cplusplus*/

#define return_if_fail(p) if(!(p)) \
	{printf("%s:%d Warning: "#p" failed.\n", \
		__func__, __LINE__); return;}
#define return_val_if_fail(p, ret) if(!(p)) \
	{printf("%s:%d Warning: "#p" failed.\n",\
	__func__, __LINE__); return (ret);}

#define SAFE_FREE(p) if(p != NULL) {free(p); p = NULL;}

typedef Ret (*SortFunc)(void** array, size_t nr, DataCompareFunc cmp);

#endif/*TYPEDEF_H*/

 

 

3. hash_table.h

#include <stdio.h>
#include "typedef.h"

#ifndef HASH_TABLE_H
#define HASH_TABLE_H

DECLS_BEGIN

struct _HashTable;
typedef struct _HashTable HashTable;

HashTable* hash_table_create(DataDestroyFunc data_destroy, void* ctx, DataHashFunc hash, int slot_nr);

size_t   hash_table_length(HashTable* thiz);
Ret      hash_table_insert(HashTable* thiz, void* data);
Ret      hash_table_delete(HashTable* thiz, DataCompareFunc cmp, void* data);
Ret      hash_table_find(HashTable* thiz, DataCompareFunc cmp, void* data, void** ret_data);
Ret      hash_table_foreach(HashTable* thiz, DataVisitFunc visit, void* ctx);

void hash_table_destroy(HashTable* thiz);

DECLS_END

#endif/*HASH_TABLE*/

 

 

4.hash_table.c

#include "dlist.h"
#include "hash_table.h"

struct _HashTable
{
	DataHashFunc    hash;
	DList**         slots;
	size_t          slot_nr;
	DataDestroyFunc data_destroy;
	void*           data_destroy_ctx;
};

HashTable* hash_table_create(DataDestroyFunc data_destroy, void* ctx, DataHashFunc hash, int slot_nr)
{
	HashTable* thiz = NULL;

	return_val_if_fail(hash != NULL && slot_nr > 1, NULL);
	
	thiz = (HashTable*)malloc(sizeof(HashTable));

	if(thiz != NULL)
	{
		thiz->hash = hash;
		thiz->slot_nr  = slot_nr;
		thiz->data_destroy_ctx = ctx;
		thiz->data_destroy = data_destroy;
		if((thiz->slots = (DList**)calloc(sizeof(DList*)*slot_nr, 1)) == NULL)
		{
			free(thiz);
			thiz = NULL;
		}
	}

	return thiz;
}

Ret      hash_table_insert(HashTable* thiz, void* data)
{
	size_t index = 0;

	return_val_if_fail(thiz != NULL, RET_INVALID_PARAMS);

	index = thiz->hash(data)%thiz->slot_nr;
	if(thiz->slots[index] == NULL)
	{
		thiz->slots[index] = dlist_create(thiz->data_destroy, thiz->data_destroy_ctx);
	}

	return dlist_prepend(thiz->slots[index], data);
}

Ret      hash_table_delete(HashTable* thiz, DataCompareFunc cmp, void* data)
{
	int index = 0;
	DList* dlist = NULL;

	return_val_if_fail(thiz != NULL && cmp != NULL, RET_INVALID_PARAMS);

	index = thiz->hash(data)%thiz->slot_nr;
	dlist = thiz->slots[index];
	if(dlist != NULL)
	{
		index = dlist_find(dlist, cmp, data);
	
		return dlist_delete(dlist, index);
	}

	return RET_FAIL;
}

size_t   hash_table_length(HashTable* thiz)
{
	size_t i = 0;
	size_t nr = 0;

	return_val_if_fail(thiz != NULL, 0);

	for(i = 0; i < thiz->slot_nr; i++)
	{
		if(thiz->slots[i] != NULL)
		{
			nr += dlist_length(thiz->slots[i]);
		}
	}

	return nr;
}

Ret    hash_table_find(HashTable* thiz, DataCompareFunc cmp, void* data, void** ret_data)
{
	int index = 0;
	DList* dlist = NULL;
	return_val_if_fail(thiz != NULL && cmp != NULL && ret_data != NULL, RET_INVALID_PARAMS);
	
	index = thiz->hash(data)%thiz->slot_nr;
	dlist = thiz->slots[index];
	if(dlist != NULL)
	{
		index = dlist_find(dlist, cmp, data);

		return dlist_get_by_index(dlist, index, ret_data);
	}

	return RET_FAIL;
}

Ret      hash_table_foreach(HashTable* thiz, DataVisitFunc visit, void* ctx)
{
	size_t i = 0;
	
	return_val_if_fail(thiz != NULL && visit != NULL, RET_INVALID_PARAMS);

	for(i = 0; i < thiz->slot_nr; i++)
	{
		if(thiz->slots[i] != NULL)
		{
			dlist_foreach(thiz->slots[i], visit, ctx);
		}
	}

	return RET_OK;
}

void hash_table_destroy(HashTable* thiz)
{
	size_t i = 0;

	if(thiz != NULL)
	{
		for(i = 0; i < thiz->slot_nr; i++)
		{
			if(thiz->slots[i] != NULL)
			{
				dlist_destroy(thiz->slots[i]);
				thiz->slots[i] = NULL;
			}
		}

		free(thiz->slots);
		free(thiz);
	}

	return;
}

#ifdef HASH_TABLE_TEST
#include "test_helper.c"

int main(int argc, char* argv[])
{
	int i = 0;
	int n = 10000;
	int ret_data = 0;
	HashTable* hash_table = hash_table_create(NULL, NULL, hash_int, 31);

	for(i = 0; i < n; i++)
	{
		assert(hash_table_length(hash_table) == i);
		assert(hash_table_insert(hash_table, (void*)i) == RET_OK);
		assert(hash_table_length(hash_table) == (i + 1));
		assert(hash_table_find(hash_table, cmp_int, (void*)i, (void**)&ret_data) == RET_OK);
		assert(ret_data == i);
	}

	for(i = 0; i < n; i++)
	{
		assert(hash_table_delete(hash_table, cmp_int, (void*)i) == RET_OK);
		assert(hash_table_length(hash_table) == (n - i -1));
		assert(hash_table_find(hash_table, cmp_int, (void*)i, (void**)&ret_data) != RET_OK);
	}
	
	hash_table_destroy(hash_table);

	return 0;
}
#endif/*HASH_TABLE_TEST*/

 

5. 最后来复习一下以前写的几个文件

typedef.h

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

#ifndef TYPEDEF_H
#define TYPEDEF_H

typedef enum _Ret
{
	RET_OK,
	RET_OOM,
	RET_STOP,
	RET_INVALID_PARAMS,
	RET_FAIL
}Ret;

typedef void     (*DataDestroyFunc)(void* ctx, void* data);
typedef int      (*DataCompareFunc)(void* ctx, void* data);
typedef Ret      (*DataVisitFunc)(void* ctx, void* data);
typedef int       (*DataHashFunc)(void* data);

#ifdef __cplusplus
#define DECLS_BEGIN extern "C" {
#define DECLS_END   }
#else
#define DECLS_BEGIN
#define DECLS_END
#endif/*__cplusplus*/

#define return_if_fail(p) if(!(p)) \
	{printf("%s:%d Warning: "#p" failed.\n", \
		__func__, __LINE__); return;}
#define return_val_if_fail(p, ret) if(!(p)) \
	{printf("%s:%d Warning: "#p" failed.\n",\
	__func__, __LINE__); return (ret);}

#define SAFE_FREE(p) if(p != NULL) {free(p); p = NULL;}

typedef Ret (*SortFunc)(void** array, size_t nr, DataCompareFunc cmp);

#endif/*TYPEDEF_H*/

 

dlist.h

#include <stdio.h>
#include "typedef.h"

#ifndef DLIST_H
#define DLIST_H

DECLS_BEGIN

struct _DList;
typedef struct _DList DList;

DList* dlist_create(DataDestroyFunc data_destroy, void* ctx);

Ret dlist_insert(DList* thiz, size_t index, void* data);
Ret dlist_prepend(DList* thiz, void* data);
Ret dlist_append(DList* thiz, void* data);
Ret dlist_delete(DList* thiz, size_t index);
Ret dlist_get_by_index(DList* thiz, size_t index, void** data);
Ret dlist_set_by_index(DList* thiz, size_t index, void* data);
size_t   dlist_length(DList* thiz);
int      dlist_find(DList* thiz, DataCompareFunc cmp, void* ctx);
Ret      dlist_foreach(DList* thiz, DataVisitFunc visit, void* ctx);

void dlist_destroy(DList* thiz);

DECLS_END

#endif/*DLIST*/

 
 

 

 

chuanwang66
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C 算法精介----链表->双向链表
TTc 's share
02-02 561
双向链表 双向链表,如同名字所暗示的那样，链表元素之间由2个指针链接，双向链表中的每一个元素都有3部分组成：除了数据成员和指针next外，新增加了一个指针prev，指向其前驱元素的指针。下图清晰绘出双向链表的结构： // // DList.c // Algorithms&Data_structures // // Created by TTc on
zephyr学习笔记---双向链表dlist
abatei的专栏
04-20 2557
现阶段学zephyr很困难，没有足够资料，东一锤子，西一榔头，转来转去还是转回数据结构。没办法，这几个数据结构是其它各类机制的基础，不研究一下还真不行。静下心来先搞数据结构吧。上次讲了单向链表slist，这次再弄个双向链表dlist。 先来看看结点的数据结构： struct _dnode {     union     {         struc
dlist(随机选择手机品牌列表brandlist)
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
02-25 525
数据结构问题：循环双链表有一个循环双链表，每个节点由两个指针(r 我来解答吧： void delnode(dlist *p) dlist *q,*r; q=p;---------1 while(q->right!=p) q=q->right;---------2 r=p...
【数据结构】带头+双向+循环链表（DList）（增、删、查、改）详解
最新发布
Elena's Blog
07-28 976
有和。一个是，指向其前一个节点；一个是，指向其后一个节点。
DList
wmy_1995的专栏
09-22 2293
#include using namespace std; typedef int DataType; class LinkNode { public: LinkNode(const DataType &x) :_data(x) , _prev(NULL) , _next(NULL) {} friend class DList; private: DataType _data;
dlist:以及它在 elixir 中的实现
06-20
第first和last操作是最坏情况 O(n)。 to_list也是 O(n) 最坏的情况。 alias Dlist . Dequedeque = Deque . newdeque = Deque . append (deque, 2 )deque = Deque . append (deque, 3 )deque = Deque . prepend ...
Dlist_链表_
09-30
1. 构造函数`Dlist()`通常初始化为空链表，头尾指针为`nullptr`，大小为0。 2. 析构函数`~Dlist()`需要负责释放链表中的所有节点，防止内存泄漏。 3. `insert(int value, int index)`函数在指定位置插入新值，需要...
Dlist.cpp
10-27
Dlist.cpp
dlist：Haskell中的差异列表
02-04
import Data.DList -- 创建一个差异列表，表示在任何列表后面添加1,2,3 dl = singleton 1 <> singleton 2 <> singleton 3 -- 将差异列表应用于空列表，得到[1,2,3] normalList = execDList dl [] -- 使用差异列表...
dlist:实验性 Javascript 双向链表
06-25
dlist（未经测试） 用 Javascript 编写的双向链表数据结构。 这是一个 Javascript 和伪经典模式的实验。列表（[元素...]） 列表取决于ddict字典对象。 继承的字典方法用于管理 List 状态： seed, cursor并允许使用...
程序员成长之路(转)
di0808的博客
01-31 303
什么时候才能成为一个专业程序员呢？三年还是五年工作经验？其实不用的，你马上就可以了，我没有骗你，因为专业程序员与业余程序员的区别主要在于一种态度，如果缺乏这种态度，拥有十年工作经验也还是业余的。 什么态度？专业态度！也就是星爷常说的专业精神。专业态度有多种表现形式，以后我们会一一介绍的。这里先介绍一下有关形象的态度，专业的程序员是很注重自己的形象的，当然程序员的形象不是表现在衣着和...
zephyr-双向链表
lbaihao的专栏
06-07 231
先来看看结点的数据结构： struct_dnode { union { struct_dnode*head;/*链表头指针(sys_dlist_t)*/ struct_dnode*next;/*下一节点指针(sys_dnode_t)*/ }; union { struct_dnode*tail;/*链表尾指针(sys_dlist_t)*/ struct...
双向链表(Dlist) 用模板实现
weixin_33806300的博客
03-27 711
#define_CRT_SECURE_NO_WARNINGS1 #include<iostream> #include<stdlib.h> usingnamespacestd; template<typenameT> structNode { Node(constT&d) :_nex...
ArrayList与LindedList区别
weixin_34075551的博客
09-26 148
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 转载于:https://www.cnblogs.com/niexinlei/...
event_dlist
qu1993的博客
03-07 276
今天看libevent源码的时候，看到struct evmap_io结构体，改结构体内容如下： struct evmap_io { struct event_dlist events; ev_uint16_t nread; ev_uint16_t nwrite; ev_uint16_t nclose; }; 里面第一个类型是struct event_dlist，但是用sourcein...
基于TI-RTOS的CC2650DK开发（1）---开发环境搭建
abatei的专栏
12-08 6903
前段一直在学51单片机，所以暂停翻译RPL文档。51初步了解后，现在开始转过头来学习CC2650芯片。看了下TI公司的开发工具Code Composer studio（CCS），基于eclipse，比Ubuntu下的vi好用得多了。实在是不喜欢在Linux下开发，太麻烦，无代码追踪，学习起来太不方便。TI公司有自己的操作系统TI-RTOS，我看了下，注释超级详细，代码编写堪称典范，如获至宝啊，看来
DList中的DataKeyField使用方法
weixin_30756499的博客
07-17 348
DList中的DataKeyField使用方法:1:<asp:DataList id="DList" runat="server" Width="100%" DataKeyField="GalleryId">指定好DataKeyField到DataList控件中2在程序中使用:foreach(DataListItem item in DList.Items){if(((S...
SlinkList（不带头节点的单链表）20171003
学无止境，Fighting！
10-03 483
#include typedef int Datatype; typedef struct link_node { Datatype info; struct link_node *next; }node; node *init(node *head) { return NULL; } void display(node *head) { if (!head
python list 遍历 输出ind与元素_【编程】Python 列表 List
weixin_39871162的博客
12-11 965
列表在Python 中使用的频率最高，列表也是对象，并且它可以处理另外的对象。列表和数组非常类似，它实现了序列协议，允许从队列里面增加和移除对象。列表用一对方括号表示，第一个元素的索引是 0。列表有许多关联的方法。创建列表在一对方括号内，用逗号隔开的一个值序列，就是列表。a_list = [1,2,3,4]b_list = ['a','b','c','d']c_list = ['一','二','三...
aList = [1,2,3] bList = [4,5,6] cList = [7,8,9] dList = zip(aList, bList, cList)
05-05
这段代码使用了zip函数来将三个列表aList、bList、cList合并为一个元组的列表dList。其中，第一个元组包含了aList、bList、cList中的第一个元素，第二个元组包含了它们的...dList = [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值