【数据结构基础_有空头单向链表_(C语言实现)】

最新推荐文章于 2022-03-16 11:17:07 发布
最新推荐文章于 2022-03-16 11:17:07 发布
阅读量523 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： c语言 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sugar_wolf/article/details/121618156
版权

C语言 单向链表 增删改查 空头 数据结构
关键词由CSDN通过智能技术生成

有空头单向链表_(C语言实现)

本文主要是针对（含空头）单向链表进行增、删、改、查操作

创建一个结构体当做节点
struct Node
{
	int iData;
	struct Node* pNext;
};

定义空头指针

//空头
struct Node stHead = { 0,NULL };

空头不参加任何增、删，

增加：1.尾添加

此处和之前无空头链表操作只有稍微差别，咱们这次就不要尾指针了（当然你也可以尝试添加空的尾指针也是可以的），记住一定要先连后断

//尾添加
void AddToTail(struct Node* stHead, int iData)
{
	//参数合法性检测
	if (NULL == stHead)
		return;
	//申请节点
	struct Node* pTemp = (struct Node*)malloc(sizeof(struct Node));
	if (pTemp == NULL)
		return;
	//空间赋值
	pTemp->iData = iData;
	pTemp->pNext = NULL;
	//节点连到链表
	struct Node* pT = stHead;
	//循环找到尾巴
	while (pT->pNext != NULL)
		pT = pT->pNext;
	pT->pNext = pTemp;
	//计数器++
	//(*iNodeCount)++;
	(stHead->iData)++;
}
增加：2.头添加
//头添加
void AddToHead(struct Node* stHead, int iData)
{
	//参数合法性检测
	if (NULL == stHead)
		return;
	//申请节点
	struct Node* pTemp = (struct Node*)malloc(sizeof(struct Node));
	if (pTemp == NULL)
		return;
	//空间赋值
	pTemp->iData = iData;
	pTemp->pNext = NULL;
	//链接链表
	pTemp->pNext = stHead->pNext;
	stHead->pNext = pTemp;
	//计数器++
	(stHead->iData)++;
}

此时咱们链表的最简单的两个添加，已经完成，我们可以遍历链表来查看，并且释放链表

遍历链表
//遍历链表
void Look(struct Node stHead)
{
	struct Node* pTemp = stHead.pNext;
	printf("共有 %d 个数据： ", stHead.iData);
	while (pTemp != NULL)
	{
		printf("%d  ", pTemp->iData);
		pTemp = pTemp->pNext;
	}
	putchar('\n');
}
释放链表
//释放链表
void FreeList(struct Node* stHead)
{
	//参数合法性检测
	if (NULL == stHead || 0 >= stHead->iData)
		return;
	struct Node* pTemp = stHead->pNext;
	if (pTemp == NULL)
		return;
	while (pTemp != NULL)
	{
		//记录当前节点
		struct Node* pT = NULL;
		if (pT== NULL)
			return;
		pT = pTemp;
		//节点下移
		pTemp = pTemp->pNext;
		//释放记录节点
		free(pT);
	}
	//对应数据置NULL
	stHead->pNext = NULL;
	//*iNodeCount = 0;
	stHead->iData = 0;
}

释放链表记得指针要置空哈

查找：1.根据下标查询
//根据下标查找节点
struct Node* FindNodeByIndex(struct Node* stHead, int iIndex)
{
	if (NULL == stHead || stHead->iData <= 0 || iIndex < 0 || iIndex > (stHead->iData) - 1)
		return NULL;
	struct Node* pTemp = stHead->pNext;
	for (int i = 0; i < iIndex; i++)
		pTemp = pTemp->pNext;
	return pTemp;
}
查找：2.根据数值查询
struct Node* FindNodeByData(struct Node* stHead, int iData)
{
	if (NULL == stHead || stHead->iData <= 0)
		return NULL;
	struct Node* pTemp = stHead->pNext;
	while (pTemp != NULL)
	{
		if (pTemp->iData == iData)
			break;
		pTemp = pTemp->pNext;
	}
	return pTemp;
}
升级版添加：1.在指定下标节点处添加节点
void AddByIndex(struct Node* stHead, int iPosIndex, int iIndex)
{
	//参数合法性检测
	if (NULL == stHead || iPosIndex > stHead->iData || iPosIndex < 0)
		return;
	//循环找位置
	struct Node* pTemp = stHead;
	for (int i = 0; i < iPosIndex; i++)
	{
		pTemp = pTemp->pNext;
	}
	//找到了 并添加
	AddToHead(pTemp, iIndex);
	pTemp->iData -= 1;
	stHead->iData += 1;
}
升级版添加：2.在指定数值添加一个或者多个节点

看着很高大上，其实你只需要调用头添加即可，此时的头非彼头；

//指定数据后面添加一个节点
void AddBehandData(struct Node* stHead, int iPosData, int iData)
{
	//参数合法性检测
	if (NULL == stHead)
		return;
	//遍历 找节点
	struct Node* pTemp = stHead->pNext;
	while (pTemp != NULL)
	{
		if (pTemp->iData == iPosData)
			break;
		pTemp = pTemp->pNext;
	}
	//判断是否找到
	if (NULL == pTemp)
		printf("查无此数据");
	else
	{
		AddToHead(pTemp, iData);
		pTemp->iData -= 1;
		stHead->iData += 1;
	}
}

//指定下标位置添加 n 个节点
void AddBySomeIndex(struct Node* stHead, int iPosIndex, int iCount, int iData)
{
	//参数合法性检测
	if (NULL == stHead || iPosIndex > stHead->iData || iPosIndex < 0)
		return;
	//循环找位置
	struct Node* pTemp = stHead;
	for (int i = 0; i < iPosIndex; i++)
	{
		pTemp = pTemp->pNext;
	}
	//找到了 并添加
	//循环插入
	for (int i = 0; i < iCount; i++)
	{
		AddToHead(pTemp, iData);
		pTemp->iData -= 1;
		stHead->iData += 1;
	}
}
修改：1.根据数值改变此节点数据
void ChangeByData(struct Node stHead, int iData, int iValue)
{
	if (stHead.iData <= 0)
		return;
	//循环找到对应下标位置
	struct Node* pTemp = stHead.pNext;
	for (int i = 0; i < stHead.iData; i++)
	{
		if (pTemp->iData == iData)
		{
			//修改数据
			pTemp->iData = iValue;
		}
		pTemp = pTemp->pNext;	
	}
}
修改：2.根据下标改变此节点
//根据下标修改修改节点的值
void ChangeByIndex(struct Node stHead, int iIndex, int iValue)
{
	if (stHead.iData <= 0 || iIndex < 0 || iIndex >stHead.iData - 1)
		return;
	//循环找到对应下标位置
	struct Node* pTemp = stHead.pNext;
	for (int i = 0; i < iIndex; i++)
		pTemp = pTemp->pNext;
	//修改数据
	pTemp->iData = iValue;
}
删除：1.删除指定下标节点
void DeleteByIndex(struct Node* stHead, int iIndex)
{
	//参数合法性检测
	if (NULL == stHead || iIndex < 0 || iIndex > stHead->iData - 1)
		return;
	//循环定位指定下标的前一个节点
	struct Node* pTemp = stHead;
	for (int i = 0; i < iIndex; i++)
	{
		pTemp = pTemp->pNext;
	}
	//节点扣下来
	struct Node* pT = pTemp->pNext;
	//链表重新连接
	pTemp->pNext = pT->pNext;
	//释放原节点
	free(pT);
	//节点数 -1
	stHead->iData -= 1;
}
删除：2.删除指定数据节点
void DeleteByValue(struct Node* stHead, int iValue)
{
	// 参数合法性检测
	if (NULL == stHead || stHead->iData < 0)
		return;
	//循环定位指定数据的前一个节点
	struct Node* pTemp = stHead;
	if (pTemp == NULL)
		return;
	while (pTemp->pNext != NULL)
	{
		if (pTemp->pNext == NULL)
			return;
		if (pTemp->pNext->iData == iValue)
		{
			//记录被删除的节点
			struct Node* pT = NULL;
			if (pT == NULL)
				return;
			pT = pTemp->pNext;
			//链表重新连接
			pTemp->pNext = pT->pNext;
			//释放原节点
			free(pT);
			//节点数 -1
			stHead->iData -= 1;
			continue;
		}
		pTemp = pTemp->pNext;
	}
}
删除：3.根据数值删除此节点（只删除一个哟）
struct Node* DeleteOneDataByData(struct Node** pHead, struct Node** pEnd, int iData)
{
	if (NULL == *pHead)
		return NULL;
	if ((*pHead)->iData == iData)
	{
		DeleteHead(pHead, pEnd);
		return *pHead;
	}
	else if ((*pEnd)->iData == iData)
	{
		DeleteEnd(pHead, pEnd);
		return *pHead;
	}
	else
	{
		//循环找节点
		struct Node* pTemp = *pHead;
		while (pTemp->pNext != NULL)
		{
			if (pTemp->pNext->iData == iData)
				break;
			pTemp = pTemp->pNext;
		}
		//判断
		if (pTemp->pNext != NULL)
		{
			struct Node* pT = pTemp->pNext; //记录
			pTemp->pNext = pT->pNext;
			free(pT);
			return *pHead;   //return pTemp->pNext  ----- pHead
		}
		else
		{
			printf("查无此节点\n");
			return NULL;
		}
	}
}

下面是一个简单对链表去除重复元素的操作，主要通过两个指针（内指针和外指针），遍历链表，找到重复的直接删除，并连接上下一个节点即可。

（1）去重
void DeleteSome(struct Node* stHead)
{
	if (NULL == stHead || stHead->iData <= 1)
		return;
	//循环遍历
	struct Node* pWai = stHead->pNext;
	if (NULL == pWai)
		return;
	while (pWai != NULL)
	{
		//跟后面的节点进行比较
		struct Node* pNei = NULL;
		if (NULL == pNei)
			return;
		pNei = pWai;
		while (pNei->pNext != NULL)
		{
			if (pWai->iData == pNei->pNext->iData)
			{
				//删除节点
				//1.记录节点
				struct Node* pTemp = pNei->pNext;
				//2.原位置进行新的链接
				pNei->pNext = pTemp->pNext;
				//3.释放节点
				free(pTemp);
				//4.节点数--
				stHead->iData -= 1;
				continue;
			}
			pNei = pNei->pNext;
		}

		pWai = pWai->pNext;
	}
}

此时有空头的单向链表基本操作已经完成咯~

千北@
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
graph_DFS.zip_C语言单向链表_linux 链表_链表_链表 linux
09-24
在IT领域，特别是软件开发中，数据结构是基础且至关重要的部分，而链表就是其中一种常用的数据结构。本文将详细解析标题为“graph_DFS.zip”中的C语言单向链表在Linux环境下的实现，以及它与链表、图深度优先搜索...
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
在IT领域，特别是编程中，数据...在实际应用中，链表常用于实现如队列、栈、哈希表等高级数据结构，以及解决各种排序和搜索问题。通过分析并实践C11.C中的代码，学生可以深入理解链表的内部机制，提升自己的编程能力。
C语言单向链表的实现
热门推荐
无界编程
10-30 5万+
一个简单结点的结构体表示为：    struct note    {       int  data；              /*数据成员可以是多个不同类型的数据*/       struct  note  *next；      /*指针变量成员只能是-个*/    }；  一个简单的单向链表的图示 1．链表是结构、指针相结合的-种应用,它是由头、中间、尾多个链环组成的单方向可伸缩的链表,链
有空头链表
taw19960426的博客
05-23 468
#include <stdio.h> #include <stdlib.h> //节点结构体 struct Node { int a; struct Node *pNext; } ; //头尾指针定义 struct Node *g_pHead=NULL; struct Node *g_pEnd=NULL; //空头链表初始化 void LianBiaoCh...
C：无空头链表
weixin_30399155的博客
05-14 216
1.链表的结构体以及全局变量声明 #include <stdio.h>#include <stdlib.h>// 创建Node结构体struct Node{ int a; struct Node * pNext;};//链表头尾指针struct Node* g_pHead = NULL; //刚开始链表头部为null（头部：内容，该节点的内容存储）struct...
西卡学院单链表的实现（带空表头的实现）
lijun5635的专栏
11-23 1258
纠结写了一上午没啥进展，把别人的代码贴出来。要努力了的。     list.h    #define NULL 0 #define ElementType int typedef struct _ChainNode { ElementType data; struct _ChainNode * next; }ChainNode;
【数据结构基础_双向循环链表（有空头）_(C语言实现)】
Sugar_wolf的博客
11-30 793
双向循环链表（含空头） 双向循环链表呢，就是将尾结点指向头结点形成一个环形 本文主要是针对双向循环链表进行增、删、改、查操作 创建一个结构体当做节点 struct Node { int iData; struct Node* pNext; struct Node* pPre; }; 定义空头 //空头 struct Node stHead; stHead.iData = 0; stHead.pNext = &stHead; stHead.pPre = &stHead;
CList.zip_CList_C语言实现vector_链表 c语言
09-22
`CList.zip`文件提供了一个C语言实现的链表，模拟了`std::vector`的一些操作，这对于学习数据结构和算法，以及理解动态数组的工作原理非常有帮助。链表是一种非连续、非顺序的存储结构，它通过指针将各个节点连接...
shujujiegou.rar_c 数据结构_数据结构_栈_链表 实现_顺序表
09-22
在这个"shujujiegou.rar_c 数据结构_数据结构_栈_链表 实现_顺序表"压缩包中，包含了C语言实现的数据结构相关的源代码，主要关注的是顺序表、链表和栈这三种基本数据结构。下面我们将逐一探讨这些数据结构及其基本...
DOUBLE_LINK.rar_DOUBLE_LINK_doublelink_双向链表_双向链表C语言_链表 实现
最新发布
09-24
双向链表（Double-Linked List）是一种数据结构，它与单向链表相似，但每个节点不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针。这种设计使得在链表中的前进和后退操作同样高效，而单向链表只能从前...
C：有空头链表
weixin_30410999的博客
05-16 274
#include <stdio.h>#include <stdlib.h>//结点结构体struct Node{ int a; struct Node * pNext;};//链表头尾指针struct Node * g_pEnd = NULL;//这里的null没有意义，因为在主函数开始会直接给head和end申请地址，成为空头struct Node * g_p...
带有空表头的创建链表的方法（下附用指针创建带有空表头的链表）
qq_41151066的博客
09-28 3167
#include<stdio.h> #include<stdlib.h> typedef struct num{ int num; struct num *next; }Num, *NUM; //创建链表 NUM createlist(NUM L,int x) { printf("开始创建链表\n"); NUM head,r,s,tail; int i=0; ...
C中链表为什么要建立空的表头？
qq_18671205的博客
04-29 2513
1.头结点有数据：当你想在自定函数中删改头结点的数据时，或是要修改head的值的时候，不能用头指针head作为形参，这样修改无效。所以你必需把头指针的指针（也就是头指针的地址）当作形参，而通常会把头指针写入一个结构体内，用该结构的指针当作形参。（实质上这也是指针的指针当作形参的办法）。 2.当头结点没有数据时：显然head中的数据域是空的，而head->next是存在的（除非是空表）,这就...
C语言链表之空头链表的创立，及元素的插入
m0_53036215的博客
09-15 564
#include<stdio.h> #include<stdlib.h> struct node { int num; struct node* nextptr; }; void createlisthead(struct node** headptr) { *headptr=(struct node*)malloc(sizeof(struct node)); if (*headptr != NULL) { (*headptr)->nextptr = NULL;.
(7)数据结构与算法-有空头链表的创建与添加
A_shmily_的博客
08-11 373
有空头链表介绍特点链表的创建空头的创建节点计数器的建立链表的添加尾添加释放链表 介绍 特点 1）第一个节点不装数据作为链表头（永远不变），从第二个节点开始有数据 2）不使用尾指针，涉及尾部，循环寻找；目的是与之前写的不一样，更有意思！ 3）操作原理和操作逻辑和无空头链表基本一样，多了空头，代码部分也会稍有不同 4）与无空头链表的区别：有空头一些操作会比无空头的简单一些 链表的创建 空头的创建 //单独创建空头链表节点 struct Chain Head = {0，NULL}; //或者 struct
自己动手写一个简单的单向链表结构
凉拌糖醋鱼
07-11 399
自己动手写一个简单的单向链表结构 链表结构，是一个相对比较复杂的结构，不过也不难理解。尤其是我们在学习了Java中的数据类型之后，了解了除了基本的数据类型，其他的数据类型都是引用数据类型，也就是说，引用了它们的地址值。 关于链表结构，它的特点是插入删除特别的方便，但是查询就会比较麻烦，因为单向链表只在头结点保存了对下一个结点的引用，如果你要查询链表中某个元素的数据，那么就得从头结点开始遍历整个链表，可以说是相当慢了。但是插入元素结点是很方便的，只需要将要查如位置的前一个元素结点的指针域指向要插入元素结点，再
无空头链表详解（增删改查）
taw19960426的博客
05-23 522
#include <stdio.h> #include <stdlib.h> //节点结构体 struct Node { int a; struct Node *pNext; } ; //链表的头尾指针 struct Node *g_pHead=NULL; struct Node *g_pEnd=NULL; //链表清空 需要遍历 void qingko...
数据结构—单向链表（详解）
梅山
03-16 1万+
基于C语言的链表基础，包括概念，链表的初始化，插入，删除，查找等操作。
Java中List的空指针问题
qq_45872719的博客
09-13 2153
Java中List的空指针问题 如果直接使用则会出现空指针问题 修改： 在对List声明的时候，缺失了实现类的赋予，会导致空指针问题
C语言实现单向链表动态数据结构
"本资源主要介绍了如何在C语言中...总结来说，这个资源提供了C语言实现单向链表的基础知识，包括链表节点的定义、链表的创建方法以及如何通过函数来构建链表，对于学习数据结构和C语言编程的初学者来说是非常有价值的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

千北@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值