单向链表基本操作

最新推荐文章于 2023-08-05 01:56:51 发布
最新推荐文章于 2023-08-05 01:56:51 发布
阅读量158 收藏
点赞数
分类专栏： DS 文章标签： C 单向链表 结构体 指针 增删改查
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxy131072/article/details/107711319
版权 
#define  _CRT_SECURE_NO_WARNINGS 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct Node
{
	int id;		//数据域
	struct Node *next;	//指针域
}SLIST;

//创建头节点
SLIST *SListCreat() 
{
	SLIST *pCur = NULL;		//当前节点
	SLIST *pHead = NULL;	//头结点
	SLIST *pNew = NULL;		//新节点

	//头结点，只是作为标志使用，不保存有效数据
	pHead = (SLIST *)malloc(sizeof(SLIST));
	if (pHead == NULL)
	{
		return NULL;
	}

	//pHead成员变量赋值，数据域任意即可，后面用不上
	pHead->id = -1;
	pHead->next = NULL;

	//保存当前节点
	//指针指向谁，就把谁的地址赋值给指针
	pCur = pHead;

	int data;

	//循环创建结点，结点数据域中的数值从键盘输入，以-1作为输入结束标志
	while (1)
	{
		printf("请输入数据：");
		scanf("%d", &data); 

		if (data == -1)
		{//输入-1，退出循环
			break;
		}

		//新节点分配空间
		pNew = (SLIST *)malloc(sizeof(SLIST));
		if (pNew == NULL)
		{//如果没有分配成功，跳出本次循环
			continue;
		}

		//pNew成员变量赋值
		pNew->id = data;
		pNew->next = NULL;

		//当前节点next指向新节点
		pCur->next = pNew;

		//新节点的next指向NULL
		pNew->next = NULL;

		//当前节点的位置移动到新节点的位置（pCur指向pNew）
		pCur = pNew;
	}

	
	//链表的头结点地址由函数值返回。
	return pHead;
}

//遍历节点
//顺序输出单向链表各项结点数据域中的内容
int SListPrint(SLIST *pHead)
{
	if (pHead == NULL)
	{
		return -1;
	}

	//保存头结点的下一个节点
	//因为头结点不是有效数据节点，下一个节点才是有效数据的结点
	SLIST *pCur = pHead->next;

	printf("head -> ");
	while (pCur != NULL)
	{
		printf("%d -> ", pCur->id);

		//节点往后移动，当前节点指向下一个节点
		pCur = pCur->next;
	}
	printf("NULL\n");

	return 0;
}

//在值为x的结点前，插入值为y的结点；
//若值为x的结点不存在，则插在表尾
int SListNodeInsert(SLIST *pHead, int x, int y)
{
	if (pHead == NULL)
	{
		return -1;
	}

	SLIST *pPre = pHead;		//上一个节点
	SLIST *pCur = pHead->next;	//当前节点
	SLIST *pNew = NULL;         //新节点

	while (pCur != NULL)
	{
		//如果当前节点数据域等于x，跳出循环
		if (pCur->id == x)
		{
			break;
		}

		//保存当前节点
		pPre = pCur;

		//当前节点往后移动，当前节点指向下一个节点
		//pPre和pCur相差一个节点，pPre为上一个节点，pCur为当前节点
		pCur = pCur->next;
	}

	//程序执行到这，有两种情况
	//1. 找到值为x的结点，pCur为当前匹配节点，pPre为上一个节点
	//2. 没有找到x的结点，节点移动到结尾，pPre为最后一个节点，pCur为NULL

	//在值为x的结点前，插入值为y的结点；
	//若值为x的结点不存在，则插在表尾
	
	//新节点分配空间
	pNew = (SLIST *)malloc(sizeof(SLIST));
	if (pNew == NULL)
	{
		return -2;
	}

	//pNew成员变量赋值
	pNew->id = y;
	pNew->next = NULL;

	//pPre的next指向pNew
	pPre->next = pNew;

	//pNew的next指向pCur
	pNew->next = pCur;

	return 0;
}

//删除第一个值为x的结点
int SListNodeDel(SLIST *pHead, int x)
{
	if (pHead == NULL)
	{
		return -1;
	}

	SLIST *pPre = pHead;		//上一个节点
	SLIST *pCur = pHead->next;	//当前节点
	int flag = 0; //标志位，0代表没有值为x的结点，1代表有

	while (pCur != NULL)
	{
		if (pCur->id == x)
		{
			//上一个节点指向当前节点的下一个节点
			pPre->next = pCur->next;

			//临时释放节点
			free(pCur);
			pCur = NULL;

			//标志位，0代表没有值为x的结点，1代表有
			flag = 1;

			//跳出循环
			break;
		}

		//保存当前节点
		pPre = pCur;

		//当前节点往后移动，当前节点指向下一个节点
		//pPre和pCur相差一个节点，pPre为上一个节点，pCur为当前节点
		pCur = pCur->next;
	}

	if (flag == 0)
	{ //标志位，0代表没有值为x的结点，1代表有
		printf("没有值为%d的结点\n", x);
		return -2;
	}

	return 0;
}

//删除值为x的所有结点
int SListNodeDelPro(SLIST *pHead, int x)
{
	if (pHead == NULL)
	{
		return -1;
	}

	SLIST *pPre = pHead;		//上一个节点
	SLIST *pCur = pHead->next;	//当前节点
	SLIST *pTmp = NULL;			//临时释放节点
	int flag = 0; //标志位，0代表没有值为x的结点，1代表有


	while (pCur != NULL)
	{
		if (pCur->id == x)
		{
			//上一个节点指向当前节点的下一个节点
			pPre->next = pCur->next;
			pTmp = pCur;		//临时释放节点


			//当前节点往后移动，当前节点指向下一个节点
			//pPre和pCur相差一个节点，pPre为上一个节点，pCur为当前节点
			pCur = pCur->next;

			//临时释放节点
			free(pTmp);
			pTmp = NULL;

			//标志位，0代表没有值为x的结点，1代表有
			flag = 1;

			//结束本次循环，没有跳出循环，看是否有重复值为x的结点
			continue;
		}

		//保存当前节点
		pPre = pCur;

		//当前节点往后移动，当前节点指向下一个节点
		//pPre和pCur相差一个节点，pPre为上一个节点，pCur为当前节点
		pCur = pCur->next;
	}

	
	if (flag == 0)
	{ //标志位，0代表没有值为x的结点，1代表有
		printf("没有值为%d的结点\n", x);
		return -2;
	}

	return 0;
}

//链表节点排序
int SListNodeSort(SLIST *pHead)
{
	if (pHead == NULL)
	{
		return -1;
	}

	SLIST *pPre = NULL;
	SLIST *pCur = NULL; 
	SLIST tmp; //临时交换变量
	
	//选择法排序
	for (pPre = pHead->next; pPre != NULL; pPre = pPre->next)
	{
		for (pCur = pPre->next; pCur != NULL; pCur = pCur->next)
		{
			if (pPre->id > pCur->id) //升序
			{
				//交换数据域
				tmp = *pCur;
				*pCur = *pPre;
				*pPre = tmp;

				//交换指针域（重要）
				tmp.next = pCur->next;
				pCur->next = pPre->next;
				pPre->next = tmp.next;

			}
		}
	}

	return 0;
}

//假如原来链表是升序的,升序插入新节点
//不能插入节点后再排序，是升序插入新节点x
int SListNodeInsertPro(SLIST *pHead, int x)
{
	//先排序，保证原来链表是升序的
	int ret = SListNodeSort(pHead);
	if (ret != 0)
	{
		return ret;
	}

	SLIST *pPre = pHead;		//上一个节点
	SLIST *pCur = pHead->next;	//当前节点

	while (pCur != NULL)
	{
		//找到合适节点，假如x = 3
		//链表为：1 2 4 5
		//那么 4 节点为合适节点
		if (pCur->id >= x)
		{
			break;
		}

		//保存当前节点
		pPre = pCur;

		//当前节点往后移动，当前节点指向下一个节点
		//pPre和pCur相差一个节点，pPre为上一个节点，pCur为当前节点
		pCur = pCur->next;
	}

	//程序执行到这，有2种情况
	//1. 找到匹配节点，pCur为当前匹配节点，pPre为上一个节点
	//2. 没有找到匹配节点，节点移动到结尾，pPre为最后一个节点，pCur为NULL
	

	//新节点分配空间
	SLIST *pNew = (SLIST *)malloc(sizeof(SLIST));
	if (pNew == NULL)
	{
		return -2;
	}

	//pNew成员变量赋值
	pNew->id = x;
	pNew->next = NULL;

	//pPre的next指向pNew
	pPre->next = pNew;

	//pNew的next指向pCur
	pNew->next = pCur;

	return 0;
}

//翻转链表的节点（不是排序，是翻转）
int SListNodeReverse(SLIST *pHead)
{
	if (pHead == NULL || pHead->next == NULL || pHead->next->next == NULL)
	{
		return -1;
	}

	//上一个节点
	SLIST *pPre = pHead->next;

	//当前节点，pCur和pPre相差一个节点
	SLIST *pCur = pPre->next; //pHead->next->next

	SLIST *pTmp = NULL; //临时节点

	while (pCur != NULL)
	{
		//先保存pCur的下一个节点
		pTmp = pCur->next;

		//原来： pPre->next = pCur
		//翻转： pCur->next = pPre
		//pCur的next指向pPre
		pCur->next = pPre;

		//pPre往后移动一个节点，pPre指向pCur
		pPre = pCur;

		//pCur往后移动一个节点，pCur指向pTmp
		pCur = pTmp;
	}

	//确定头结点和尾结点
	//程序执行到这，说明pCur为NULL，pPre为最后一个有效节点
	//而翻转后，pPre为头结点指向的第一个有效节点

	//先确定翻转后的尾结点
	pHead->next->next = NULL;

	//在确定头结点
	pHead->next = pPre;

	return 0;
}

//释放所有节点
int SListDestroy(SLIST *pHead)
{
	if (pHead == NULL)
	{
		return -1;
	}

	SLIST *pTmp = NULL;	//临时释放节点

	while (pHead != NULL)
	{
		//临时释放节点
		pTmp = pHead;

		//头结点指向头结点next节点
		pHead = pHead->next;
		
		free(pTmp);
		pTmp = NULL;

	}

	return 0;
}

int main(int argc, const char * argv[])
{
	SLIST *pHead = NULL;

	pHead = SListCreat(); //创建头结点
	printf("\n创建头结点后\n");
	SListPrint(pHead); //遍历所有节点

	
	SListNodeInsert(pHead, 4, 3);//在4前面插入3
	printf("\n在4前面插入3\n");
	SListPrint(pHead); //遍历所有节点

	
	SListNodeDel(pHead,  4);//删除第一个值为4的结点
	printf("\n删除第一个值为4的结点\n");
	SListPrint(pHead); //遍历所有节点

	SListNodeSort(pHead);//链表节点排序
	printf("\n链表节点排序\n");
	SListPrint(pHead); //遍历所有节点

	SListNodeInsertPro(pHead, 5);//升序插入5
	printf("\n升序插入5后\n");
	SListPrint(pHead); //遍历所有节点

	//翻转链表的节点（不是排序，是翻转）
	SListNodeReverse(pHead);
	printf("\n翻转链表的节点\n");
	SListPrint(pHead); //遍历所有节点

	SListDestroy(pHead);//释放所有节点
	pHead = NULL;
	SListPrint(pHead); //遍历所有节点

	return 0;
}

测试结果

在这里插入图片描述

zxy131072
关注
专栏目录
C中单向链表的简单使用
xiaopan233的博客
08-24 238
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; //结构体，为链表做准备 typedef struct A{ int num; struct A *next; } AA; /* *创建链表函数 */ AA *create(int n){ int i; AA *head, *node, *end; //定义头结点，普通节点，尾节点...
单向链表的操作
weixin_54420332的博客
02-24 269
具体实现：在链表中使用节点存储数据，并使用引用串联各个元素。每个节点除了存储数据本身之外，还需要额外存储下一个节点的地址。 添加、删除、查找操作的编码如下： public class LinkedList { private Node head = null; // 整个链表的头指针 public void insert(Node a, Node b) { // 在节点a后面插入新节点b if (a == null) { //在链表的头部插入添加数据b b.next=head; he
单向链表的基本操作
qq_52253798的博客
01-17 454
一、什么是单向链表 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 a、表元素域elem用来存放具体的数据。 b、链接域next用来存放下一个节点的位置。 c、变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。 二、链表基本操作的实现原理； （1）、添加元素； 直接添加即在链表的末尾添加，又因底层是用LinkedList实现...
数据结构：链表（一）单向链表的实现及应用
最新发布
2201_75880188的博客
08-05 591
本文对链表的创建即实现进行阐述，主要围绕更易理解和上手实现的无头单向非循环链表进行详细叙述和讲解。
一文教会你单向链表
fq157856469的博客
07-30 1299
链表是是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。比较通俗易懂的说法就是，在计算机内存中开辟了一个个空间，然后通过地址的方式将它们链接在一起，并通过地址的方式进行访问。在手动创建链表之前，我们要先对链表进行定义，对链表的定义，接口函数的引用和头文件的引用最好放在一个头文件中这样在要使用创建的接口时便只需要引用一个头文件即可，而接口函数的实现你也可以放在一个.c文件中，最后在另一个.c文件中引用函数测试即可，如图：//链表博客版.h。
单向链表基本操作的递归实现
08-10
在本文中，我们将探讨如何使用递归实现单向链表的一些基本操作。 1. **统计节点个数**：`count_listnode`函数通过递归遍历链表，计算节点总数。在递归调用中，它首先检查当前节点是否非空，然后递增计数器`count`，...
python单向链表的基本操作细节（小白入门）
12-21
【Python 单向链表的基本操作细节】 链表是一种数据结构，它不同于数组，它将数据元素分散在内存的不同位置，而不是连续存储。单向链表是链表的一种形式，其中每个节点包含一个数据元素和一个指向下一个节点的引用...
单向链表的操作____
05-17
单向链表是一种基本的数据结构，它在计算机科学和编程中有着广泛的应用。与数组不同，链表中的元素不是在内存中连续存储的，而是通过指针连接起来。每个链表节点包含两部分：数据域，用于存储实际的元素值；指针域，...
带头结点的单向链表的基本操作的实验代码和实验报告
04-14
使用给定数据结构，实现带头结点的单向链表的创建、删除链表、插入结点等操作，每个学生的学号互不相同，学号不同而姓名相同则为不同的学生，每个学生的学号在合并后的链表中不重复，如果出现重复，则删除年龄较小...
单向链表类模板_单向链表类模板_fastchq_
10-03
单向链表类模板的基本结构通常包括以下几个部分： 1. **节点定义**：首先，我们需要定义一个节点结构体（或类），它包含一个数据成员和一个指向下一个节点的指针。例如： ```cpp template struct ListNode { T...
TypeScript算法-21. 合并两个有序链表（包含数组到链表的转换、链表遍历的方法）
qq_40486952的博客
12-02 561
用TypeScript做【LeetCode 热题 HOT 100】：21. 合并两个有序链表（包含数组到链表的转换函数、链表遍历函数）
单链表的操作（超详细），保证你看完不后悔
热门推荐
princekin
04-22 3万+
编程实现单链表的以下基本操作：建立顺序表，修改顺序表，插入顺序表，删除顺序表。
单向链表的操作（带头结点）
m0_59716409的博客
07-28 2014
单向链表的操作
单向链表的简单使用
倚楼听风雨的博客
09-28 1万+
一、单向链表的概念     单向链表是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。链表是使用指针进行构造的列表，并且是由一个个结点组装起来的，因此又称为结点列表。其中每个结点都有指针成员变量指向列表中的下一个结点，head指针指向第一个结点称为表头，而终止于最后一个指向nuLL的指针。     结点的数据结构 typedef struct _LINK_N
单链表常见操作图文详解
程序猿老樊的博客
04-15 2万+
     单链表的最大特点是可以将物理地址上不连续的数据连接起来，通过指针来对物理地址进行操作，实现增删改查等功能。     单链表分为两种：有头链表和无头链表。     无头单链表，也就是phead一只是一个指针，指向链表的第一个节点。     带头节点的单链表：只不过头结点的data不保存信息。//构建一个节点typedef struct Node { DataType data; ...
TS：链表
大空翼 つばさ
03-08 895
class Node { constructor(data){ this.data = data; this.next = null; } } class LinkedList { constructor(head){ if(typeof head === 'undefined'){ this.length = 0; this.head = null; }else{ this.length = 1; this.head = new Node(head); }
C语言实现单向链表的基本操作
"这篇资源是关于单向链表的基础知识，包括如何在C语言中实现单向链表的初始化、创建、销毁等操作。" 在数据结构中，链表是一种非常重要的非线性数据结构。单向链表是其中一种形式，每个节点包含一个数据元素和一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值