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

其他 2018-12-08 15:02:02 阅读次数: 0

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

Main.c

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


void main()
{

	/*****************尾部添加节点*****************/
#if 0
	S_List* P_Head = NULL;
	for (int i = 0; i < 10; i++)
	{
		AddBack(&P_Head, i);
	}
	Show(P_Head);
#endif

	/*****************头部添加节点*****************/
#if 0
	S_List* P_Head = NULL;
	for (int i = 0; i < 10; i++)
	{
		AddHead(&P_Head, i);
	}
	Show(P_Head);
#endif

	/*****************查找节点*****************/
#if 0
	S_List* P_Head = NULL;
	for (int i = 0; i < 10; i++)
	{
		AddHead(&P_Head, i);
	}
	Show(P_Head);

	if (NULL != FindNode(P_Head,0) && NULL != FindNode(P_Head, 5) && NULL != FindNode(P_Head, 9))
	{
		puts("Find.");
	}
	else
	{
		puts("Can't find.");
	}
#endif
	
	/*****************指定位置插入节点*****************/
#if 0
	S_List* P_Head = NULL;
	for (int i = 0; i < 10; i++)
	{
		AddHead(&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
	S_List* P_Head = NULL;
	for (int i = 0; i < 10; i++)
	{
		AddHead(&P_Head, i);
	}

	Show(P_Head);
	DeleteNode(&P_Head, 0);
	DeleteNode(&P_Head, 5);
	DeleteNode(&P_Head, 9);
	Show(P_Head);
#endif

	/*****************修改节点*****************/
#if 0
	S_List* P_Head = NULL;
	for (int i = 0; i < 10; i++)
	{
		AddHead(&P_Head, i);
	}

	Show(P_Head);
	Modeifier(P_Head, 0,100);
	Modeifier(P_Head, 5,100);
	Modeifier(P_Head, 9,100);
	Show(P_Head);
#endif

	/*****************修改节点*****************/
#if 0
	S_List* P_Head = NULL;
	for (int i = 0; i < 100; i++)
	{
		AddHead(&P_Head, i);
	}

	Show(P_Head);
	printf("该链表有 %u 个节点\n", CounteNode(P_Head));
#endif

	/*****************链表合并*****************/
#if 0
	S_List* P_Head1 = NULL;
	S_List* P_Head2 = NULL;
	S_List* P_All = NULL;

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

	AddBack(&P_Head1, 520);
	AddBack(&P_Head1, 1314);

	Show(P_Head1);

	Show(P_Head2);

	Merge(&P_All, P_Head1, P_Head2);
	Show(P_All);
#endif
	
	/*****************翻转链表（循环）*****************/
#if 0
	S_List* P_Head = NULL;
	for (int i = 0; i < 10; i++)
	{
		AddBack(&P_Head, i);
	}

	Show(P_Head);
	ReversalByLoop(&P_Head);
	Show(P_Head);
#endif

	/*****************翻转链表（递归）*****************/
#if 0
	S_List* P_Head = NULL;
	for (int i = 0; i < 10; i++)
	{
		AddBack(&P_Head, i);
	}

	Show(P_Head);
	P_Head=ReversalByRecursion(P_Head);
	Show(P_Head);
#endif

	/*****************销毁链表*****************/
#if 0
	S_List* P_Head = NULL;
	for (int i = 0; i < 10; i++)
	{
		AddBack(&P_Head, i);
	}

	Show(P_Head);
	Destroy(&P_Head);
	Show(P_Head);
#endif

	/*****************获取中间节点*****************/
#if 0
	S_List* P_Head = NULL;
	for (int i = 0; i < 10; i++)
	{
		AddBack(&P_Head, i);
	}

	Show(P_Head);
	printf("中间节点：%d\n", GetMiddleNode(P_Head)->Data);
#endif
	
	/*****************冒泡排序*****************/
#if 0
	srand((unsigned int)time(NULL));

	S_List* P_Head = NULL;
	for (int i = 0; i < 10; i++)
	{
		AddBack(&P_Head, rand()%100);
	}

	Show(P_Head);
	BubbleSort(P_Head);
	Show(P_Head);
#endif

	/*****************快速排序*****************/
#if 0
	srand((unsigned int)time(NULL));

	S_List* P_Head = NULL;
	for (int i = 0; i < 10; i++)
	{
		AddBack(&P_Head, rand() % 100);
	}

	Show(P_Head);
	QuickSort(P_Head,NULL);
	Show(P_Head);
#endif

	/*****************选择排序*****************/
#if 1
	srand((unsigned int)time(NULL));

	S_List* P_Head = NULL;
	for (int i = 0; i < 10; i++)
	{
		AddBack(&P_Head, rand() % 100);
	}

	Show(P_Head);
	SelectSort(P_Head);
	Show(P_Head);
#endif
	system("pause");
}

S_List.h

#pragma once 


#ifdef __cplusplus
extern "C"
{
#endif

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

	typedef int DataType;
	
	typedef struct S_List
	{
		DataType Data;
		struct S_List* P_Next;
	}S_List;

	//初始节点
	void InitNode(S_List* P_Node);
	//显示链表状态
	void Show(S_List* P_Head);
	//尾部添加节点
	void AddBack(S_List** PP_Head, DataType Data);
	//头部添加节点
	void AddHead(S_List** PP_Head, DataType Data);
	//查找节点
	S_List* FindNode(S_List* P_Head, DataType Data);
	//指定位置插入节点
	void InsertNode(S_List** PP_Head, DataType InData, DataType InsData);
	//删除节点
	void DeleteNode(S_List** PP_Head, DataType DelData);
	//修改节点
	void Modeifier(S_List* P_Head, DataType OldData, DataType NewData);
	//统计链表节点
	unsigned int CounteNode(S_List* P_Head);
	//链表合并
	void Merge(S_List** PP_All, S_List* P_Head1, S_List* P_Head2);
	//翻转链表（循环）
	void ReversalByLoop(S_List** PP_Head);
	//翻转链表（递归）
	S_List* ReversalByRecursion(S_List* P_Head);
	//销毁链表
	void Destroy(S_List** PP_Head);
	//获取中间节点
	S_List* GetMiddleNode(S_List* P_Head);
	//冒泡排序
	void BubbleSort(S_List* P_Head);
	//快速排序
	void QuickSort(S_List* P_Begin, S_List* P_End);
	//选择排序
	void SelectSort(S_List* P_Head);
	//数据交换（辅助排序）
	void Swap(S_List* Pa, S_List* Pb);
	//链表分段（辅助快速排序）
	S_List* Segmentation(S_List* P_Begin, S_List* P_End);
#ifdef __cplusplus
}
#endif

S_LIst.c

#include "S_List.h"


//初始节点
void InitNode(S_List* P_Node)
{
	P_Node->P_Next = NULL;
	P_Node->Data = 0;
}

//显示链表状态
void Show(S_List* 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);
	}
}

//尾部添加节点
void AddBack(S_List** PP_Head, DataType Data)
{
	S_List* P_New = (S_List*)malloc(sizeof(S_List));
	InitNode(P_New);
	P_New->Data = Data;

	if (NULL == *PP_Head)
	{
		*PP_Head = P_New;
	}
	else
	{
		S_List* P_Bak = *PP_Head;

		while (NULL != P_Bak->P_Next)
		{
			P_Bak = P_Bak->P_Next;
		}
		P_Bak->P_Next = P_New;
	}
}

//头部添加节点
void AddHead(S_List** PP_Head, DataType Data)
{
	S_List* P_New = (S_List*)malloc(sizeof(S_List));
	InitNode(P_New);
	P_New->Data = Data;

	if (NULL == PP_Head)
	{
		*PP_Head = P_New;
	}
	else
	{
		P_New->P_Next = *PP_Head;
		*PP_Head = P_New;
	}
}

//查找节点
S_List* FindNode(S_List* P_Head, DataType Data)
{
	if (NULL == P_Head)
	{
		return NULL;
	}
	else
	{
		while (NULL != P_Head)
		{
			if (Data == P_Head->Data)
			{
				return P_Head;
			}
			P_Head = P_Head->P_Next;
		}
	}
	return NULL;
}

//指定位置插入节点
void InsertNode(S_List** PP_Head, DataType InData, DataType InsData)
{
	if (NULL != *PP_Head)
	{
		S_List* P_Res = FindNode(*PP_Head, InData);
		if (NULL != P_Res)
		{
			S_List* P_New = (S_List*)malloc(sizeof(S_List));
			InitNode(P_New);
			P_New->Data = InsData;
			S_List* P_Bak = NULL;

			if (P_Res == *PP_Head)
			{
				P_Bak = P_Res->P_Next;
				P_Res->P_Next = P_New;
				P_New->P_Next = P_Bak;
			}
			else if (NULL==P_Res->P_Next)
			{
				P_Res->P_Next = P_New;
			}
			else
			{
				P_Bak = P_Res->P_Next;
				P_Res->P_Next = P_New;
				P_New->P_Next = P_Bak;
			}
		}
	}
}

//删除节点
void DeleteNode(S_List** PP_Head, DataType DelData)
{
	if (NULL != *PP_Head)
	{
		S_List* P_Res = FindNode(*PP_Head, DelData);
		if (NULL != P_Res)
		{
			if (*PP_Head == P_Res)
			{
				*PP_Head = (*PP_Head)->P_Next;
				free(P_Res);
				P_Res = NULL;
			}
			else
			{
				S_List* P_Bak = *PP_Head;
				while (P_Res != P_Bak->P_Next)
				{
					P_Bak = P_Bak->P_Next;
				}
				P_Bak->P_Next = P_Res->P_Next;
				free(P_Res);
				P_Res = NULL;
			}
		}
	}
}
//修改节点
void Modeifier(S_List* P_Head, DataType OldData, DataType NewData)
{
	if (NULL != P_Head)
	{
		S_List* P_Res = FindNode(P_Head, OldData);
		if (NULL != P_Res)
		{
			P_Res->Data = NewData;
		}
	}
}

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

//链表合并
void Merge(S_List** PP_All, S_List* P_Head1, S_List* P_Head2)
{
	while (NULL != P_Head1||NULL != P_Head2)
	{
		if (NULL != P_Head1&&NULL != P_Head2)
		{
			if (P_Head1->Data < P_Head2->Data)
			{
				AddBack(PP_All, P_Head1->Data);
				P_Head1 = P_Head1->P_Next;
			}
			else
			{
				AddBack(PP_All, P_Head2->Data);
				P_Head2 = P_Head2->P_Next;
			}
		}
		else
		{
			while (NULL != P_Head1)
			{
				AddBack(PP_All, P_Head1->Data);
				P_Head1 = P_Head1->P_Next;
			}

			while (NULL != P_Head2)
			{
				AddBack(PP_All, P_Head2->Data);
				P_Head2 = P_Head2->P_Next;
			}
		}
	}
}

//翻转链表（循环）
void ReversalByLoop(S_List** PP_Head)
{
	if (NULL == *PP_Head || NULL == (*PP_Head))
	{
		return;
	}
	else
	{
		S_List* P_Pre, *P_Cur, *P_Next;

		P_Pre = P_Cur = P_Next = NULL;

		P_Pre = *PP_Head;
		P_Cur = *PP_Head;

		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;

	}
}

//翻转链表（递归）
S_List* ReversalByRecursion(S_List* P_Head)
{
	if (NULL == P_Head || NULL == P_Head->P_Next)
	{
		return P_Head;
	}
	else
	{
		S_List* P_Next = P_Head->P_Next;
		S_List* P_NewHead = ReversalByRecursion(P_Next);
		P_Next->P_Next = P_Head;
		P_Head->P_Next = NULL;
		return P_NewHead;
	}
}

//销毁链表
void Destroy(S_List** PP_Head)
{
	if (NULL == *PP_Head)
	{
		return;
	}
	else
	{

		S_List* P_Bak = (*PP_Head)->P_Next;
		while (NULL != P_Bak)
		{
			S_List* P_Bak2 = P_Bak;
			P_Bak = P_Bak->P_Next;
			free(P_Bak2);
			P_Bak2 = NULL;
		}

		free(*PP_Head);
		*PP_Head = NULL;
	}

}

//获取中间节点
S_List* GetMiddleNode(S_List* P_Head)
{
	if (NULL == P_Head || NULL == P_Head->P_Next)
	{
		return P_Head->P_Next;
	}
	else
	{
		S_List* P1 = P_Head;
		S_List* P2 = P_Head;

		while (NULL != P2->P_Next)
		{
			P1 = P1->P_Next;
			P2 = P2->P_Next;

			if (NULL != P2->P_Next)
			{
				P2 = P2->P_Next;
			}
		}
		return P1;
	}
	return NULL;
}

//冒泡排序
void BubbleSort(S_List* P_Head)
{
	for (S_List* Pi = P_Head; NULL != Pi; Pi = Pi->P_Next)
	{
		for (S_List* Pj = Pi->P_Next; NULL != Pj; Pj = Pj->P_Next)
		{
			if (Pi->Data < Pj->Data)
			{
				Swap(Pi, Pj);
			}
		}
	}
}

//快速排序
void QuickSort(S_List* P_Begin, S_List* P_End)
{
	if (P_Begin != P_End)
	{
		S_List* Pi = Segmentation(P_Begin, P_End);
		QuickSort(P_Begin, Pi);
		QuickSort(Pi->P_Next, P_End);
	}
}

//选择排序
void SelectSort(S_List* P_Head)
{
	S_List* P_Max=NULL;

	for (S_List* Pi = P_Head; NULL != Pi; Pi = Pi->P_Next)
	{
		P_Max = Pi;
		for (S_List* Pj = Pi->P_Next; NULL != Pj; Pj = Pj->P_Next)
		{
			if (P_Max->Data < Pj->Data)
			{
				P_Max = Pj;
			}
		}
		if (P_Max!=Pi)
		{
			Swap(P_Max, Pi);
		}
	}
}
//数据交换（辅助排序）
void Swap(S_List* Pa, S_List* Pb)
{
	DataType Temp = Pa->Data;
	Pa->Data = Pb->Data;
	Pb->Data = Temp;
}

//链表分段（辅助快速排序）
S_List* Segmentation(S_List* P_Begin, S_List* P_End)
{
	DataType Key = P_Begin->Data;
	S_List* Pi = P_Begin;
	S_List* Pj = Pi->P_Next;

	while (Pj != P_End)
	{
		if (Pj->Data > P_Begin->Data)
		{
			Pi = Pi->P_Next;
			Swap(Pi, Pj);
		}
		Pj = Pj->P_Next;
	}

	Swap(Pi, P_Begin);
	return Pi;
}

猜你喜欢

转载自blog.csdn.net/baidu_41905806/article/details/84790137
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022