数据结构，C语言单向链表、双向链表的学习记录（增、删、查）

已于 2024-02-28 16:33:24 修改
阅读量59 收藏
点赞数
文章标签： 数据结构 c语言 链表
于 2023-06-29 14:05:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51076606/article/details/131454847
版权

声明：本文参考自今日头条用户：记录我的编程生活

原文链接：合集|C语言-数据结构与算法 - 今日头条 (toutiao.com)

 

正文：主要是记录个人学习情况，非教程，因本人也没学明白，不想误导人，代码仅供参考！废话不多说，不讲原理，自己看书，我直接上代码（欢迎批评指正）

附上gitee仓库链接：https://gitee.com/moweida/gitee_linux.git

mylist.c：

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

#include "mylist.h"



//初始化单向链表
int slist_init(single_list *list)
{
	if ( NULL == list ) //判断传入的参数是否为空
	{
		printf("Illegal pointer parameter!\n");
		return -1;
	}

	list->head = list->tail = NULL;
	printf("single_list initialized successfully\n");
	return 1;
}

//初始化双向链表
int dlist_init(double_list *list)
{
	if ( NULL == list ) //判断传入的参数是否为空
	{
		printf("Illegal pointer parameter!\n");
		return -1;
	}

	list->head = list->tail = NULL;
	printf("double_list initialized successfully\n");
	return 1;
}

//单向链表头插法
int slist_head_add(single_list *list, void *data)
{
	single_list_node	*newnode = (single_list_node*)malloc(sizeof(single_list_node));
	newnode->data = data;
	newnode->next = NULL;

	if ( NULL == list ) //判断传入的参数是否为空
	{
		printf("Illegal pointer parameter!\n");
		return -1;
	}

	if ( NULL == list->head )
	{
		list->head = list->tail = newnode;
		newnode->next = NULL;
	}
	else
	{
		newnode->next = list->head; //新节点的后继指针指向头指针指向的旧（原头结点）结点
		list->head = newnode; //头指针指向新结点，成为新的头结点
	}

	printf("Add new node to the list head successfully\n");

	return 1;
}


//单向链表尾插法
int slist_tail_add(single_list *list, void *data)
{
	single_list_node	*newnode = (single_list_node*)malloc(sizeof(single_list_node)); //创建一个结点并分配内存
	newnode->data = data; //结点数据
	newnode->next = NULL; //结点后继指针

	if ( NULL == list ) //判断传入的参数是否为空
	{
		printf("Illegal pointer parameter!\n");
		return -1;
	}

	if ( NULL == list->tail ) //如果尾指针为空，代表链表没有任何结点
	{
		list-> head = list->tail = newnode; //将头指针、尾指针都指向新结点
	}
	else
	{
		list->tail->next = newnode; //否则将新结点插入链尾
		list->tail = newnode; //将尾指针指向新的链尾结点
	}

	printf("Add new node to the list tail successfully\n");

	return 1;
}


//单向链表头删法
int slist_del_head(single_list *list)
{
	if ( (NULL == list) || (NULL == list->head) ) //判断传入的参数以及链表是否为空
	{
		printf("Illegal pointer parameter!\n");
		return -1;
	}

	single_list_node *next = list->head->next; //创建一个新结点指向头结点的后继结点

	free(list->head); //释放旧的头结点
	list->head = next; //后继结点成为新的头结点
	
	printf("Delete the head node successfully\n");

	return 1;
}


//单向链表尾删法
int slist_del_tail(single_list *list)
{
	if ( (NULL == list) || (NULL == list->head) ) //判断传入的参数以及链表是否为空
	{
		printf("Illegal pointer parameter!\n");
		return -1;
	}

	single_list_node *cru = list->head; //创建一个当前结点指针，指向头结点
	single_list_node *pre = cru; //创建一个前驱结点指针，指向头结点

	while ( NULL != cru->next ) //遍历链表，寻找尾结点（后继指针为空的结点）
	{
		pre = cru; //前驱结点指针指向当前结点
		cru = cru->next; //当前结点指针指向下一结点，循环移动，直到指向尾结点
	}

	free(cru); //释放尾结点
	pre->next = NULL; //尾结点的后继指针为空
	list->tail = pre; //尾指针指向新的尾结点

	printf("Delete the tail node successfully\n");

	return 1;
}


//双向链表头插法
int dlist_head_add(double_list *list, void *data)
{
	double_list_node *newnode = (double_list_node*)malloc(sizeof(double_list_node));
	newnode->data = data;
	newnode->next = NULL;

	if ( NULL == list ) //判断传入的参数是否为空
	{
		printf("Illegal pointer parameter!\n");
		return -1;
	}

	if ( NULL == list->head )
	{
		list->head = list->tail = newnode;
		newnode->next = NULL;
	}
	else
	{
		newnode->next = list->head; //新节点的后继指针指向头指针指向的旧（原头结点）结点
		list->head->prev = newnode; //头指针的前驱指针指向新结点
		list->head = newnode; //头指针指向新结点，新结点成为头结点
		newnode->prev = NULL; //头结点的前驱为NULL
	}

	printf("Add new node to the double list head successfully\n");

	return 1;
}


//双向链表尾插法
int dlist_tail_add(double_list *list, void *data)
{
	double_list_node *newnode = (double_list_node*)malloc(sizeof(double_list_node)); //创建一个结点并分配内存
	newnode->data = data; //结点数据
	newnode->next = NULL; //结点后继指针

	if ( NULL == list ) //判断传入的参数是否为空
	{
		printf("Illegal pointer parameter!\n");
		return -1;
	}

	if ( NULL == list->tail ) //如果尾指针为空，代表链表没有任何结点
	{
		list-> head = list->tail = newnode; //将头指针、尾指针都指向新结点
		newnode->prev = newnode->next = NULL;
	}
	else
	{
		newnode->prev = list->tail; //将新结点的前驱指针指向尾结点
		list->tail->next = newnode; //否则将新结点插入链尾
		list->tail = newnode; //将尾指针指向新的链尾结点
		newnode->next = NULL; //尾结点的后继指针为NULL
	}

	printf("Add new node to the double list tail successfully\n");

	return 1;
}


//双向链表头删法
int dlist_del_head(double_list *list)
{
	if ( (NULL == list) || (NULL == list->head) ) //判断传入的参数以及链表是否为空
	{
		printf("Illegal pointer parameter!\n");
		return -1;
	}

	double_list_node *next = list->head->next; //创建一个新结点，指向头结点的后继结点

	free(list->head); //释放旧的头结点

	if ( NULL == next )
	{
		list->head = list->tail = NULL; //链表为空
	}
	else
	{
		next->prev = NULL; 
		list->head = next; //next成为新的头结点
	}

	printf("delete the head node successfully\n");

	return 1;
}


//双向链表尾删法
int dlist_del_tail(double_list *list)
{
	if ( (NULL == list) || (NULL == list->head) ) //判断传入的参数以及链表是否为空
	{
		printf("Illegal pointer parameter!\n");
		return -1;
	}

	double_list_node *prev = list->tail->prev; //创建一个当前结点指针，指向尾结点的前驱结点
	free(list->tail); //释放尾结点

	if ( NULL == prev ) //如果删除了尾结点后为空
	{
		list->head = list->tail = NULL; //链表为空
	}
	else
	{
		prev->next = NULL; //尾结点的后继为NULL
		list->tail = prev; //尾指针指向前驱结点，成为新的尾结点
	}
	printf("delete the tail node successfully\n");

	return 1;
}



//按索引查找
int slist_index_search(single_list *list, int index, void *get_data)
{
	if ( (NULL == list) || (NULL == list->head) ) //判断传入的参数以及链表是否为空
	{
		printf("Illegal pointer parameter!\n");
		return -1;
	}

	int i = 1;
	single_list_node *p = list->head; //创建一个结点指针用来遍历链表
	while ( (NULL != p) && (i < index) ) //遍历链表
	{
		p = p->next;
		i++;
	}
	if ( (NULL == p) || (i > index) ) //如果遍历完整个链表或者越界
	{
		printf("Search node of index[%d] failure\n");
		return -1;
	}

	get_data = p->data; //找到指定序号的结点，并取出其中的数据
	printf("Search node of index[%d] successfully:\n%s\n", index, get_data);
	 
	return 1;
}


//按值查找
int slist_value_search(single_list *list, void *value, void *get_data)
{
	if ( (NULL == list) || (NULL == list->head) ) //判断传入的参数以及链表是否为空
	{
		printf("Illegal pointer parameter!\n");
		return -1;
	}

	single_list_node *p = list->head; //创建一个结点指针用来遍历链表
	while ( (NULL != p) && (p->data != value) ) //遍历链表
	{
		p = p->next;
	}
	if ( (NULL == p) && (p->data != value) ) //如果遍历完整个链表都没有匹配给定数据的结点
	{
		printf("Search node of value(%s) failure\n", value);
		return -1;
	}
	get_data = p->data; //找到指定数据的结点，并取出其数据

	printf("Search node of value(%s) successfully\n", value);
	 
	return 1;
}


//按索引查找
int dlist_index_search(double_list *list, int index, void *get_data)
{
	if ( (NULL == list) || (NULL == list->head) ) //判断传入的参数以及链表是否为空
	{
		printf("Illegal pointer parameter!\n");
		return -1;
	}

	int i = 1;
	double_list_node *p = list->head; //创建一个结点指针用来遍历链表
	while ( (NULL != p) && (i < index) ) //遍历链表
	{
		p = p->next;
		i++;
	}
	if ( (NULL == p) || (i > index) ) //如果遍历完整个链表或者越界
	{
		printf("Search node of index[%d] failure\n");
		return -1;
	}

	get_data = p->data; //找到指定序号的结点，并取出其中的数据
	printf("Search node of index[%d] successfully:\n%s\n", index, get_data);
	 
	return 1;
}


//按值查找
int dlist_value_search(double_list *list, void *value, void *get_data)
{
	if ( (NULL == list) || (NULL == list->head) ) //判断传入的参数以及链表是否为空
	{
		printf("Illegal pointer parameter!\n");
		return -1;
	}

	double_list_node *p = list->head; //创建一个结点指针用来遍历链表
	while ( (NULL != p) && (p->data != value) ) //遍历链表
	{
		p = p->next;
	}
	if ( (NULL == p) && (p->data != value) ) //如果遍历完整个链表都没有匹配给定数据的结点
	{
		printf("Search node of value(%s) failure\n", value);
		return -1;
	}
	get_data = p->data; //找到指定数据的结点，并取出其数据

	printf("Search node of value(%s) successfully\n", value);
	 
	return 1;
}

mylist.h：

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


//单向链表结点结构体
typedef struct single_list_node
{
	void 			        *data; //数据域
	struct single_list_node	*next; //后继指针域
}single_list_node;

//双向链表结点结构体
typedef struct double_list_node
{
	void            	    *data; //数据域
	struct double_list_node *prev; //后继指针域
	struct double_list_node *next; //后继指针域
}double_list_node;

//单链表结构体
typedef struct single_list
{
	single_list_node	*head; //头指针
	single_list_node	*tail; //尾指针
}single_list;

//双表结构体
typedef struct double_list
{
	double_list_node	*head; //头指针
	double_list_node	*tail; //尾指针
}double_list;

//初始化链表
int slist_init(single_list *list);
int dlist_init(double_list *list);

//单向链表头插法
int slist_head_add(single_list *list, void *data);
//双向链表头插法
int dlist_head_add(double_list *list, void *data);

//单向链表尾插法
int slist_tail_add(single_list *list, void *data);
//双向链表尾插法
int dlist_tail_add(double_list *list, void *data);
//单向链表头删法
int slist_del_head(single_list *list);
//双向链表头删法
int dlist_del_head(double_list *list);

//单向链表尾删法
int slist_del_tail(single_list *list);
//双向链表尾删法
int dlist_del_tail(double_list *list);

//按序号查找
int slist_index_search(single_list *list, int index, void *get_data);
//按值查找
int slist_value_search(single_list *list, void *value, void *get_data);

//按序号查找
int dlist_index_search(double_list *list, int index, void *get_data);
//按值查找
int dlist_value_search(double_list *list, void *value, void *get_data);

main.c（个人测试用）

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

#include "mylist.h"

int main(int argc, char **argv)
{
	single_list 	*list1 = (single_list*)malloc(sizeof(single_list));
	double_list 	*list2 = (double_list*)malloc(sizeof(double_list));
	void	*get_data11;
	void	*get_data12;
	void	*get_data21;
	void	*get_data22;

	slist_init(list1); //初始化单向链表
	slist_head_add(list1, "single head"); //单向链表头插法
	slist_tail_add(list1, "single tail"); //单向链表尾插法
	slist_index_search(list1, 1, get_data11); //单向链表按索引查找
	slist_value_search(list1, "single head", get_data12); //单向链表按值查找
	slist_del_head(list1); //单向链表删除头结点
	slist_del_tail(list1); //单向链表删除尾结点

	dlist_init(list2); //初始化双向链表
	dlist_head_add(list2, "double head"); //双向链表头插法
	dlist_tail_add(list2, "double tail"); //双向链表尾插法
	dlist_index_search(list2, 1, get_data21); //双向链表按索引查找
	dlist_value_search(list2, "double head", get_data22); //双向链表按值查找
	dlist_del_head(list2); //双向链表删除头结点
	dlist_del_tail(list2); //双向链表删除尾结点

	return 1;
}

运行结果：（基于Linux ubuntu）

IorT
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C语言实现单向链表及操作
03-24
数据结构，c语言实现的单向链表。代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode;
C语言自学链表，单向链表，双向链表，适合新手学习。
06-18
源码包含单向链表和双向链表，注释比较详细，简单明白，适合新手初学者下载使用，比较基础。觉得有用记得收藏哦！
C语言链表超详解
热门推荐
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
【数据结构-C语言】单向链表，循环单向链表
sakura0908的博客
03-02 2294
顺序表：顺序存储的线性表 链式表：链式存储的线性表，简称链表 由于顺序表的缺点（数据连续存储），顺序存储的数据因为挤在一起而导致需要成片移动，那很容易想到的解决方案是将数据离散地存储在不同内存块中，然后再用指针将他们串起来，这种朴素的思路所形成的链式线性表，就是所谓的链表。顺序表和链表存在的基本样态如下图所示
数据结构——单向链表（C语言实现）
2402_82711634的博客
01-18 1627
无头链表：以结点为开头的链式结构——————同时也是非循环链表typedef struct SListNode//定义的是结点的结构//存放数据//存放下一个位置的地址}SLTNode;//pos就是节点的指针。
【数据结构】带头双向循环链表的增删查改（C语言实现）
在平淡的日子里寻找存在的价值
08-08 1366
带头双向循环链表的实现以及链表、顺序表优缺点的总结。
双向链表--C语言实现数据结构
2201_76062618的博客
05-13 4871
本文详细介绍带头双向循环链表，内容较为丰富
c语言实现数据结构中的单向链表
qq_68695298的博客
09-03 1012
简单易懂教你用c语言实现链表。
数据结构C语言版 —— 链表增删改查实现(单链表+循环双向链表)
爱敲代码的三毛的博客
12-15 726
链表是用一组任意的额存储单元存储线性表的数据元素(这组存储单元可以是连续的，也可以是不连续的)。简单来说链表是一种**物理结构上非连续**，非顺序的存储结构，数据元素的**逻辑顺序**是通过链表中的**指针链接**次序实现的。
C语言数据结构之双向链表
Qurry的博客
09-21 1254
前面介绍了单链表，由于单链表遍历查找是单向性的，故引出了双向链表的概念，也叫双链表，既可以向前查找，也可以向后遍历。
C语言之链表：单向链表，循环链表，双向链表
哒宰的博客
11-22 2163
C语言之链表：单向链表，循环链表，双向链表 提起链式存储结构，其与数组是两个非常基础的数据结构，每当提到链式存储结构时，一般情况下我们都会将其与数组放到一块儿来比较。 对于数组与链表，从结构上来看，数组是需要一块连续的内存空间来存储数据，对内存 的要求非常高，比如说我们申请一个100M大小的数组，而如果我们的内存可用空间大于100M，但是没有连续的100M可用空间，那即便是我们的内存空间充足，在申请空间时也会申请失败 而对于链表来说，他对内存空间的要求就不会有那么高，它并不需要一块连续的内存空间，只要内存空
C语言数据结构——链表
wxk2227814847的博客
01-28 1618
在计算机科学中，数据结构是存储和组织数据的一种方式，它不仅影响数据的存储，也影响数据的检索和更新效率。C语言，作为一种经典的编程语言，提供了灵活的方式来处理数据结构，其中链表是最基本且重要的一种。
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
C语言实例-双向链表增删改查
09-11
双向链表（Doubly Linked List）是一种常见的数据结构，在单链表的基础上增加了向前遍历的功能。与单向链表不同，双向链表的每个节点除了包含指向下一个节点的指针外，还包含指向前一个节点的指针。
C语言数据结构旋转链表的实现
12-31
C语言数据结构旋转链表的实现 实例： 给出链表1->2->3->4->5->null和k=2 返回4->5->1->2->3->null 分析： 感觉很直观，直接把分割点找出来就行，记得k可能大于len,要取模 代码： /** * Definition for singly-...
数据结构进阶——并查集
weixin_73870552的博客
06-10 988
数据结构进阶——并查集。
【Chrome插件】如何在Chrome插件开发中处理复杂数据结构的存储
Yong.Sunshine
06-12 322
最近俺在接触 Chrome 插件开发，需要把一个数据存放到浏览器的存储中。这个数据结构有点复杂，它包含一个 Map 和一个数组。我使用 chrome.storage.local API来存储这个数据，然后在另一个地方获取数据。保存数据的代码并没有报错，但是俺发现获取的时候获取结果的内容为空，这是为什么呢？
java算法：冒泡排序
最新发布
weixin_45832694的博客
06-13 577
然而，尽管这些优化方法可以减少比较和交换的次数，冒泡排序的时间复杂度仍然是O(n^2)，因此对于大规模数据集来说，并不是最优的排序算法选择。传统的冒泡排序是从左到右逐个比较并交换相邻元素的位置，而鸡尾酒排序是交替进行从左到右和从右到左的遍历，将较大的元素从末端冒泡到首端，再将较小的元素从首端冒泡到末端。在每一趟遍历中，通过记录最后一次交换的位置，将该位置作为下一趟遍历的边界。为了优化冒泡排序，可以引入一个标志变量来记录是否发生了交换操作，如果某一趟遍历中没有发生交换，就说明数组已经有序，可以提前结束排序。
数据结构-二叉树
passworddddddd的博客
06-12 296
树（Tree）是一种非常重要的数据结构，它模拟了一种层级或者分支结构。在树结构中，数据以节点（Node）的形式存储，并且每个节点都可以有零个或多个子节点。除了二叉树最后一层，其他各层的节点数都达到最大个数，且最后一层从左向右的叶节点连续存在，只缺右侧若干节点。完美二叉树是特殊的完全二叉树。除了最下一层的叶子节点外，每层节点都有两个子节点，就构成了满二叉树。如果树中每个节点最多只能有两个子节点，这样的树就称之为二叉树。
C语言数据结构双向循环链表
09-27
双向循环链表是一种常用的链表结构，它与单向链表相比具有更好的灵活性和操作效率。在C语言中，实现双向循环链表需要定义一个链表节点结构体，其中包含指向前驱节点和后继节点的指针，以及存储数据的成员。以下是一个示例的C语言代码来初始化一个双向循环链表： ``` typedef int LTDataType; typedef struct ListNode { struct ListNode* next; struct ListNode* prev; LTDataType data; } LTNode; void InitDList(LTNode** pHead) { *pHead = (LTNode*)malloc(sizeof(LTNode)); (*pHead)->next = *pHead; (*pHead)->prev = *pHead; } ``` 在上述代码中，`InitDList`函数用于初始化一个双向循环链表，它使用一个头节点指针作为参数，通过动态内存分配来创建一个头节点，并将头节点的`next`和`prev`指针均指向自身，从而形成一个空的循环链表。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值