数据结构：单链表的相关操作

最新推荐文章于 2024-07-24 22:34:26 发布
最新推荐文章于 2024-07-24 22:34:26 发布
阅读量377 收藏 3
点赞数 8
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a287100886/article/details/138707004
版权

声明：

本文章对链表的相关操作均采用C语言实现，涉及的操作有：单链表的创建、添加新节点、删除节点、查找节点、对链表进行排序、打印链表信息等。

单链表的基本结构：

单链表的基本结构为下图所示：

链表的创建：

这里需要说明的是：我们经常提及的将某个指针指向某个节点的含义，其实就是将该节点的地址赋值给这个指针变量，这样我们就能通过这个指针变量来获取对应节点的相关信息或者对这个节点进行操作了。

所以，在创建新节点时往往需要使用malloc的方法开辟一块内存存储新节点；

但是使用某个指针变量指向该节点时不需要在开辟内存空间。

代码示例：

注意：在代码例，head是一个节点，但end是一个指针变量，不要搞混了。

Node* createNode(int num)//创建节点函数，参数是节点的数量，注意头结点是不算在节点数量里的
{
	Node* head;
	Node* end;

	head = (Node*)malloc(sizeof(Node));
	end = head;  //这里end只是一个指针变量，其存储的是head的地址，所以不需要对end进行内存的分配，换句话说，其实这里的end不是一个节点
	//还是有一点迷惑性的，这里创建end变量，只是为了后续循环好不断添加节点
	if (head == NULL)
	{
		printf("头节点内存分配失败！");
		return NULL;//表示分配内存失败了
	}
	for (int i = 0; i < num; i++)
	{
		Node* newnode = (Node*)malloc(sizeof(Node));
		if (newnode == NULL)
		{
			printf("节点内存分配失败！");
			return NULL;//表示分配内存失败了
		}
		printf("请输入该节点的数值：");
		scanf_s("%d", &newnode->data); //这里还得用scanf_s,scanf还不行，会警告，可能是编译器版本的题
		end->next = newnode;
		end = newnode;
	}

	//循环添加完成链表的创建后，要将最后一个节点的Node.next == NULL，用于链表结束的判别
	end->next = NULL;
	return head;
	//到这里，讲一下这个函数的类型Node* createNode(int num)，结构体指针类型的函数，这个函数会返回值是一个结构体的地址（在链表中就是头结点的地址），
	//这样，我们就能通过头结点不断地遍历链表中的每一个节点的。
	//某种意义上，这么做能达到创建一个函数，（类似python中直接返回一个数组的功能）
}

向链表中添加节点：

这里采用的方法是头插法，非常好理解。

代码示例：

void addNode_From_Head(Node* head,int data)//第一个参数是链表的头结点，第二个参数是插入节点的值
{
	Node* newnode = (Node*)malloc(sizeof(Node));//为新节点分配空间
	newnode->data = data;
	newnode->next = head->next;//将原head节点的下一个节点地址赋值(指向)给新节点的下一位
	head->next = newnode;//头结点的下一位指向新插入的节点
}

删除某个节点：

这里采用的是：使用双指针的方法；

好像还有其他的方法，比如可以使用二级指针的方式，但该方法可能更难理解。

代码示例：

void deleteNode(Node*head,int data)//第一个参数是链表的头结点,第二个参数是删除节点的值，该函数会删除所有匹配的值                                   
{
//这里采用双指针的形式，进行删除
	Node* P1 = head;
	Node* P2 = head->next;
	while (P2!= NULL )
	{
		if (P2->data == data) 
		{
			Node* AimNode = P2;
			P2 = P2->next;
			P1->next = P2;
			free(AimNode);
		}
		else
		{
			P1 = P2;
			P2 = P2->next;
		}		
	}
}

寻找目标节点：

找到目标节点后，返回结果是该节点的地址，我们可以通过该节点的地址，访问对应的数据域。

代码示例：
 

Node* findNode(Node* head, int data) //返回值是目标节点地址
{
	while (head != NULL)
	{
		if (head->data == data)
		{
			return head;
		}
		else
		{
			head = head->next;
		}
	}
}

链表的排序：

这里采用的方法是冒泡排序（最简单最好理解的一种排序算法，但时间复杂度是O(n^2)）；

为便于理解，这里对链表的操作仅仅是交换数据域，并没有真正意义上的交换节点。

void bubbleSort(Node* head)  //利用冒泡排序对列表中数据进行排序
{
	Node* p = head->next;
	int len = 1; //计算链表的长度(不包括头节点)
	while (p->next!= NULL)
	{
		len++;
		p = p->next;
	}
	printf("这个链表的长度为:%d\n", len);
	for (int i = 0; i < len-1; i++)
	{
		p = head->next; //这里需要注意，每次重新遍历后需要先讲p指针指向第一个一般节点
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (p->data > p->next->data) //这里仅仅是交换了数据域，没有交换两个节点
			{
				int temp = p->data;
				p->data = p->next->data;
				p->next->data = temp;
			}
			p = p->next;
			
		}
	}	
}

完整源码：

#include<stdio.h> //练习
#include<stdlib.h>

typedef struct Node {   //定义链表的每一个节点
	int data;
	struct Node* next;  //结构体指针类型的变量  next
}Node;


Node* createNode(int num)//创建节点函数，参数是节点的数量，注意头结点是不算在节点数量里的
{
	Node* head;
	Node* end;

	head = (Node*)malloc(sizeof(Node));
	end = head;  //这里end只是一个指针变量，其存储的是head的地址，所以不需要对end进行内存的分配，换句话说，其实这里的end不是一个节点
	//还是有一点迷惑性的，这里创建end变量，只是为了后续循环好不断添加节点
	if (head == NULL)
	{
		printf("头节点内存分配失败！");
		return NULL;//表示分配内存失败了
	}
	for (int i = 0; i < num; i++)
	{
		Node* newnode = (Node*)malloc(sizeof(Node));
		if (newnode == NULL)
		{
			printf("节点内存分配失败！");
			return NULL;//表示分配内存失败了
		}
		printf("请输入该节点的数值：");
		scanf_s("%d", &newnode->data); //这里还得用scanf_s,scanf还不行，会警告，可能是编译器版本的题
		end->next = newnode;
		end = newnode;
	}

	//循环添加完成链表的创建后，要将最后一个节点的Node.next == NULL，用于链表结束的判别
	end->next = NULL;
	return head;
	//到这里，讲一下这个函数的类型Node* createNode(int num)，结构体指针类型的函数，这个函数会返回值是一个结构体的地址（在链表中就是头结点的地址），
	//这样，我们就能通过头结点不断地遍历链表中的每一个节点的。
	//某种意义上，这么做能达到创建一个函数，（类似python中直接返回一个数组的功能）
}


void printNode(Node* node) //打印节点的函数
{
	while (node->next != NULL)
	{
		printf("%d ", node->next->data);
		node = node->next;
	}
	printf("\n");
}


void freeNode(Node* head) //链表内存的释放
{
	while (head != NULL)
	{
		Node* temp = head->next;
		free(head);
		head = temp;
	}
}


//头插法
void addNode_From_Head(Node* head,int data)//第一个参数是链表的头结点，第二个参数是插入节点的值
{
	Node* newnode = (Node*)malloc(sizeof(Node));//为新节点分配空间
	newnode->data = data;
	newnode->next = head->next;//将原head节点的下一个节点地址赋值(指向)给新节点的下一位
	head->next = newnode;//头结点的下一位指向新插入的节点
}


Node* findNode(Node* head, int data) //返回值是目标节点地址
{
	while (head != NULL)
	{
		if (head->data == data)
		{
			return head;
		}
		else
		{
			head = head->next;
		}
	}
}


void deleteNode(Node*head,int data)//第一个参数是链表的头结点,第二个参数是删除节点的值，该函数会删除所有匹配的值                                   
{
//这里采用双指针的形式，进行删除
	Node* P1 = head;
	Node* P2 = head->next;
	while (P2!= NULL )
	{
		if (P2->data == data) 
		{
			Node* AimNode = P2;
			P2 = P2->next;
			P1->next = P2;
			free(AimNode);
		}
		else
		{
			P1 = P2;
			P2 = P2->next;
		}		
	}
}


void bubbleSort(Node* head)  //利用冒泡排序对列表中数据进行排序
{
	Node* p = head->next;
	int len = 1; //计算链表的长度(不包括头节点)
	while (p->next!= NULL)
	{
		len++;
		p = p->next;
	}
	printf("这个链表的长度为:%d\n", len);
	for (int i = 0; i < len-1; i++)
	{
		p = head->next; //这里需要注意，每次重新遍历后需要先讲p指针指向第一个一般节点
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (p->data > p->next->data) //这里仅仅是交换了数据域，没有交换两个节点
			{
				int temp = p->data;
				p->data = p->next->data;
				p->next->data = temp;
			}
			p = p->next;
			
		}
	}	
}

int main()
{
	Node* n1 = createNode(5);
	printf("初始化列表结果为:\n");
	printNode(n1);

	printf("头部插入节点6\n");
	addNode_From_Head(n1, 6);
	printNode(n1);


	printf("删除列表中所有节点2\n");
	deleteNode(n1,2);
	printNode(n1);


	Node*pos = findNode(n1, 3);
	printf("节点的地址为：%p\n", pos); //通过返回的节点，查看该节点的相关信息
	printf("该节点的值为：%d\n",pos->data);
	printf("该节点的下一节点地址为:%p\n", pos->next);
	

	bubbleSort(n1);
	printf("排序后结果为:\n");
	printNode(n1);


	freeNode(n1);
	printf("链表内存已释放");
	printNode(n1);


	return 0;
}

运行结果：

%KT%
关注
  • 8
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构：单链表的基本操作
weixin_45213079的博客
08-17 1149
数据结构：单链表的基本操作
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。 2.再从键盘输入顺序任意的5个整数，按有序插入的要求生成第二个有序单链表，将该链表输出显示。 3.将这两个有序单链表...
数据结构：单链表逆置
努力敲代码
06-30 7927
写出将单链表逆置的算法。即令单链表的第一个结点变为最后一个结点，第二个结点变为倒数第二个结点，…，最后一个结点变为第一个结点。
C语言简单的数据结构：单链表
2302_82004664的博客
04-10 1474
我们在使用顺序表的时候我们发现了一些问题： 1.涉及到中间插入和头插时会进行数据的移动，导致效率较低 2.增容的空间会进行数据的拷贝 3.每次申请的空间不一定被使用，导致空间浪费 以上都说明顺序表不是很完美的，那有什么解决方法呢？ 没错那就是：链表 概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表 中的指针链接次序实现的。 所以链表也是线性表的一种（物理结构上不一定时线性的，逻辑结构是连续的）
数据结构：单链表实现
weixin_39339460的博客
01-28 2092
单链表的python实现 目录*顺序表（这个不是本次重点，简单介绍一下）*链式表  　　首先说下线性表，线性表是一种最基本，最简单的数据结构，通俗点讲就是一维的存储数据的结构。 　　线性表分为顺序表和链接表： 顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素，称为线性表的顺序存储结构或顺序映像； 链式表示指的是用一组任意的存储单元存储线性表中的数据元素，称为线性表的链式存储结构。而他既可以是连续的也可以不连续，是通过一个与后...
数据结构：拆分单链表代码
10-28
本主题聚焦于一种特定的数据结构——单链表，并探讨如何对其进行拆分操作。单链表是一种线性数据结构，其中每个节点包含数据元素以及指向下一个节点的引用（或称为指针）。在本文中，我们将深入理解单链表的结构，...
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列
10-19
在IT领域，数据结构是计算机科学中的核心概念，它研究如何高效地组织和存储数据，以便于进行各种操作。在C语言中实现数据结构能够帮助我们深入理解底层工作原理，并为编写高性能的程序打下坚实基础。以下是关于标题...
数据结构与算法实验（C++）：单链表实验-代码
01-18
1.内容概要： （1）实验目的： 1）熟练掌握单链表的存储特点； 2）熟练掌握单链表的基本操作算法； 3）熟练掌握面向对象程序设计方法； 4）能灵活使用单链表解决具体的问题。...数据结构与算法实验
数据结构-单链表的操作
06-28
数据结构-单链表的操作
插入和选择排序
c23856的博客
07-20 531
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
【数据结构】搜索二叉树
dab112的博客
07-24 555
介绍了二叉搜索树的实现与模拟
数据结构（二叉树-1）
2401_83968713的博客
07-20 1075
树是⼀种⾮线性的数据结构，它是由nn>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做 树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。有⼀个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)个互不相交的集合T1T2……Tm，其中每⼀个集合⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有0个或多个后继。因此，树是递归定义的。树形结构中，⼦树之间不能有交集，否则就不是树形结构。
【手撕数据结构】把玩顺序表
apple_61439616的博客
07-19 958
顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组线性结构又是什么意思，这就不得不提到线性表了线性表（linear list）是n个具有相同特性的数据元素的有限序列线性表是⼀种在实际中⼴泛使 ⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串注意的是，他在逻辑结构上一定是连续的，但在物理结构上不一定是连续的.线性表在物理上存储时，通常以数组和链式结构的形式存储那么我们知道，数组在内存中存储也是连续的，并且也是类型一致，那么他与顺序表的区别是什么呢.
《数据结构：栈和队列》
2401_83305953的博客
07-19 664
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行插入和删除操作的一端称为栈顶，另一端称为栈底。概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)队列也可以由数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。：栈的插入操作叫做进栈/压栈/入栈/，入数据在栈顶。
数据结构——二叉树定义
鲸落博客
07-23 371
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
数据结构：栈
sparrowfart的博客
07-19 1172
满足栈的特性，只有先进后出的特性，不能遍历，也就不能遍历打印，也不能随机访问。
2024.7.24 作业
qq_64434282的博客
07-24 367
【代码】2024.7.24 作业。
数据结构的概念和术语
最新发布
2303_78660417的博客
07-24 349
数据结构是一门研究非数值计算的程序设计中计算机的操作对象以及它们之间的关系和操作的学科。数据结构的基本数据结构包括两部分，线性结构跟非线性结构。
数据结构：单链表操作实现详解与应用
在《数据结构》第二章讲义中，主要讨论了线性表的基本概念和操作。线性表是一种重要的数据结构，其逻辑结构表现为元素的有序集合，具有四个基本特征：第一元素的存在、最后一个元素的存在、每个元素都有唯一的后继和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值