《C语言》单链表——增、删、查、改、销毁、排序、翻转、合并、取中间节点...

最新推荐文章于 2023-03-20 20:26:40 发布
最新推荐文章于 2023-03-20 20:26:40 发布
阅读量396 收藏 3
点赞数
分类专栏： C语言 C 文章标签： 数据结构 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_41905806/article/details/84790137
版权
C语言 同时被 2 个专栏收录
7 篇文章 0 订阅
订阅专栏
C
7 篇文章 0 订阅
订阅专栏

《C语言》单链表——增、删、查、改、销毁、排序、翻转、合并、取中间节点...

Main.c

#include "SingleList.h"
#include <time.h>

#define N 10

void main()
{

/************************尾部添加节点************************/
#if 0
	//创建一个结构体指针（32Bit-占四字节）
	SingleList* P_Head = NULL;

	for(int i=0;i<N;i++)
	{
		//尾部添加节点
		PushBack(&P_Head, i);
	}
	//显示节点
	Show(P_Head);
#endif

/************************头部添加节点************************/
#if 0

	//定义一个结构体指针
	SingleList* P_Head = NULL;

	for (int i = 0; i < N; i++)
	{
		//头部添加节点
		PushHead(&P_Head, i);
	}

	//显示链表状态
	Show(P_Head);
#endif

/************************查找指定节点************************/
#if 0

	//定义一个结构体指针
	SingleList* P_Head = NULL;

	//循环插入节点
	for (int i = 0; i < N; i++)
	{
		PushBack(&P_Head, i);
	}

	//显示链表状态
	Show(P_Head);

	//查找节点,分别查找“0”、“5”、“9”
	//如果有一个找不到就打印“Can't found!”
	if (NULL != FindNode(P_Head, 0) && NULL != FindNode(P_Head, 5) && NULL != FindNode(P_Head, 9))
	{
		puts("Find");
	}
	else
	{
		puts("Can't found!");
	}

#endif

/************************将节点插入指定位置************************/
#if 0
	//定义结构体指针
	SingleList* P_Head = NULL;
	
	//循环添加节点
	for (int i = 0; i < N; i++)
	{
		//尾部添加节点
		PushBack(&P_Head, i);
	}

	//显示链表状态（插入节点之前）
	Show(P_Head);


	InsertNode(&P_Head, 0, 100);

	InsertNode(&P_Head, 5, 100);

	InsertNode(&P_Head, 9, 100);

	//显示链表状态（插入节点之后）
	Show(P_Head);
#endif

/************************删除指定节点************************/
#if 0
	//定义结构体指针
	SingleList* P_Head = NULL;

	//循环添加节点
	for (int i = 0; i < N; i++)
	{
		//尾部添加节点
		PushBack(&P_Head, i);
	}

	//显示链表状态（插入节点之前）
	Show(P_Head);

	DeleteNode(&P_Head, 0);
	DeleteNode(&P_Head, 5);
	DeleteNode(&P_Head, 9);

	Show(P_Head);
#endif

/************************统计链表节点************************/
#if 0
		//定义结构体指针
	SingleList* P_Head = NULL;

	//循环添加节点
	for (int i = 0; i < N*N; i++)
	{
		//尾部添加节点
		PushBack(&P_Head, i);
	}

	//显示链表状态（插入节点之前）
	Show(P_Head);
	printf("该链表合计\t%u\t个节点\n", CounterNode(P_Head));
#endif

/************************修改链表节点************************/
#if 0

			//定义结构体指针
	SingleList* P_Head = NULL;

	//循环添加节点
	for (int i = 0; i < N; i++)
	{
		//尾部添加节点
		PushBack(&P_Head, i);
	}

	//显示链表状态（插入节点之前）
	Show(P_Head);
	
	Modification(P_Head, 0, 100);
	Modification(P_Head, 5, 100);
	Modification(P_Head, 9, 100);

	Show(P_Head);
#endif

/************************获取链表的中间节点************************/
#if 0
		//定义结构体指针
	SingleList* P_Head = NULL;

	//循环添加节点
	for (int i = 0; i < N; i++)
	{
		//尾部添加节点
		PushBack(&P_Head, i);
	}

	//显示链表状态（插入节点之前）
	Show(P_Head);

	printf("中间节点：%d\n",(GetMiddleNode(P_Head))->Data);
#endif

/************************链表合并************************/	
#if 0

	SingleList* P_All=NULL;
	SingleList* P_Head1 = NULL;
	SingleList* P_Head2 = NULL;

	for (int i = 0; i <10; i++)
	{
		
		if (i % 2)
		{
			PushBack(&P_Head2, i);
		}
		else
		{
			PushBack(&P_Head1, i);
		}
	}

	Show(P_Head1);
	Show(P_Head2);

	Merge(&P_All, P_Head1, P_Head2);
	Show(P_All);
#endif

/************************销毁链表************************/
#if 0
		//定义结构体指针
	SingleList* P_Head = NULL;

	//循环添加节点
	for (int i = 0; i < N; i++)
	{
		//尾部添加节点
		PushBack(&P_Head, i);
	}

	//显示链表状态（插入节点之前）
	Show(P_Head);

	Destory(&P_Head);

	Show(P_Head);
#endif

/************************链表反转（循环）************************/
#if 0
		//定义结构体指针
	SingleList* P_Head = NULL;

	//循环添加节点
	for (int i = 0; i < N; i++)
	{
		//尾部添加节点
		PushBack(&P_Head, i);
	}

	//显示链表状态（插入节点之前）
	Show(P_Head);
	ReversalByLoop(&P_Head);
	Show(P_Head);
#endif


/************************链表反转（递归）************************/
#if 0
		//定义结构体指针
	SingleList* P_Head = NULL;

	//循环添加节点
	for (int i = 0; i < N; i++)
	{
		//尾部添加节点
		PushBack(&P_Head, i);
	}

	//显示链表状态（插入节点之前）
	Show(P_Head);
	P_Head= ReversalByRecursion(P_Head);
	Show(P_Head);
#endif

/************************冒泡排序************************/
#if 0

	//获取随机数种子
	srand((unsigned int)time(NULL));

	//定义结构体指针
	SingleList* P_Head = NULL;
	
	//循环添加节点
	for (int i = 0; i < N; i++)
	{
		//尾部添加节点
		PushBack(&P_Head, rand()%100);
	}
	//显示链表状态
	Show(P_Head);
	BubbleSort(P_Head);
	Show(P_Head);
#endif

/************************快速排序************************/
#if 0
 

	//获取随机数种子
	srand((unsigned int)time(NULL));

	//定义结构体指针
	SingleList* P_Head = NULL;

	//循环添加节点
	for (int i = 0; i < N; i++)
	{
		//尾部添加节点
		PushBack(&P_Head, rand() % 100);
	}
	//显示链表状态
	Show(P_Head);
	QuickSort(P_Head,NULL);
	Show(P_Head);
#endif


/************************选择排序************************/
#if 1

	//获取随机数种子
	srand((unsigned int)time(NULL));

	//定义结构体指针
	SingleList* P_Head = NULL;

	//循环添加节点
	for (int i = 0; i < N; i++)
	{
		//尾部添加节点
		PushBack(&P_Head, rand() % 100);
	}

	//显示链表状态
	Show(P_Head);
	SelectSort(P_Head);
	Show(P_Head);
#endif
	system("pause");
}

SingleList.h

#pragma once 


#ifdef __cplusplus
extern"C"
{
#endif

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

	typedef int DataType;

	typedef struct SingleList
	{
		DataType Data;
		struct SingleList* P_Next;
	}SingleList;



	//显示链表状态
	void Show(SingleList* P_Head);
	//初始化节点
	void InitNode(SingleList* P_Node, DataType Data);
	//数据交换
	void Swap(SingleList* Pa, SingleList*  Pb);
	//链表分段
	SingleList* Segmentaction(SingleList* P_Begin, SingleList* P_End);
	
	//尾部追加节点
	void PushBack(SingleList** PP_Head, DataType Data);
	//头部添加节点
	void PushHead(SingleList** PP_Head,DataType Data);
	//查找指定节点
	SingleList* FindNode(SingleList* P_Head, DataType FindData);
	//将节点插入指定位置
	void InsertNode(SingleList** PP_Head, DataType Rear, DataType InsData);
	//删除指定节点
	void DeleteNode(SingleList** PP_Head, DataType Data);
	//修改链表节点
	void Modification(SingleList* P_Head, DataType OldData, DataType NewData);
	//统计链表节点
	unsigned int CounterNode(SingleList*P_Head);
	//获取链表的中间节点
	SingleList* GetMiddleNode(SingleList* P_Head);
	//链表合并
	void Merge(SingleList** PP_ALL, SingleList* P_Head1, SingleList* P_Head2);
	//销毁链表
	void Destory(SingleList** PP_Head);
	//链表反转（循环）
	void ReversalByLoop(SingleList** PP_Head);
	//链表反转 （递归）
	SingleList* ReversalByRecursion(SingleList* P_Head);
	//冒泡排序
	void BubbleSort(SingleList* P_Head);
	//快速排序
	void QuickSort(SingleList* P_Begin, SingleList* P_End);
	//选择排序
	void SelectSort(SingleList* P_Head);
#ifdef __cplusplus
}
#endif

SingleList.c

#include "SingleList.h"



//显示链表状态
void Show(SingleList* P_Head)
{
	//如果“P_Head”为空就直接跳出
	if (NULL == P_Head)
	{
		puts("");
		return;
	}
	else
	{
		//顺序打印
		printf("%p\t%p\t%d\n",P_Head,P_Head->P_Next,P_Head->Data);
		Show(P_Head->P_Next);
		//逆序打印
		//printf("%p\t%p\t%d\n", P_Head, P_Head->P_Next, P_Head->Data);
	}

}

//初始化节点
void InitNode(SingleList* P_Node, DataType Data)
{
	//下一个节点为空
	P_Node->P_Next = NULL;
	//初始化该节点的“Data”
	P_Node->Data = Data;
}

//数据交换
void Swap(SingleList* Pa, SingleList*  Pb)
{
	DataType Temp = Pa->Data;
	Pa->Data = Pb->Data;
	Pb->Data = Temp;
}

//链表分段
SingleList* Segmentaction(SingleList* P_Begin, SingleList* P_End)
{
	//备份数据
	DataType Key = P_Begin->Data;
	//起始点
	SingleList* Pi = P_Begin;

	for (SingleList* Pj = Pi->P_Next; Pj != P_End; Pj = Pj->P_Next)
	{
		if (Key < Pj->Data)
		{
			Pi = Pi->P_Next;
			Swap(Pi, Pj);
		}
	}

	//交换中间节点，让左边的小于“Key”右边的大于“Key”
	Swap(Pi, P_Begin);

	return Pi;
}


//尾部追加节点
void PushBack(SingleList** PP_Head, DataType Data)
{
	//如果头节点为空
	if (NULL == *PP_Head)
	{
		//创建一个节点
		SingleList* P_New=(SingleList*)malloc(sizeof(SingleList));
		//初始化节点
		InitNode(P_New, Data);
		//直接让“*PP_Head”指向“P_New”
		*PP_Head = P_New;
	}
	else
	{
		//头节点不为空

		//创建节点
		SingleList* P_New = (SingleList*)malloc(sizeof(SingleList));
		InitNode(P_New, Data);

		//备份头节点
		SingleList* P_Bak = *PP_Head;
		
		//因为要将最后一个节点指向新的节点，所以要循环
		//到倒数第二个节点
		while (NULL != P_Bak->P_Next)
		{
			P_Bak = P_Bak->P_Next;
		}

		P_Bak->P_Next = P_New;
	}
}
//头部添加节点
void PushHead(SingleList** PP_Head, DataType Data)
{
	//如果头节点为空
	if (NULL == *PP_Head)
	{
		//创建一个新的节点
		SingleList* P_New = (SingleList*)malloc(sizeof(SingleList));

		//初始化新节点
		InitNode(P_New, Data);

		//直接让“*PP_Head”指向“P_New”
		*PP_Head = P_New;
	}
	else
	{
		//头节点不为空

		//创建一个新节点
		SingleList* P_New = (SingleList*)malloc(sizeof(SingleList));
		//初始化新节点
		InitNode(P_New, Data);

		//直接让“P_New->PNext”指向头节点
		P_New->P_Next = *PP_Head;

		//重新定义头节点，让“*PP_Head”指向“P_New”
		*PP_Head = P_New;
	}
}

//查找指定节点
SingleList* FindNode(SingleList* P_Head, DataType FindData)
{
	//循环遍历节点
	while (NULL != P_Head)
	{
		//穷举
		if (FindData == P_Head->Data)
		{
			//返回相对应的节点地址
			return P_Head;
		}
		P_Head = P_Head->P_Next;
	}
	//如果没有找到返回“NULL”
	return NULL;
}

//将节点插入指定位置
void InsertNode(SingleList** PP_Head, DataType Rear, DataType InsData)
{
	//插入之前先查找该该节点是否存在
	SingleList* P_Res = FindNode(*PP_Head, Rear);

	//如何没找到，那还插个毛啊 -_-|||
	if (NULL == P_Res)
	{
		return;
	}
	else
	{
		//如果找到了就创建一个节点先
		SingleList* P_New = (SingleList*)malloc(sizeof(SingleList));
		//初始化节点
		InitNode(P_New, InsData);
		
		 if(NULL == P_Res->P_Next)	
		{
			//如果“P_Res->P_Next==NULL”说明“P_Res”在倒数
			//第二个节点

			//让“P_Res->P_Nex”指向“P_New”
			P_Res->P_Next = P_New;
		}
		else 
		{
	
			P_New->P_Next = P_Res->P_Next;
			P_Res->P_Next = P_New;
		}
		
	}

}

//删除指定节点
void DeleteNode(SingleList** PP_Head, DataType Data)
{
	//删除之前先查找
	SingleList* P_Res = FindNode(*PP_Head, Data);

	//如果没有找到，那还删个毛啊
	if (NULL == P_Res)
	{
		return;
	}
	else
	{
	
		if (P_Res == *PP_Head)
		{
			//如果“P_Res”等于“*PP_Head”

			//让头节点指向下一个节点
			*PP_Head = (*PP_Head)->P_Next;

			//释放内存
			free(P_Res);
			//避免野指针
			P_Res = NULL;
		}
		
		else
		{
			//当“P_Res”在首尾节点之间

			//循环到“P_Res”的上一个节点
			//备份头指针
			SingleList* P_Bak = *PP_Head;

			while (P_Bak->P_Next!=P_Res)
			{
				//趋于终止
				P_Bak = P_Bak->P_Next;
			}

			//删除节点
			P_Bak->P_Next = P_Res->P_Next;

			//释放内存
			free(P_Res);
			//避免野指针
			P_Res = NULL;
		}
	}
}

//修改链表节点
void Modification(SingleList* P_Head, DataType OldData, DataType NewData)
{
	//修改之前先查找
	SingleList* P_Res = FindNode(P_Head,OldData);
	
	//如果没找到，那还改个毛啊-_-|||
	if (NULL == P_Res)
	{
		//直接返回
		return;
	}
	else
	{
		P_Res->Data = NewData;
	}

}

//统计链表节点
unsigned int CounterNode(SingleList*P_Head)
{
	if (NULL == P_Head)
	{
		return 0;
	}
	return 1 + CounterNode(P_Head->P_Next);
}

//获取链表的中间节点
SingleList* GetMiddleNode(SingleList* P_Head)
{
	//当头节点为空或者只有一个节点的情况
	if (NULL == P_Head || NULL == P_Head->P_Next)
	{
		//直接返回
		return P_Head;
	}
	
	SingleList* Pi=P_Head;
	SingleList* Pj=P_Head;

	while (NULL != Pi->P_Next)
	{
		Pi = Pi->P_Next;
		Pj = Pj->P_Next;

		if (NULL != Pi->P_Next)
		{
			Pi = Pi->P_Next;
		}
	}
	return Pj;
}

//链表合并
void Merge(SingleList** PP_ALL, SingleList* P_Head1, SingleList* P_Head2)
{

	while (NULL != P_Head1 || NULL != P_Head2)
	{
		if (NULL != P_Head1 && NULL != P_Head2)
		{
			//对比数据大小,插入合适的位置
			if (P_Head1->Data < P_Head2->Data)
			{
				PushBack(PP_ALL, P_Head1->Data);
				P_Head1 = P_Head1->P_Next;
			}
			else
			{
				PushBack(PP_ALL, P_Head2->Data);
				P_Head2 = P_Head2->P_Next;
			}		
		}
		else
		{
			//循环添加节点
			while (NULL != P_Head1)
			{
				PushBack(PP_ALL, P_Head1->Data);
				P_Head1 = P_Head1->P_Next;
			}

			//循环添加节点
			while (NULL != P_Head1)
			{
				PushBack(PP_ALL, P_Head2->Data);
				P_Head2 = P_Head2->P_Next;
			}
			break;
		}
	}
}

//销毁链表
void Destory(SingleList** PP_Head)
{

	while (*PP_Head != NULL)
	{
		SingleList* Pi = *PP_Head;
		*PP_Head = (*PP_Head)->P_Next;

		if (NULL == *PP_Head)
		{
			break;
		}

		//释放内存
		free(Pi);
		//避免野指针
		Pi = NULL;
	}
}

//链表反转（循环）
void ReversalByLoop(SingleList** PP_Head)
{
	//如果头指针为空或者只有一个节点
	if (NULL == *PP_Head || NULL == (*PP_Head)->P_Next)
	{
		return;
	}
	else
	{
		//上一个指针，中间节点，下一个节点
		SingleList* P_Pre, *P_Cur, *P_Next;
		P_Pre=P_Cur=P_Next= NULL;

		//保存头指针
		P_Pre = *PP_Head;
		//保存下一节点
		P_Cur = (*PP_Head)->P_Next;
		while (NULL != P_Cur)
		{
			//轮替
			P_Next = P_Cur->P_Next;
			P_Cur->P_Next = P_Pre;
			P_Pre = P_Cur;
			P_Cur = P_Next;
		}
		
		//尾部为空
		(*PP_Head)->P_Next= NULL;
		//定义新的头节点
		*PP_Head = P_Pre;
	}
}

//链表反转 （递归）
SingleList* ReversalByRecursion(SingleList* P_Head)
{
	//如果头指针为空或者只有一个节点
	if (NULL == P_Head || NULL == P_Head->P_Next)
	{
		return P_Head;
	}
	else
	{
		//保存第二个节点的地址
		SingleList* P_Next = P_Head->P_Next;
		//递归调用
		SingleList* P_NewHead = ReversalByRecursion(P_Next);

		P_Next->P_Next = P_Head;
		P_Head->P_Next = NULL;

		//返回新的头节点地址
		return P_NewHead;
	}
}
//冒泡排序
void BubbleSort(SingleList* P_Head)
{
	for (SingleList* Pi = P_Head; NULL != Pi; Pi = Pi->P_Next)
	{
		//每冒泡一次就有一个极值沉底
		for (SingleList* Pj = Pi->P_Next; NULL != Pj; Pj = Pj->P_Next)
		{
			if (Pi->Data < Pj->Data)
			{
				//数据交换
				Swap(Pi,Pj);
			}
		}
			
	}
}

//快速排序
void QuickSort(SingleList* P_Begin, SingleList* P_End)
{
	if (P_Begin != P_End)
	{
		SingleList* Pi = Segmentaction(P_Begin, P_End);
		//分割左边
		QuickSort(P_Begin, Pi);
		//分割右边
		QuickSort(Pi->P_Next, P_End);
	}

}

//选择排序
void SelectSort(SingleList* P_Head)
{
	//保存极值的节点地址
	SingleList* P_Limit = NULL;

	for (SingleList* Pi = P_Head; NULL != Pi; Pi = Pi->P_Next)
	{
		//假设“Pi”为极值的节点
		P_Limit = Pi;
		for (SingleList* Pj = Pi->P_Next; NULL != Pj; Pj = Pj->P_Next)
		{
			if (P_Limit->Data < Pj->Data)
			{
				//如果“P_Limit->Data < Pj->Data”就让“P_Limit”保存“Pj”的地址
				P_Limit = Pj;
				P_Limit = Pj;
			}
		}
		//如果“P_Limit”不等于“Pi”,说明“P_Limit”已经存储了其他极值
		//交换数据
		Swap(P_Limit, Pi);
	}
}
阿信coder
关注
专栏目录
数据结构（三） -- C语言版 -- 线性表的链式存储 - 单链表
青椒*^_^*凤爪爪的博客
03-12 9257
本文中没有涉及到很多的相关理论知识，也没有做深入的了解，所以，您如果是想要系统的学习、想要多学习关于理论的知识等，那么本文可能并不合适您。 本文中所有设计的代码均通过测试，并且在功能性方面均实现应有的功能。 设计的代码并非全部公开，部分无关紧要代码并没有贴出来。 如果你也对此感兴趣、也想测试源码的话，可以私聊我，非常欢迎一起探讨学习。 由于时间、水平、精力有限，文中难免会出现不准确、甚至错误的地方，也很欢迎大佬看见的话批评指正。 嘻嘻。。。。 。。。。。。。。收！
单链表由易到难
Chinanjing的博客
12-26 298
无头节点的单链表的简单、复杂操作。 声明 本文针对的是无头结点的单链表， 而下文所出现的头结点所表示的指的是单链表的第一个结点。文中可能出现语句不当的情况，但绝不会影响读者对本文的理解，请以宽容、乐观的心态放心地阅读本文。文中可能会出现一些错误，在此提前向读者致以歉意，并欢迎在评论区留言指正！ 说在前面 单链表比起双链表，其复杂性较低，减少了从后向前的指针变量，只有一个从前往后的指针变量，导致单链...
Python如何创建一个单链表，以及实现单链表的增，删，改，查操作，以及对单链表的排序功能
Idoit_z的博客
07-02 1489
标题Python如何创建一个单链表，以及实现单链表的增，删，改，查操作，以及对单链表的排序功能 #功能: 实现单链表的构建和功能操作 #定义单链表的类 class Node: """ 思路:将自定义的类视为节点的生成类,实例对象中 包含数据部分和指向下一个节点的next """ def __init__(self, val, next=None...
数据结构与算法之单链表(增{包含增序增加}、删、改、查、链表反转、有序链表合并{包含递归和非递归两种方式})
qq_35671159的博客
05-29 254
直接上代码吧，后面再总结一下： public class SinglyLinkedList { // 头节点 private final Node headNode = new Node(0, "", ""); /** * 添加节点 * * @param newNode 新节点 */ public void add(Node newNode) { Node temp = headNode; whi
java单链表实现增删改_java实现单链表的增删改查、反转、合并有序单链表
weixin_35705874的博客
03-08 132
1、非递归创建单链表public static LinkedNode createLinked(List list) {LinkedNode head = null;LinkedNode temp = null;for (int i = 0; i < list.size(); i++) {LinkedNode linkedNode = new LinkedNode(list.get(i));...
python链表的创建_Python如何创建一个单链表，以及实现单链表的增，删，改，查操作，以及对单链表的排序功能...
weixin_40006963的博客
11-23 201
标题Python如何创建一个单链表，以及实现单链表的增，删，改，查操作，以及对单链表的排序功能#功能:实现单链表的构建和功能操作#定义单链表的类class Node:"""思路:将自定义的类视为节点的生成类,实例对象中包含数据部分和指向下一个节点的next"""def __init__(self, val, next=None):self.val = val # 有用数据self.next = ...
链表 第一部分：单向链表增删改反转合并等
笔记别偷看
10-06 513
链表 链表(Linked List)介绍 链表是有序的列表，但是它在内存中是存储如下： 小结上图: 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域：存数据的， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表 逻辑结构 单链表(带头结点) 逻辑结构示意图如下： 单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理 完成对英雄人物的增删改查操作， 注: 删除和修改,查找
C语言课程设计-黑白棋AI游戏源码.zip
11-12
在这个"C语言课程设计-黑白棋AI游戏源码.zip"压缩包中，我们主要探讨的是一个用C语言编写的黑白棋（也称为翻转棋或奥赛罗棋）的人工智能游戏。黑白棋是一种双人对弈策略游戏，其规则简单但策略深度丰富，非常适合...
C语言写的带有头结点的链表
04-03
本文将详细讨论“带有头结点的链表”这一主题，包括它的实现、翻转和销毁过程，以及如何在实际代码中进行测试。 首先，让我们理解什么是头结点。在链表中，头结点是一个特殊的节点，它不存储任何数据，但作为链表的...
【二叉树】单值、最大深度、构建、节点（叶子）个数、前、中、后序遍历、层序遍历、是否完全、是否相同、对称、另一颗树的子树、翻转
knous
04-11 570
二叉树题目练习
数据结构与算法_1.稀疏数组和队列_2
Jack_ZZF的博客
03-10 166
1.2 队列 单链表
C语言实现单链表的创建、增、删、改、查、逆序、冒泡排序
weixin_49061985的博客
08-27 310
链表相关操作： //创建一个链表，并进行增删改查 定义结构体： typedef struct Node { int data; struct Node *next; }Linklist; 1.主函数相关调用语句 int main() { int num=0; Linklist * phead=NULL; puts("请输入需要创建的节点数"); scanf("%d",&num); create_list(&phead,num); //通过指针的指针进行头指针的改变 tra
数据结构--单向链表及其增、删、改、查、排序等操作的实现（C语言）
羟基与苯的博客
04-10 2583
文章目录🎃链表🎃单向链表的实现（C语言）📌结点类型描述📌1.创建初始化一个链表结点📌2.从链表尾部插入数据📌3.链表遍历打印📌4.查找链表：按结点序号查找📌5.查找链表：按数据内容查找📌6.在任意位置插入一个数据📌7.删除链表：按结点序号删除📌8.删除链表：按数据内容删除📌9.free释放内存📌10.求链表数据个数🎃单向链表总结 本章内容：单链表的概念；单链表结点模型；单链表的各运算实现。 本文涉及实现单链表完整代码已提交至码云Gitee中，供读者参考。 🎃链表 我们之前实现了数据结构中第一个结构–顺序
【C语言】单链表的增查
cute_Niu的博客
09-19 247
单链表的基本操作 初始化 void SListInit(SListNode **ppFirst) { assert(ppFirst != NULL); *ppFirst = NULL; } 从头部插入 首先需要开辟空间，因为在以后的操作中还需要动态开辟空间故把开辟空间独立封装为一个函数。 开辟空间函数 static SListNode* CreatNode(DataType data) { ...
c语言单链表销毁、清空
qq_42449028的博客
08-02 2591
清空指从首元结点开始删除每一个结点，并将头结点的next指针置为null。由于头结点不能删除，所以删除时循环需从首元结点开始，最后对头结点做单独置空。销毁指从头结点开始删除每一个结点。...
C语言-单链表的摧毁
weixin_56988709的博客
02-15 2695
SLNode* destroy(SLNode *head) { SLNode *p,*q; p=head->next; head->next=NULL; q=NULL; while(q!=NULL) { q=p; p=p->next; free(q); q=NULL; } printf("sucess!"); }
C语言链表——增删改查
最新发布
weixin_54859557的博客
03-20 2878
链表是一种数据结构，是一种数据存放的思想
C语言 链表的增删改查
TorchCqs的博客
11-22 1609
题目：利用C或C++语言实现一个长度为N的int型单链表，包括链表的定义、建立、指定位置增减以及长度查询等操作。 #include<stdio.h> #include<stdlib.h> #define N 10 struct Link { int data; struct Link *next; }; int length = 0; // 用来存放链表长度 /** * head: 数据链表 * index: 插入的位置 * data: 插入的数据 **/ str
史上最全单链表的增删改查反转等操作汇总以及5种排序算法(C语言)
热门推荐
嵌入式与Linux那些事的博客
04-01 1万+
1.准备工作 首先包含头文件，定义链表结构体，产生随即链表的范围，定义全局头尾节点。 #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX 10 /*定义链表*/ typedef struct Node { int data; struct Node *ne...
C语言实现链表操作：增删改查
在C语言中，链表是一种非常重要的数据结构，它不像数组那样需要预先分配连续的内存空间，而是由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在本资源中，作者定义了一个名为`Student`的结构体，用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值