使用C语言封装链表函数

最新推荐文章于 2023-07-18 00:24:24 发布
最新推荐文章于 2023-07-18 00:24:24 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： Unix高级环境编程 C/C++ 文章标签： linux c链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzhenhe2008/article/details/73045002
版权

GITHUB项目

https://github.com/zhouzhenhecv/linux_c_list


list.h

#include <sys/time.h> 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#ifndef  LOG_TRACE
#define LOG_TRACE printf
#define LOG_INFO(msg)  \
	do{ \
		LOG_TRACE msg; \
		LOG_TRACE("[%s %d] \n",__FUNCTION__,__LINE__);\
	}while(0)

#define LOG_ERROR(err_info)  \
	do{ \
		LOG_TRACE("\033[1;40;31m ");\
		LOG_TRACE err_info; \
		LOG_TRACE("[%s %d] \033[0m \n",__FUNCTION__,__LINE__);\
	}while(0)
#endif


typedef struct  list_node_s
{	
	void *pData;
	int nDataLen;
	struct list_node_s *pNext; 
} list_node_t;

typedef struct list_s
{	
	list_node_t *pNodeHead;
	int nCountNum;
	int nMaxCountNum;
}list_t;

int  list_create( list_t *pList,int nMaxCount);

int  list_destroy( list_t *pList);

int list_get_data(list_t *pList,const void *pKeyData,void *pDesData,int nDataLen,int (*compare)(void *A,void *B));

int list_get_node_address(list_t *pList,list_node_t ** ppListNode,
								const void *pKeyData,int (*compare)(void *A,void *B));

int list_exist_node(list_t *pList,const void *pKeyData,int (*compare)(void *A,void *B));

int list_is_empty(list_t *pList);

int list_append( list_t *pList,void *pData,int nDataLen);

int list_delete_node(list_t *pList,const void *pKeyData,int (*compare)(void *A,void *B));

int list_delete_all(list_t *pList);




list.c

#include "list.h"
#include <sys/time.h> 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int  list_create( list_t *pList,int nMaxCount)
{
	if(NULL == pList ||
		nMaxCount <= 0)
	{
		LOG_ERROR(("param error"));
		return -1;
	}

	pList->nCountNum = 0;
	pList->pNodeHead = NULL; 
	pList->nMaxCountNum = nMaxCount;

	return 0;
}

int  list_destroy( list_t *pList)
{
	list_node_t *pListNode = NULL;
	list_node_t *pCurListNode = NULL;

	LOG_ERROR(("  come in "));
	
	if(NULL == pList)
	{
		LOG_ERROR(("param error"));
		return -1;
	}

	if(NULL == pList->pNodeHead)
	{
		pList->nCountNum = 0;
		return 0;
	}
	
	pListNode = pList->pNodeHead;

	// 1.Node by node release
	while(NULL != pListNode)
	{

		pCurListNode = pListNode;
		pListNode = pListNode->pNext ;
		if(NULL != pCurListNode->pData)
		{
			free(pCurListNode->pData); //free node data
		}

		free(pCurListNode);// free list node 
	}

	pList->pNodeHead = NULL;
	pList->nCountNum = 0;
	pList->nMaxCountNum = 0;
	return 0;

}

int list_get_data(list_t *pList,const void *pKeyData,void *pDesData,int nDataLen,int (*compare)(void *A,void *B))

{
	list_node_t *pListNode = NULL;
	list_node_t *pCurListNode = NULL;
	list_node_t *pListNodeTmp = NULL;

	if((NULL == pList) ||
		(NULL == pList->pNodeHead) ||
		(NULL == pDesData) || 
		(nDataLen <= 0 )||
		(NULL == pKeyData))
	{
		LOG_ERROR(("param error"));
		return -1;
	}
	
	pListNode = pList->pNodeHead;
	pCurListNode = pListNode;
	while(NULL != pListNode)
	{
		if(0 == compare(pKeyData,pListNode->pData))
		{
			break;
		}
		pListNode = pListNode->pNext;
		pCurListNode = pListNode;
	}

	if(NULL == pCurListNode)
	{
		LOG_ERROR(("not found"));
		return -1;
	}

	//find pCurList
	memset(pDesData, 0, nDataLen);
	memcpy(pDesData, pCurListNode->pData,nDataLen);
	
	return 0;
}


int list_get_node_address(list_t *pList,list_node_t ** ppListNode,const void *pKeyData,int (*compare)(void *A,void *B))

{
	list_node_t *pListNode = NULL;
	list_node_t *pCurListNode = NULL;
	list_node_t *pListNodeTmp = NULL;

	if((NULL == pList) ||
		(NULL == pList->pNodeHead) ||
		(NULL == ppListNode)||
		(NULL == pKeyData) )
	{
		LOG_ERROR(("param error"));
		return -1;
	}
	
	pListNode = pList->pNodeHead;
	pCurListNode = pListNode;
	while(NULL != pListNode)
	{
		if(0 == compare(pKeyData,pListNode->pData))
		{
			break;
		}
		pListNode = pListNode->pNext;
		pCurListNode = pListNode;
	}

	if(NULL == pCurListNode)
	{
		LOG_ERROR(("not found"));
		*ppListNode = NULL;
		return -1;
	}

	//find pCurList
	
	*ppListNode = pCurListNode;
	
	return 0;
}

int list_exist_node(list_t *pList,const void *pKeyData,int (*compare)(void *A,void *B))

{
	list_node_t *pListNode = NULL;
	list_node_t *pCurListNode = NULL;
	list_node_t *pListNodeTmp = NULL;

	if((NULL == pList) ||
		(NULL == pKeyData))
	{
		LOG_ERROR(("param error"));
		return -1;
	}

	if((NULL == pList->pNodeHead) && (pList->nCountNum == 0))
	{
		LOG_ERROR(("not found   in  list "));
		return -1;
	}
	
	pListNode = pList->pNodeHead;
	pCurListNode = pListNode;
	while(NULL != pListNode)
	{
		if(0 == compare(pKeyData,pListNode->pData))
		{
			break;
		}
		pListNode = pListNode->pNext;
		pCurListNode = pListNode;
	}

	if(NULL == pCurListNode)
	{
		LOG_ERROR(("not found   in  list "));
		return -1;
	}

	LOG_ERROR(("--------found   in  list "));
	
	return 0;
}

int list_is_empty(list_t *pList)
{
	
	if(NULL == pList)
	{
		LOG_ERROR(("param error"));
		return -1;
	}

	if((NULL == pList->pNodeHead)
		&& (0 == pList->nCountNum) )
	{
		return 1; // 1  is empty
	}
	
	return 0; //0  is  not empty
}

int list_append( list_t *pList,void *pData,int nDataLen)

{
	list_node_t *pListNode = NULL;
	list_node_t *pCurListNode = NULL;
	list_node_t *pListNodeTmp = NULL;

	if((NULL == pList) ||
		(NULL == pData) ||
		(nDataLen <= 0))
	{
		LOG_ERROR(("param error"));
		return -1;
	}

	if(pList->nCountNum >= pList->nMaxCountNum)
	{
		LOG_ERROR(("list is full ,error!"));
		return -1;
	}
	
	pListNode = pList->pNodeHead;
	
	pCurListNode = pListNode;
	if(NULL != pListNode) //无节点，则不进入循环
	{
		while(NULL != pListNode->pNext)
		{
			pListNode = pListNode->pNext;
			pCurListNode = pListNode;
		}
	}

	pListNodeTmp = (list_node_t * )malloc(sizeof(list_node_t));

	if(NULL == pListNodeTmp)
	{
		LOG_ERROR(("no enough memory!"));
		return -1;
	}
	pListNodeTmp->pData= NULL;
	pListNodeTmp->pNext = NULL;
	
	 pListNodeTmp->pData= (void *)malloc(nDataLen);
	if(NULL == pListNodeTmp->pData)
	{
		LOG_ERROR(("no enough memory!"));
		
		free(pListNodeTmp);
		return -1;
	}

	memset(pListNodeTmp->pData, 0,nDataLen);

	memcpy(pListNodeTmp->pData, pData,nDataLen);

	if(NULL != pCurListNode)
	{
		pCurListNode->pNext = pListNodeTmp; //add list node  当前链表大于1个节点 
	}
	else
	{//add list node
		
		pCurListNode = pListNodeTmp;//0个节点的时候
		pList->pNodeHead = pListNodeTmp;;
	}
	pList->nCountNum++;

	return 0;
}

int list_delete_node(list_t *pList,const void *pKeyData,int (*compare)(void *A,void *B))

{
	list_node_t *pListNode = NULL;
	list_node_t *pCurListNode = NULL;
	list_node_t *pPreListNode = NULL;
	list_node_t *pListNodeTmp = NULL;

	if((NULL == pList) ||
		(NULL == pList->pNodeHead) ||
		(NULL == pKeyData))
	{
		LOG_ERROR(("param error"));
		return -1;
	}
	
	pListNode = pList->pNodeHead;
	pCurListNode = pListNode;
	pPreListNode = pListNode;
	while(NULL != pListNode)
	{
		if(0 == compare(pKeyData,pListNode->pData))
		{
			break;
		}
		pPreListNode = pListNode;
		pListNode = pListNode->pNext;
		pCurListNode = pListNode;
	}

	if(NULL == pCurListNode)
	{
		LOG_ERROR(("not found"));
		return -1;
	}
	else
	{
		//(free)
		if(pListNode == pPreListNode) //第一个节点
		{
			pList->pNodeHead = pPreListNode->pNext;
			if(NULL != pPreListNode->pData)
			{
				free(pPreListNode->pData);
			}

			free(pPreListNode);
		}
		else
		{
			pPreListNode->pNext = pCurListNode->pNext;
			if(NULL != pCurListNode->pData)
			{
				free(pCurListNode->pData);
			}

			free(pCurListNode);
		}
		
	}

	pList->nCountNum--;
	if(pList->nCountNum < 0)
	{
		LOG_ERROR((" pList->nCountNum  error"));
		return -1;
	}
	return 0;
}

int list_delete_all(list_t *pList)

{
	list_node_t *pListNode = NULL;
	list_node_t *pCurListNode = NULL;
	
	if((NULL == pList) ||
		((NULL != pList) && (NULL == pList->pNodeHead)))
	{
		LOG_ERROR(("param error"));
		return -1;
	}

	pListNode = pList->pNodeHead;
	pCurListNode = pListNode;	
	while(NULL != pListNode)
	{
		pListNode = pListNode->pNext;
		if(NULL != pCurListNode->pData)
		{
			free(pCurListNode->pData);
		}

		free(pCurListNode);
		pCurListNode = pListNode;
		
	}
	pList->pNodeHead = NULL;
	pList->nCountNum = 0;
	
	return 0;
}

int list_dump(list_t *pList,int (*print_list_dump)(void *))
{
	list_node_t *pListNode = NULL;
	int i = 0;
	if((NULL == pList) ||
		((NULL != pList) && (NULL == pList->pNodeHead)))
	{
		LOG_ERROR(("param error"));
		return -1;
	}

	pListNode = pList->pNodeHead;
	while(NULL != pListNode)
	{
		LOG_ERROR(("list node %d",i));
		i++;
		print_list_dump(pListNode->pData);
		pListNode = pListNode->pNext;
	}

	return 0;
}


test.c

#include "list.h"

const char chData[10][100]={"123","124","125","126","666",
                            "234","345","456","567","678"};

int compare(void *A,void *B)
{
	return strcmp((char *)A,(char*)B);
}

int print_list_dump(void *arg)
{
	printf("\n [%s]\n",(char *)arg);
	return 0;
}
int example()
{
	static list_t s_List;
	int MaxCountListNode = 30;
	int ret = -1;
	int i = 0;
	char chTmp[255]={0};

	//list_create(list_t * pList,int nMaxCount)
	ret = list_create(&s_List,MaxCountListNode);
	if(0 != ret)
	{
		LOG_ERROR(("list_create error"));
		return -1;
	}

	LOG_ERROR(("list_create success"));

	ret = list_is_empty(&s_List);
	LOG_ERROR(("list_is_empty  ret[%d]",ret));
	
	for(i = 0; i< 10; i++)
	{
		//list_append(list_t * pList,void * pData,int nDataLen)
		ret = list_append(&s_List,chData[i],sizeof(chData[i]));
		if(0 != ret)
		{
			LOG_ERROR(("list_append error"));
			list_destroy(&s_List);
			return -1;
		}

		LOG_ERROR(("list_append  [%s] success",chData[i]));
		
	}

	//int list_get_data(list_t *pList,const void *pKeyData,void *pDesData,int nDataLen,int (*compare)(void *A,void *B))
	ret = list_get_data(&s_List,"666",chTmp,sizeof(chData[0]),compare);

	if(0 == ret )
	{
		LOG_ERROR(("list_get_data  chTmp [%s]",chTmp));
	}
	else
	{	
		LOG_ERROR(("list_get_data  failed"));
	}

	{
		list_node_t * pListNode = NULL;
		//list_get_node_address(list_t *pList,list_node_t ** ppListNode,const void *pKeyData,int (*compare)(void *A,void *B))

		ret = list_get_node_address(&s_List,&pListNode,"456",compare);

		if(0 == ret)
		{
			LOG_ERROR(("list_get_node_address  pListNode->pData [%s]",(char *)(pListNode->pData)));

			strncpy(pListNode->pData,"111",sizeof("111"));
		}
		else
		{
			LOG_ERROR(("list_get_node_address  failed"));
		}
		
	}

	ret = list_exist_node(&s_List,"111",compare);
	if(0 == ret)
	{
		LOG_ERROR(("list_exist_node  ret[%d]",ret));
	}

    // int list_is_empty(list_t *pList)

	ret = list_is_empty(&s_List);
	LOG_ERROR(("list_is_empty  ret[%d]",ret));
	
	list_dump(&s_List,print_list_dump);

	#if 1
	{
		//int list_delete_node(list_t *pList,const void *pKeyData,int (*compare)(void *A,void *B))
		list_delete_node(&s_List,"21xd",compare);

		list_dump(&s_List,print_list_dump);
	}
	#endif

	#if 1
	{
		 list_delete_all(&s_List);
		 list_dump(&s_List,print_list_dump);
	}
	#endif

	ret = list_destroy(&s_List);

	if(0 != ret)
	{
		LOG_ERROR(("list_destroy error"));
		return -1;
	}
	
	return 0;
}

int main()
{
	example();
	return 0;
}







zhouzhenhe2008
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用c语言写链表
Mr_fanna的博客
02-08 2869
数据结构——链表的学习（链表的构建、初始化、插入和删除等基本操作）
C语言之链表HuffmanTree
03-27
C语言中的链表通常通过指针来实现，通过定义结构体来封装数据和指针。 接下来，我们讨论哈夫曼树（Huffman Tree），这是一种特殊的二叉树，用于哈夫曼编码，这是一种无损数据压缩算法。在哈夫曼树中，频率较高的...
C语言链表超详解
热门推荐
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
魔王语言C语言 使用头文件封装 链表链栈顺序队列的基本操作
my_269的博客
11-30 1472
魔王语言，C语言，使用了链栈和顺序队列，其中链栈是通过链表的基本操作改装的，旨在实现封装性，可自定义规则，可括号嵌套
C语言封装多个函数的方法,用C语言封装的链表的方法
weixin_42138376的博客
05-21 284
#include #include #define TRUE 1#define ERROR 0#define BOOL inttypedef struct LNode...{int data;LNode *next;}LNode,*Linklist;BOOL HeadNOde(Linklist* Head,Li...
C语言链表详解
qq_28576837的博客
06-02 4854
C语言链表详解
C语言静态链表
m0_62127837的博客
09-07 515
C语言静态链表
C语言 链表创建及操作
weixin_44272350的博客
09-10 3110
C语言 链表创建及操作 第一部分构建链表，定义结构体，分别用头插法、尾插法实现，这里封装了打印函数：printf();做练习方便后续使用，具体代码如下： struct node //定义结构体 { int data; struct node *next; }; void print_data(struct node *inc) //封装函数做打印用 { printf("data = %d\n",inc->data); } void traverse(struct node *inc
链表C语言实现--单向链表
qq_48639334的博客
08-01 3455
链表C语言实现--单向链表
C语言——链表（带头节点与不带头节点）
m0_73771309的博客
07-18 1266
链表是一种常见的线性数据结构，它由一系列的节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点可以在内存中不连续地分布，通过指针将它们串联在一起。下面呢，进入正题！！！首先呢，我们先看这张图！这是带头节点，带头节点的链表是在链表头部添加了一个额外的节点，该节点不存储任何数据，只是作为链表的起始位置。带头节点的链表中，头节点的下一个节点才是实际存储数据的第一个节点。
C语言链表的简单的尾插法
LICHARD的小空间
11-28 7372
C语言链表的简单的尾插法 今天简单的总结一下关于C语言的尾插法，简单来说就是在一堆的简单的数据节点当中，在一个指定的位置后方插入你想要插入的数据！开整！（自己学习也不是很好哈!，请见谅） 第一步：创建一个链表 struct test { int data; struct test *next; }; 第二步：封装打印函数（其实也有其他的打印输出的方式，比如之前讲的printf方法，感兴趣可以参考我之前发的，这里只是为了简单的写法哈！） 参考链接：（只是参考哈！） C语言链表简单的结
C语言实现双向链表
09-03
在C语言中，双向链表是一种非常重要的数据结构，它具有前向和后向两个指针，可以方便地...此外，为了保证代码的健壮性和可维护性，通常会采用面向对象的设计方式，将链表操作封装到一个类中，而不是分散在各个函数中。
C语言实现的双链表功能完整示例
08-27
在C语言中，双链表的定义主要包括链表的结构体定义和链表操作函数的实现。链表的结构体定义主要包括双链表的结点结构体和链表结构体。结点结构体包括数据元素和两个指针，分别表示当前结点的数据元素和前驱结点、...
c语言实现实现函数指针
最新发布
01-05
这种特性使得C语言具有很高的灵活性，特别是在编写回调函数、动态调度代码或者实现数据结构（如链表、树等）的算法时。下面将详细阐述函数指针的定义、声明、使用以及其在实际编程中的应用。 首先，我们需要理解...
链表交换_C语言链表交换算法_
10-01
这个过程可以封装成一个`swapSubList()`函数： ```c void swapSubList(ListNode** head, int p, int q) { ListNode* prevP = NULL; ListNode* nodeP = *head; for (int i = 0; i != NULL; i++) { prevP = nodeP...
linux开机启动自动执行某个脚本
烟花易冷
08-19 2万+
有时候我们需要在开机的拉起一个服务或进程。 比较方便的改法是在文件/etc/rc.local，编辑这个文件，在末尾添加 source 脚本名称.sh 脚本run_httpd_server.sh的内容 #!/bin/bash export BASE_DIR=$(pwd) echo ${BASE_DIR} cd /share/http/apache2.2.32-install/
利用/proc/mounts检查已经被系统挂载的设备
烟花易冷
06-08 2万+
1 介绍/proc/mounts 如何利用/proc/mounts知道已经挂载上的设备呢，我们先来看看/proc/mounts都有啥东西 解释一下，第一列是设备路径，比如说/dev/sda1  第二列是挂载点（即设备挂载到的目录）  第三列是以什么文件系统挂载 2 编代码读取前3列 #include #include #include int re
文件夹已经存在的情况下调用mkdir函数
烟花易冷
04-24 1万+
#include #include #include #include #include #include #include int main() { char dirname[]="abc123"; int ret1 = -1; int ret2 = -1; ret1 = mkdir(dirname,0777); sleep(5)
Linux stat函数获取文件属性（文件大小，创建时间等，判断普通文件或者目录等）
烟花易冷
01-01 1万+
struct stat64 s; memset(&s, 0, sizeof(struct stat64)); nRet = stat64(pchFilename, &s); if (nRet) { SK_ERROR(("stat %s failed! error_code: %s", pchFilename, strerror(errno))); return SK_FAILE
用c语言封装链表的动态创建，删除，修改的函数
03-12
可以回答这个问题。以下是用 C 语言封装链表的动态创建、删除和修改的函数： 1. 动态创建链表： ```c typedef struct node { int data; struct node *next; } Node; Node *createList() { Node *head = (Node *)malloc(sizeof(Node)); head->next = NULL; return head; } ``` 2. 动态删除链表： ```c void deleteList(Node *head) { Node *p = head; while (p != NULL) { Node *temp = p; p = p->next; free(temp); } } ``` 3. 修改链表中某个节点的值： ```c void modifyNode(Node *head, int index, int value) { Node *p = head->next; int i = 0; while (p != NULL && i < index) { p = p->next; i++; } if (p != NULL) { p->data = value; } } ``` 以上是用 C 语言封装链表的动态创建、删除和修改的函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值