C语言 关于单链表的所有操作

最新推荐文章于 2023-02-21 22:51:23 发布
最新推荐文章于 2023-02-21 22:51:23 发布
阅读量315 收藏 4
点赞数 1
分类专栏： 进度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kawayi90hou/article/details/79857234
版权

目前实现的所有操作如下图所示：

学数据结构半个多月了，下面是整合的对单链表组的操作，测试了一下数据，应该没问题。

以下是代码：

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#define MAXNUM 10
int cnt = 0;
typedef struct node {
	int data;
	struct node* next;
}Node, *LinkList;
//链表的初始化操作
void Init(LinkList *L) {
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->data = 0;
	(*L)->next = 0;
}
void InitClear(LinkList *L) {
	(*L)->next = NULL;
}
//进行当前链表，链表组的打印
void PrintCurrList(LinkList*L) {
	LinkList p = (*L)->next;
	printf("Head->");
	if (!p)
		printf("NULL");
	while (p) {
		printf("%d", p->data);
		if (p->next)
			printf("->");
		p = p->next;
	}
	printf("\n");
}
int PrintAllList(LinkList*L) {
	int Index = 0;
	LinkList*p = L;
	int tag, IsDisplay = 0;
	while (Index < 10) {
		if (p[Index]) {
			printf("L%d：", Index);
			PrintCurrList(p + Index);
			IsDisplay = 1;
		}
		Index++;
	}
	if (IsDisplay) {
		printf("请输入当前想操控的链表：\n");
		scanf("%d", &tag);
		while (!*(L + tag)) {
			printf("输入有误，请再次输入:   ");
			scanf("%d", &tag);
		}
		return tag;
	}
	else {
		printf("当前列表空荡荡，请创建链表\n");
		return 0;
	}
}
void CreateList(LinkList*L) {
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->data = 0;
	LinkList tail = *L, p;
	int j = 0, temp, n;
	printf("请输入结点数目：");
	scanf("%d", &n);
	while (j++ < n) {
		p = (LinkList)malloc(sizeof(Node));
		scanf("%d", &temp);
		p->data = temp;
		tail->next = p;
		tail = p;
	}
	tail->next = 0;
}
void CreateHead(LinkList*L, int*a, int len) {
	*L = (LinkList)malloc(sizeof(Node));
	int i = 0;
	LinkList p;
	(*L)->data = 0;
	(*L)->next = NULL;
	while (i < len) {
		p = (LinkList)malloc(sizeof(Node));
		p->data = a[i++];
		p->next = (*L)->next;
		(*L)->next = p;
	}
}
int getLen(LinkList *L) {
	LinkList p = (*L)->next;
	int cnt = 0;
	while (p) {
		p = p->next;
		cnt++;
	}
	return cnt;
}
int defaultL(LinkList*L) {
	cnt = 0;
	while (*L) {
		L++;
		cnt++;
	}
	if (cnt > 9) cnt = 9;
	return cnt;
}
LinkList getNode(LinkList*L, int i) {
	LinkList p = (*L);
	int j;
	for (j = 0; p&&j < i; j++) {
		p = p->next;
	}
	if (!p || j > i)
		return 0;//相当于return为空
	return p;
}
void swapNode(LinkList*L, int a, int b) {
	int len = getLen(L);
	//此时在赋值后，L可以当做一个地址在之后的函数中操作
	if (b > len || b<1 || a>len || a < 1||a==b) {
		printf("输入的结点有误！\n");
	}
	else {
		if (abs(a - b) == 1) {
			LinkList p;
			if (a<b)
				p = getNode(L, a - 1);
			if (b < a)  p = getNode(L, b - 1);
			LinkList anode, bnode;
			anode = p->next;
			bnode = anode->next;
			anode->next = bnode->next;
			bnode->next = anode;
			p->next = bnode;
		}
		else {
			LinkList apre, anode, anext, bpre, bnode, bnext;
			apre = getNode(L, a - 1);
			anode = apre->next;
			anext = apre->next->next;
			bpre = getNode(L, b - 1);
			bnode = bpre->next;
			bnext = bpre->next->next;
			bnode->next = anext;

			apre->next = bnode;
			bpre->next = anode;
			anode->next = bnext;
			bnode->next = anext;
		}
	}
}
void Insertnode(LinkList *L, int i, int data) {
	int j = 1;
	int len = getLen(L) + 1;
	LinkList p = *L, q;
	if (!p || i>len || i<1)  return;
	for (j; j < i&&p; j++) {
		p = p->next;
	}
	q = (LinkList)malloc(sizeof(Node));
	q->data = data;
	q->next = p->next;
	p->next = q;
}
void deleteNode(LinkList*L, int data) {
	LinkList p = (*L)->next, q;
	while (p->next) {
		if (p->next->data == data) break;
		p = p->next;
	}
	if (!(p->next)) {
		printf("你所查找的数据不存在\n");
		return;
	}
	else {
		q = p->next;
		p->next = q->next;
		free(q);
	}
}
void ClearList(LinkList*L) {
	LinkList p = *L, q;
	while (p) {
		q = p->next;//先进行预存，因为删除后就无法进行访问了
		free(p);
		p = q;
	}
	*L = 0;
}
LinkList getmidnode(LinkList*L) {
	LinkList s, p = (*L)->next;
	s = p;
	while (p) {
		//在p改变之前先进性改变
		if (!(p->next)) break;
		p = p->next->next;
		s = s->next;
	}
	return s;
}
//在排序中要保留结点的前驱部分，前驱部分不会随着交换而改变
void BubbleSort(LinkList*L) {
	LinkList end, p, temp, p1;
	p = *L;
	for (end = 0; end != *L; end = temp) {
		//for循环中先执行条件语句，然后执行之后的代码，最后再执行赋值语句
		for (temp = p = *L; p->next->next != end; p = p->next) {
			//最开始给了end空值，所以开始要循环到末尾，要从被比较结点前面的一个结点开始操作，所操作的最大限值在p->next->next
			if (p->next->data > p->next->next->data) {
				//p1 = p->next;
				//p1->next = p1->next->next;//这一步就相当于删除了p1后面的结点，不能在进行交换操作了
				//p1->next->next = p1;
				//p->next = p1->next;
				p1 = p->next->next;//要先保存住排在后面的结点
				p->next->next = p1->next;
				p1->next = p->next;
				p->next = p1;
				temp = p->next->next;
			}
		}
	}
}

void SelectSort(LinkList*L) {
	LinkList start, p, temp, p2, temp1;
	start = (*L)->next;
	int cnt = 1, cnt1;
	for (p = start; p; p = temp->next) {
		cnt1 = cnt;
		for (p2 = temp = p; p2; p2 = p2->next, cnt1++) {
			//这些指针只是位置的指标，实际操作的链表是一体的
			if (p->data > p2->data) {
				temp1 = p;//提前预留交换后的状态
				swapNode(L, cnt, cnt1);
				p = temp = getNode(L, cnt);
				p2 = temp1;
			}
		}
		cnt++;
	}
}
void selectSort2(LinkList *L) {
	//相当于新建了一个链表，把原链表的结点按最小值依次拆分放到新链表中
	LinkList start, tail, min, minpre, p;
	start = 0;
	while (*L) {
		for (p = *L, min = *L; p->next; p = p->next) {
			//头结点和min要默认定义在最开始的节点上
			if (p->next->data < min->data) { //找到一个比当前结点更小的结点
				minpre = p;//保存上最小结点前面的结点，不会随着链表的变动而变动，以便于以后的操作
				min = p->next;
			}
		}
		if (!start) {
			start = min;
			tail = min;
		}
		/*
		//教训：此时要加else，如果是if语句的话就承接了上面的if语句，最终结果为整个链表都为头结点的值
		if(start) {
		tail->next = min;
		tail = min;
		}
		*/
		else {
			tail->next = min;
			tail = min;
		}
		//将最小的那个结点从原链表中移除掉
		if (min == *L) {
			*L = (*L)->next;
		}
		else {
			minpre->next = min->next;
		}
		//free(min);  //不要把原结点的空间释放掉
	}
	tail->next = 0;
	*L = start;//为原链表重新赋值
}
void Insertsort(LinkList*L) {
	LinkList p, start, min, minpre, q;
	start = (*L)->next;//插入要从后面的数开始
	(*L)->next = 0;//把原链表换为空链表，然后再插入
				   //整个插入过程是把start插入到*L，然后根据start指针把start内的成员逐个插入到*L中
	while (start) {
		for (p = *L, q = start; p&&start->data > p->data; minpre = p, p = p->next);
		//在此获得start应插入到*L的前结点
		//q是预留的start空间
		start = start->next;//注意：这里start先进行，因为下面q的变化会联动start，先在此预留空间
		if (p == *L) {//插在头结点前面时
			*L = q;
			q->next = p;
		}
		else {
			//其余情况，*L中有小于start的结点，则插到*L中
			minpre->next = q;
			q->next = p;
		}
	}
}
void InsertOrdered(LinkList*L, int data) {
	LinkList q = *L, pre;
	LinkList p = (LinkList)malloc(sizeof(Node));
	p->data = data;
	if (!(*L)) {//若*L是空链表，则为其创建头结点
		*L = p;
		p->next = 0;
	}
	else {
		//while (q->data < p->data&&q) {
		//教训：一定要把q放到前面，当q为空时，q->data已经不能访问，先判断q==NULL，可免去后续的判断
		while (q&&q->data < p->data) {
			pre = q;
			q = q->next;
		}
		if (q == *L) {
			*L = p;
			p->next = q;
		}
		else {
			p->next = pre->next;
			pre->next = p;
		}
	}
}
void PrintList(LinkList*L) {
	int Index = 0;
	LinkList*p = L;
	int IsDisplay = 0;
	while (Index < 10) {
		if (p[Index]) {
			printf("L%d：", Index);
			PrintCurrList(p + Index);
			IsDisplay = 1;
		}
		Index++;
	}
}
void Combined(LinkList*L, LinkList*b) {
	if (!(*b)) return;
	else {
		LinkList p = *L, pre;
		while (p) {
			pre = p;
			p = p->next;
		}
		LinkList q = (*b)->next;
		pre->next = q;
		free(*b);
		*b = 0;
		//ClearList(b);//不要清除整个链表，只清楚头结点即可
	}
}
void ReverseList(LinkList*L) {
	LinkList p = (*L)->next, q = 0, temp, p1 = *L;
	while (p) {
		temp = p->next;
		p->next = q;
		q = p;
		p = temp;
	}
	p1->next = q;
	//把预留的头结点接到q上，这样实现了出来头结点以外其他结点的倒置
	*L = p1;
}
void ClearAllList(LinkList *L) {
	for (int i = 0; i < MAXNUM; i++)
		ClearList(L + i);
}
void Menu() {
	printf("1：创建链表（空链表）\n2：创建链表（头插法，数组创建）\n3：创建链表（尾插法，自己赋值）\n4：显示与改变当前链表\n");
	printf("5：当前链表长度\n6：获取第i个结点的数据\n7：交换两结点\n8：插入结点\n9：删除结点\n10：获取中间结点数据\n");
	printf("11：排序链表（冒泡排序）\n12：排序链表（插入排序）\n13：排序链表（选择排序）\n14：插入有序结点\n");
	printf("15：合并链表\n16：倒置链表\n17：初始化为空链表\n18：删除该链表\n19：清空数据并重新显示菜单\n20：退出该程序\n");
}
int main() {
	static int LinkTag, temp;
	//static，每次调用时为上次调用的值，其存储空间一旦声明就不会释放
	int a[] = { 3,23,34,43,151,325,32 };
	int len = sizeof(a) / sizeof(int);
	LinkList L[MAXNUM] = { 0 };
	LinkList tempList;
	int choice, num1, num2;
	Menu();
	while (1) {
		printf("--------------------------------------\n");
		printf("请输入您的操作：");
		scanf("%d", &choice);
		switch (choice)
		{
		case 1:
			LinkTag = defaultL(L);
			Init(L + LinkTag);
			PrintCurrList(L + LinkTag);
			break;
		case 2:
			LinkTag = defaultL(L);
			CreateHead(L + LinkTag, a, len);
			PrintCurrList(L + LinkTag);
			break;
		case 3:
			LinkTag = defaultL(L);
			CreateList(L + LinkTag);
			PrintCurrList(L + LinkTag);
			break;
		case 4:
			LinkTag = PrintAllList(L);
			break;
		case 5:
			printf("当前链表长度为%02d\n", getLen(L + LinkTag));
			break;
		case 6:
			printf("输入第i个结点：");
			scanf("%d", &temp);
			tempList = getNode(L + LinkTag, temp);
			if (!tempList)
				printf("该节点不存在\n");
			else
				printf("L%d的第%d个值为：%d\n", LinkTag, temp, tempList->data);
			break;
		case 7:
			printf("请输入要交换的两个结点：");
			scanf("%d %d", &num1, &num2);
			swapNode(&L[LinkTag], num1, num2);
			PrintCurrList(L + LinkTag);
			break;
		case 8:
			printf("输入要插入的结点 和 数字：");
			scanf("%d %d", &num1, &num2);
			Insertnode(L + LinkTag, num1, num2);
			PrintCurrList(L + LinkTag);
			break;
		case 9:
			printf("输入你要删除的数据：");
			scanf("%d", &num1);
			deleteNode(L + LinkTag, num1);
			PrintCurrList(L + LinkTag);
			break;
		case 10:
			tempList = 0;
			tempList = getmidnode(L + LinkTag);
			printf("当前链表的中间结点数据为%d\n", tempList->data);
			break;
		case 11:
			BubbleSort(L + LinkTag);
			PrintCurrList(L + LinkTag);
			break;
		case 12:
			Insertsort(L + LinkTag);
			PrintCurrList(L + LinkTag);
			break;
		case 13:
			selectSort2(L + LinkTag);
			PrintCurrList(L + LinkTag);
			break;
		case 14:
			printf("输入你要插入的数据：");
			scanf("%d", &num1);
			InsertOrdered(L + LinkTag, num1);
			PrintCurrList(L + LinkTag);
			break;
		case 15:
			PrintList(L);
			printf("当前链表为L%d，请输入想要合并的链表：", LinkTag);
			scanf("%d", &num1);
			Combined(L + LinkTag, L + num1);
			PrintCurrList(L + LinkTag);
			break;
		case 16:
			ReverseList(L + LinkTag);
			PrintCurrList(L + LinkTag);
			break;
		case 17:
			InitClear(L + LinkTag);
			PrintCurrList(L + LinkTag);
			break;
		case 18:
			ClearList(L + LinkTag);
			printf("删除该链表之后，还剩下：\n");
			PrintAllList(L);
			break;
		case 19:
			system("cls");
			ClearAllList(L);
			Menu();
			break;
		case 20:
			exit(0);
			break;
		default:
			break;
		}
	}
	return 0;
}


kawayi90hou
关注
专栏目录
C语言_链表_所有操作
02-28
本程序针对链表进行一系列的操作，包括生成，插入，排序，创建已排链表等。对链表的学习以及后续程序的编写有一定帮助。
用C语言实现单链表的各种操作(一)
09-05
总的来说，理解并能熟练运用这些单链表操作对于学习和应用数据结构至关重要，因为它们是许多其他复杂数据结构和算法的基础。通过实践这些操作，可以更好地理解和掌握链表的工作原理，为后续的编程和算法设计打下坚实...
单链表的操作
dingqin8781的博客
04-30 752
题目：单链表的插入和删除 目的： 了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。 要求： 建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。 实验主要步骤： 1、分析、理解给出的示例程序。 2、调试程序，并设计输入数据（如：bat，cat，eat，fat，hat，jat...
C语言--单链表的基本操作
yu1368072332的博客
09-26 502
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct Node { int value; struct Node *next; } lsNode; lsNode *InitLink(int count) { lsNode *head = (lsNode*)malloc(sizeof(lsNode)); /...
数据结构-单链表基本操作——C语言
weixin_50490968的博客
04-24 3157
一、按位插入（带头结点）ListInsert(&l,i,e) Tips：(此时是 i=1 的情况，插在表头，不执行while循环 ) //在第i个位置插入元素 e （带头结点） typedef struct LNode{ //单链表结构定义 ElemType data; //存放数据域 struct LNode *next; //指针域 }LNode,*LinkList; { /* data */ }; boo
单链表的基本操作(C语言+图解分析)
Curz酥的博客
08-23 1614
纯C语言，代码均可直接运行，读者可自行调试。
C语言实现单链表的操作
07-27
C语言实现单链表的所有基本操作，500行左右，键盘输入
C语言实现单链表（常规操作）
06-19
C语言实现单链表（常规操作） LinkList CreateHeadListH(); // 头插法创建单链表 LinkList CreateHeadListT(); // 尾插法创建单链表 int ListEmpty(); // 单链表判空 int ListLength(); // 求单链表长度...
C语言实现单链表，单链表操作
02-06
单链表操作：1.创建单链表 2.遍历单链表 3.获取单链表的长度 4.判断单链表是否为空 5.获取节点 6.在尾部插入指定元素 7.在指定位置插入指定元素 8.在头部插入指定元素 9.在尾部删除元素 10.删除所有元素 11.删除指定...
c语言单链表的实现及测试
07-20
定义了单链表的基本操作，并在主函数中测试了所有定义的操作。
c语言单链表程序
07-05
C语言单链表程序
数据结构c语言版-单链表的操作程序代码
05-19
c语言数据结构的， 学数据结构一定会用到的 。
单链表操作（C语言）含注释
最新发布
m0_62925086的博客
02-21 371
单链表操作（C语言）含注释 1、创建 2、显示 3、查找（显示比较次数） 4、插入 5、删除（显示比较次数） 6、将链接存储线性表逆置 7、两链表有序合并 8、拆分奇偶
【数据结构】二、单链表的基本操作(C语言)
lieam的博客
12-22 7891
【数据结构】二、单链表的基本操作(C语言)
C：C语言实现的链表及其各种链表操作
Chnyac的博客
03-15 404
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct LNode { int data; struct LNode *next; }LNode, *LinkList; //LNode : 结构体类型，LinkList :结构体指针； typedef enum { false = 0, true = 1, }boo...
c语言链表各种操作
cy320h的博客
06-28 472
实现链表的数据查询， 计数，翻转，插入，删除，显示
关于单链表操作的一览表
WR的博客
09-27 90
关于单链表操作的一览表 这是根据课本上的内容，自己打出来的。 有的时候理解链表的含义，但就是写不出代码来，整理一下还会好一点吧。 常来复习看看。 注意：这个代码不可以运行，是我做测试用的，关键看思想！ // An highlighted block #include <stdio.h> #include <stdlib.h> typedef int datatype;//便于修改结构体内的数据类型 typedef struct Inode { datatype date;
【C语言】链表的一些简单操作
SHERMAN_YW BLOG
04-05 274
链表是一种重要的常见的、动态地进行存储分配数据结构，可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址，该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该元素不再指向其它元素，它称为“表尾”，它的地址部分放一个“
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值