一种基于双向链表设计的map数据存储操作接口(加入类迭代器设计)

最新推荐文章于 2022-09-07 19:57:50 发布
置顶 最新推荐文章于 2022-09-07 19:57:50 发布
阅读量187 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xiyuan255/article/details/105836735
版权
本文介绍了一个使用C语言实现的链表映射容器，包括初始化、插入、删除、查找等操作，并提供了完整的源代码。该容器适用于需要快速查找和修改数据的场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

源码的下载地址：https://download.youkuaiyun.com/download/xiyuan255/12372494

/*
 * File name	: xy_list_code.c
 *
 * Created on	: 2019年8月29日10:39:35
 * Author		  : Firmware of xiyuan255
 * Version		: 2.0
 * Language		: C
 * Copyright	: Copyright (C) 2019, xiyuan255 Inc.
 *
 */
#include <stdio.h>
#include <malloc.h>
#include "xy_cmap_source.h"

typedef struct s_map_list
{
	PCPAIR_T ptr_data;
	struct s_map_list *ptr_prev;
	struct s_map_list *ptr_next;
	
} map_list_t, *map_list_p;

typedef struct _s_cmap_
{
	map_list_p	ptr_head;	/**< map_list_p链表的头指针 */
	map_list_p	ptr_tail;	/**< map_list_p链表的尾指针 */
	c_compare_t	compare;	/**< map容器的比较函数指针 */
	
} cmap_t, *cmap_p;

#define CMAP_HEAD(cmap)		( ((cmap_p)cmap)->ptr_head )
#define CMAP_TAIL(cmap)		( ((cmap_p)cmap)->ptr_tail )
#define CMAP_COMPARE(cmap)	( ((cmap_p)cmap)->compare )

/** 
 * \brief 通过迭代器指针解析数据指针
 * \param ptr_iterator	[in] 参数名称，迭代器指针
 * \return
 *			!NULL 	: 数据指针			\n
 *			NULL	: 不存在	\n
 */
__STATIC PDATA_T c_map_data(PITERATOR_T iterator)
{
	return ( (NULL != iterator)? (((map_list_p)iterator)->ptr_data) : NULL );
}

/** 
 * \brief 获取迭代器的前一个指针
 * \param ptr_iterator	[in] 参数名称，迭代器指针
 * \return
 *			!NULL 	: 迭代器指针			\n
 *			NULL	: 不存在	\n
 */
__STATIC void c_map_prev(PITERATOR_T ptr_iterator)
{		
	if (NULL != ptr_iterator)
	{
		ptr_iterator->_value = ((map_list_p)ptr_iterator->_value)->ptr_prev;
	}
}

/** 
 * \brief 获取迭代器的后一个指针
 * \param ptr_iterator	[in] 参数名称，迭代器指针
 * \return
 *			!NULL 	: 迭代器指针			\n
 *			NULL	: 不存在	\n
 */
__STATIC void c_map_next(PITERATOR_T ptr_iterator)
{	
	if (NULL != ptr_iterator)
	{
		ptr_iterator->_value = ((map_list_p)ptr_iterator->_value)->ptr_next;
	}
}

/** 
 * \brief 判断两个迭代器指针是否相等
 * \param ptr_iter1	[in] 参数名称，迭代器指针1 
 * \param ptr_iter2	[in] 参数名称，迭代器指针2
 * \return
 *			true 	: 相等	\n
 *			false	: 不相等	\n
 */
__STATIC boolean c_map_equal(PITERATOR_T ptr_iter1, PITERATOR_T ptr_iter2)
{	
	return (  (ptr_iter1 && ptr_iter2) && (ptr_iter1->_value == ptr_iter2->_value) );
}

__STATIC iterator_ft sg_map_iterator = 
{
		c_map_data,
		c_map_prev,
		c_map_next,
		c_map_equal,
};

/** 
 * \brief 初始化CMAP对象 
 * \param compare	[in] 参数名称，比较函数
 * \return
 *		!NULL	: 成功返回句柄		\n
 *	   	NULL	: 初始化失败			\n
 */
PUBLIC CMAP c_map_init(c_compare_t compare)
{
	cmap_t *cmap = NULL;

	cmap = (cmap_t *)calloc(sizeof(char), sizeof(cmap_t)); 
	if (NULL == cmap) {
		return NULL;
	}
	cmap->ptr_head = (map_list_p)cmap;
	cmap->ptr_tail = (map_list_p)cmap;
	cmap->compare  = compare;

	return (CMAP)cmap;
}

/** 
 * \brief 清空CMAP对象 
 * \param cmap	[in] 参数名称，CMAP对象
 * \return
 */
PUBLIC void c_map_clear(CMAP cmap)
{	
	map_list_p ptr_node1 = NULL;
	map_list_p ptr_node2 = CMAP_HEAD(cmap);

	while (ptr_node2 != NULL)
	{
		ptr_node1 = ptr_node2->ptr_next;
		free(ptr_node2);
		ptr_node2 = ptr_node1;
	}

	CMAP_TAIL(cmap) = cmap;
	CMAP_HEAD(cmap)	= cmap;
}

/** 
 * \brief 销毁CMAP对象 
 * \param ptr_cmap	[in] 参数名称，CMAP对象指针
 * \return
 */
PUBLIC void c_map_destroy(CMAP *ptr_cmap)
{
	if (NULL != ptr_cmap)
	{		
		c_map_clear(*ptr_cmap);
		
		free(*ptr_cmap);
		*ptr_cmap = NULL;
	}
}

/** 
 * \brief 计算CMAP对象的长度 
 * \param cmap	[in] 参数名称，CMAP对象
 * \return
 * 		返回对象长度
 */
PUBLIC int c_map_size(CMAP cmap)
{	
	int count = 0;
	map_list_p ptr_node = CMAP_HEAD(cmap);

	while (ptr_node != cmap)
	{
		count++;
		ptr_node = ptr_node->ptr_next;
	}
	
	return count;
}

/** 
 * \brief 判断CMAP对象的是否为空 
 * \param cmap	[in] 参数名称，CMAP对象
 * \return
 *		   true    : 为空    \n
 *		   false   : 不为空 \n
 */
PUBLIC boolean c_map_empty(CMAP cmap)
{	
	return ( (NULL == cmap || cmap == CMAP_HEAD(cmap)) ? true : false );
}

/** 
 * \brief 获取CMAP对象的头迭代器 
 * \param cmap	[in] 参数名称，CMAP对象
 * \return
 * 		返回对象的头迭代器
 */
PUBLIC ITERATOR_T c_map_begin(CMAP cmap)
{
	ITERATOR_T iterator = {NULL, cmap};
	
	if (NULL != cmap)
	{
		iterator._pft = &sg_map_iterator;
		iterator._value = CMAP_HEAD(cmap);
	}

	return iterator;
}

/** 
 * \brief 获取CMAP对象的尾迭代器 
 * \param cmap	[in] 参数名称，CMAP对象
 * \return
 * 		返回对象的尾迭代器
 */
PUBLIC ITERATOR_T c_map_tail(CMAP cmap)
{
	ITERATOR_T iterator = {NULL, cmap};
	
	if (NULL != cmap)
	{
		iterator._pft = &sg_map_iterator;
		iterator._value = CMAP_TAIL(cmap);
	}

	return iterator;
}

/** 
 * \brief 获取CMAP对象的结束迭代器 
 * \param cmap	[in] 参数名称，CMAP对象
 * \return
 * 		返回对象的结束迭代器
 */
PUBLIC ITERATOR_T c_map_end(CMAP cmap)
{	
	ITERATOR_T iterator = {NULL, cmap};

	return iterator;
}

/** 
 * \brief 向CMAP对象插入数据
 * \param cmap		[in] 参数名称，CMAP对象
 * \param ptr_data	[in] 参数名称，数据指针
 * \return
 * 		-1	: 动态内存分配失败
 * 		 0	: 插入成功
 */
PUBLIC int c_map_insert(CMAP cmap, const PCPAIR_T ptr_data)
{
	map_list_p ptr_node = CMAP_HEAD(cmap); // 取头结点指针
	map_list_p ptr_new  = (map_list_p)calloc(sizeof(char), sizeof(map_list_t));
	if (NULL == ptr_new) {
		c_error("[%s, %s, %d] memory allocation failed.\n", __FILE__, __FUNCTION__, __LINE__);
		return -1;
	}
	
	ptr_new->ptr_data = ptr_data;

	if (cmap == CMAP_HEAD(cmap))
	{
		ptr_new->ptr_next = (map_list_p)cmap;
		ptr_new->ptr_prev = (map_list_p)cmap;
		CMAP_HEAD(cmap) = ptr_new;
		CMAP_TAIL(cmap) = ptr_new;
	}
	else
	{
		while (ptr_node->ptr_next != cmap) {
			ptr_node = ptr_node->ptr_next;
		}
		ptr_new->ptr_prev  = ptr_node;
		ptr_new->ptr_next  = (map_list_p)cmap;
		ptr_node->ptr_next = ptr_new;
	}
		
	return 0;
}

/** 
 * \brief 擦除CMAP对象的数据
 * \param cmap		[in] 参数名称，CMAP对象
 * \param position	[in] 参数名称，迭代器指针 
 * \return
 */
PUBLIC void c_map_erase(CMAP cmap, PITERATOR_T position)
{
	map_list_p ptr_node = NULL;
	
	if (NULL != cmap && ptr_node != cmap)
	{		
		ptr_node = (map_list_p)(position->_value); 	
		if (ptr_node == CMAP_HEAD(cmap))
		{
			if (CMAP_HEAD(cmap) == CMAP_TAIL(cmap))
			{
				CMAP_HEAD(cmap) = (map_list_p)cmap;
				CMAP_TAIL(cmap) = (map_list_p)cmap;
			}
			else
			{
				ptr_node->ptr_next->ptr_prev = (map_list_p)cmap;
				CMAP_HEAD(cmap) = ptr_node->ptr_next;
			}			
		}
		else if (ptr_node == CMAP_TAIL(cmap))
		{
			ptr_node->ptr_prev->ptr_next = cmap;
			CMAP_TAIL(cmap) = ptr_node->ptr_prev;
		}
		else
		{
			ptr_node->ptr_prev->ptr_next = ptr_node->ptr_next;
		}
		
		free(ptr_node);
	}
}

/** 
 * \brief 查找与ptr_key相同的数据指针
 * \param cmap		[in] 参数名称，CMAP对象
 * \param ptr_key	[in] 参数名称，KEY值 
 * \param keylen	[in] 参数名称，KEY值的长度
 * \return 
 *			!NULL	: 存在		\n
 *		    NULL	: 不存在	\n
 */
PUBLIC PCPAIR_T c_map_find(CMAP cmap, PKEY_T ptr_key, int keylen)
{
	map_list_p ptr_node = NULL;
	
	CHECK_PARAM_IS_NULL_RET(cmap, NULL);		
	CHECK_PARAM_IS_NULL_RET(CMAP_COMPARE(cmap), NULL);

	for (ptr_node = CMAP_HEAD(cmap); ptr_node != cmap; ptr_node = ptr_node->ptr_next)
	{
		if (0 == CMAP_COMPARE(cmap)(ptr_key, ptr_node->ptr_data->first, keylen))
		{
			return ptr_node->ptr_data;
		}
	}	
	return NULL;
}

/** 
 * \brief 删除与ptr_key相同的数据指针
 * \param cmap		[in] 参数名称，CMAP对象
 * \param ptr_key	[in] 参数名称，KEY值 
 * \param keylen	[in] 参数名称，KEY值的长度
 * \return 
 *		cmap对象剩余的长度	\n
 */
PUBLIC int c_map_delete(CMAP cmap, PKEY_T ptr_key, int keylen)
{
	map_list_p ptr_node = NULL;
	ITERATOR_T iterator = {NULL, cmap};
	
	CHECK_PARAM_IS_NULL_RET(cmap, 0);		
	CHECK_PARAM_IS_NULL_RET(CMAP_COMPARE(cmap), 0);

	for (ptr_node = CMAP_HEAD(cmap); ptr_node != cmap; ptr_node = ptr_node->ptr_next)
	{
		if (0 == CMAP_COMPARE(cmap)(ptr_key, ptr_node->ptr_data->first, keylen)) {
			break;
		}
	}	
	iterator._value = ptr_node;
	c_map_erase(cmap, &iterator);
	
	return c_map_size(cmap);
}

/** 
 * \brief 遍历CMAP对象的数据
 * \param cmap		[in] 参数名称，CMAP对象
 * \param print_data   [in] 参数名称，数据对应的打印函数 
 * \return
 */
PUBLIC void c_map_traverse(CMAP cmap, c_print_data_t print_data)
{
	map_list_p ptr_node = NULL;

	if (NULL != cmap)
	{
		for (ptr_node = CMAP_HEAD(cmap); ptr_node != cmap; ptr_node = ptr_node->ptr_next)
		{
			if (print_data)
			{
				print_data(ptr_node->ptr_data);
			}
		}	
	}
}

 

Java集合类：Java集合类及其相关接口以及实现类的特性和用法——包括List接口和Set接口、Map接口以及他们的实现类、迭代器模式、容器线程安全问题等
AI天才研究院
08-04 802
Java集合类（Collection）是一种对多个数据进行集合处理的通用数据结构。在面向对象编程中，集合被用来存储、组织和管理元素。而Java集合类为我们提供了多种形式的集合，比如List、Set、Queue、Map等。Java集合类通过统一化的方式对数据进行管理，使得开发者可以更轻松地访问到需要的数据，并且可以使用各种集合进行灵活组合，以满足不同的应用场景需求。本文将详细介绍Java集合类及其相关接口以及实现类的特性和用法。阅读本文，你将学习到以下内容：1) Java集合类都有哪些？
c++ STL标准模板库-迭代器
u010196944的博客
10-22 773
c++ STL标准模板库-迭代器
Map集合
qq_66085475的博客
09-07 221
Map集合
C++ STL之list双向链表容器
优快云_HZW的博客
11-07 7212
不同于采用线性表顺序存储结构的vector和deque容器，list双向链表中任一位置的元素查找、插入和删除，都具有高效的常数阶算法时间复杂度O(1)。 list技术原理 为了支持前向和反向访问list容器的元素，list采用双向循环的链表结构组织数据元素，链表的每个节点包括指向前驱的指针、实际数据和指向后继的指针等数据域。 list的前向链，由头节点→第1个节点→第2个节点→…第n个节点→头...
双向链表 001
babyyang1213的专栏
06-20 576
<br />好久没有写东西了，最近准备整理整理思绪，写点东西。<br />这次说说双向链表吧。我这里会有一系列的双向链表问题，一步步完善现在开始001<br />双向链表分为两类 1.私有双向链表。(私有是指链表结点保存的数据结构是定好了的，如果需要修改，会稍微麻烦一点)<br />                          2.通用双向链表。(只管理结点节点的创建，对比，删除以及打印功能由调用者提供)<br /> <br />#ifndef __DLIST_H__<br />#define __D
双向链表与LinkedHashMap
bitcarmanlee的博客
09-15 971
1.双向链表比单向链表优势 对于插入操作，单链表与双链表都是O(1)时间复杂度。 对于删除操作，我们经常看到的说法是单链表的删除时间复杂度是O(1)，其实这种说法不准确。因为单从删除这个动作来说，确实是O(1)，只要把next指针的指向做改变即可。但是，在删除操作之前，我们需要找到前驱节点，这个操作就不是O(1)，而是O(n)。 具体来说，链表删除数据一般是两种情况： 1.删除节点中值等于某个特定值的节点。 2.删除给定指针指向的节点。 对于第一种情况，不管单链表双链表，都需要从头节点开始挨个遍历，找到值等
Map+双向链表实现LRU算法
皮斯特劳沃
06-03 973
map+双向链表实现，其中双向链表头结点的后继节点依次存储最近使用的缓存数据，尾节点的前驱节点为最久未被使用的数据；当通过key查询缓存在map中，则将对应节点移动至头结点的后面；key不在缓存中时，新建一个节点，并移动至头结点后面。 实现代码如下所示： import java.util.Map; import java.util.concurrent.ConcurrentHashMap; /** * Map+双向链表实现LRU * * @param <V> */ publ..
vector list map 遍历删除制定元素 防止迭代器失效的实例
08-31
在C++编程中，容器如`vector`, `list`, 和`map`是常用的数据结构，它们提供了方便的数据存储和操作。然而，在遍历这些容器并删除元素时，如果不小心，可能会导致迭代器失效，从而引发运行时错误。下面将详细解释如何...
Collection E、Map K,V接口底层实现类数据结构的区别和联系.pdf
08-07
LinkedList是一种基于双向链表实现的List，它不仅支持通过索引访问，还支持快速的插入和删除操作，尤其是在链表的头部和尾部。双向链表中的每个节点都存储了对前一个和后一个节点的引用，此外还有存储数据的元素。...
C++程序设计之STL模板（常用容器及迭代器）
qq_43328751的博客
09-22 550
参考：《ACM程序设计》——曾宗根 STL模板 1. vector向量容器 vector向量容器可以像数组一样对元素进行随机访问，还能在尾部插入元素，是一种简单高效的容器，用来代替数组 vector具有内存自动管理的功能，对于元素的插入和删除，可以动态调整所占的内存空间 vector容器有两个重要的方法，begin(),end() begin()返回的识首元素位置的迭代器，end()返回的是最后一个元素的下一个元素位置的迭代器。 创建vector对象 常用以下三种方式： (1)不指定容器的元素个...
主要集合概述Collection Map 单向链表 双向链表
一李
05-26 755
集合中只能存储引用类型，不能存储基本数据类型 Collection需要掌握的内容以及集合存储元素的特点 Map<Key,Value> 以键值对的形式存储元素，键特点是无序不可重复的 单向链表 单向链表中的每个元素在空间的存储位置上没有规律，顺序，那么在查找每个元素的时候必须从头节点挨着往后找 增删元素因为链表每个元素存储的空间是没有顺序的，删除或者添加某个...
LinkedHashMap 双向链表
朝闻道_的博客
02-27 945
http://www.importnew.com/18726.html
单项链表+双向链表+循环链表的+队列+栈的（c思想面向过程）实现
WSTONECH的博客
07-02 466
单项链表的实现+双向链表实现+循环链表实现+基于链表的栈的实现+基于链表的队列的实现
LinkedHashMap双向链表
u014203449的博客
05-04 3679
双链回环循环链表，名字相当唬人。首尾相接才算循环，但1.8这个没发现有首尾相接，LinkedList也没有LinkedHashMap,有两种排序，一种是顺序存储排序，像队列，先放入的元素在队头，后放入的元素在队尾，移除操作在队头进行。另一种是访问排序，被访问的元素放在队尾，没被访问的放队头，put get这些操作都算是访问1.顺序存储排序LinkedHashMap继承了HashMap，比其多了两个...
stl,vector, list，双向链表，map
L未若的博客
09-13 4300
下列关于ｓｔｌ的说法正确的是（） 　　Ａ，ｍａｐ的迭代器的ｋｅｙ是ｃｏｎｓｔ类型，无法对其进行修改 　　Ｂ，ｌｉｓｔ是双向链表实现，插入元素的复杂度是Ｏ（１） 　　Ｃ，ｖｅｃｔｏｒ的大小会增大或者减少，但容量只会增大而不会减少 　　Ｄ，ｓｔｌ的排序算法一般比较传统的快速排序块是因为其选取中值的算法好
windbg之使用!list指令遍历双向链表
Navagate的专栏
03-12 821
windows内核中大量的数据结构使用了双向链表。 如果能查看每个链表的元素，甚是美哉。 windbg就给我们提供了这么好用的功能。 !list命令是一个用来查看链表的命令，该功能非常强大并且易于使用。 下面我们就用例子来看一下!list命令的用法 使用!list遍历活动进程的进程Id和进程名 活动进程链表节点在EPROCESS中德偏移 +0x088 ActiveProcessL...
三电平SVPWM模型的Matlab仿真及其在逆变器性能优化中的应用
05-01
内容概要：本文详细介绍了三电平SVPWM模型在Matlab中的搭建与研究，重点探讨了三电平逆变器的工作原理、性能特点以及参数优化方法。文中不仅解释了三电平逆变器相较于传统两电平逆变器的优势，如更高的电压分辨率和更低的谐波失真，还深入讨论了SVPWM控制策略的具体实现步骤，包括扇区划分、中性点电压平衡、死区时间和波形生成等关键环节。此外，文章还强调了仿真与实际应用之间的差异，指出仿真只是调试的起点而非终点。 适合人群：从事电力电子、自动化控制领域的研究人员和技术人员，尤其是对逆变器建模和仿真相关工作的从业者。 使用场景及目标：适用于需要深入了解三电平逆变器特性和优化控制策略的研究项目，旨在帮助读者掌握基于Matlab的三电平SVPWM模型构建技巧，从而更好地进行逆变器性能评估和改进。 其他说明：文章提供了大量实用的Matlab代码片段，便于读者理解和实践。同时提醒读者关注仿真与现实应用间的细微差别，确保理论成果能够顺利转化为实际效益。
spring-boot-2.3.9.RELEASE.jar中文文档.zip
最新发布
05-01
# 压缩文件中包含： 中文文档 jar包下载地址 Maven依赖 Gradle依赖 源代码下载地址 # 本文件关键字： jar中文文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册 # 使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 # 特殊说明： ·本文档为人性化翻译，精心制作，请放心使用。 ·只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； ·不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 # 温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值