C语言详写单链表

多喝热水啊！

已于 2022-10-29 12:39:50 修改

阅读量842

点赞数 1

文章标签： c语言数据结构

于 2022-10-29 12:29:07 首次发布

本文链接：https://blog.csdn.net/m0_66676384/article/details/127585450

版权

文章目录

**链表**

链表

顺序表和链表的优缺点

	优点	缺点
链表	1.便于在表的头和尾插入数据 2.可以按需申请释放空间，减少空间浪费 3.在删除或增加数据时不需要对数据进行挪动减少了消耗 4.通过结点实现数据的联系与存储	物理空间不连续，无法做到下标的随机访问，在除头部以外的其他位置进行数据操作时，会需要遍历链表，造成性能消耗
顺序表	1.物理空间连续，可以利用下标随机访问 2.尾插效率高	1.在除尾部数据之外，其他位置的数据在增加、删除时均会涉及到数据的挪动，增加了一定的性能消耗 2.在空间不够需要扩容的时候，有时还会涉及到数据的挪动，以及剩余空间的浪费

链表

链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

链表可以分为链表可以分为单链表、双链表、带头或者不带头、循环或者不循环，均属于链表的结构。

一般我们最常见的是无头单向不循环链表，一般用于其他数据结构的子结构出现
还有带头双向循环链表，虽然这种链表结构复杂，但是他更多的用于单独存储数据

单链表

未命名绘图.drawio

通过上图可以发现链表中的每个结点分为两部分，一部分用来存储数据、一部分用来存储指向下一结点的指针。

这里实现单链表一共建立了三个文件：头文件(SL.h)、源文件(SL.c)、源文件(test.c)，分别依次用来存储函数声明，函数定义，流程实现

定义链表结点（结构体）

这里先定义链表结点（需要放在SL.h头文件）

如果我们后续希望改变链表存储数据的类型该怎么作呢？

这里通过typedef对数据的类型进行重命名，并且对结点进行重命名，便于我们后续使用

实现思路

1.重定义数据类型
2.定义链表结点（一部分用于存放数据、一部分用于存放下一个结点的指针）
3.对链表结点进行重命名便于后续使用

实现：

typedef int SLDateType;//重定义数据的类型名
typedef struct SListNode
{
	SLDateType data;//存放数据
	struct SListNode* next;//指向下一结点的指针
}SLTNode;

浅浅的测试一下

在test.c文件中main函数中建立四个结点，并将他们链接起来打印
建立结点之后记得要使用assert来检查是否建立成功

建立结点

建立结点的时候通过malloc来开辟空间，开辟空间的大小可以通过sizeof来计算结点的大小，接着通过强制类型转换，将他们转换为结构体指针类型

实现：

void TestSL1()
{
	//建立四个结点
	SLTNode* n1 = (SLTNode*)malloc(sizeof(SLTNode));
	assert(n1);

	SLTNode* n2 = (SLTNode*)malloc(sizeof(SLTNode));
	assert(n2);

	SLTNode* n3 = (SLTNode*)malloc(sizeof(SLTNode));
	assert(n3);

	SLTNode* n4 = (SLTNode*)malloc(sizeof(SLTNode));
	assert(n4);
	
	//四个结点存放四个数据
	n1->data = 1;
	n2->data = 2;
	n3->data = 3;
	n4->data = 4;

	//将四个结点链接起来
	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = NULL;
	
	//调用打印函数
	SListPrint(n1);//打印
}

int main()
{
	TestSL1();
	return 0;
}

这里我们看下效果

这里补充一个打印函数，来观察我们是否实现了链表的链接

打印函数

打印链表，我们需要遍历整个链表，只需要可以访问到这个链表即可，所以我们只需要知道头结点的地址即可访问链表。

实现思路：

1.建立临时变量来遍历整个链表
2.利用while语句判断目前的结点是否是最后一个结点
3.这里便于我们观察除最后一个结点以外在每一个结点之后都打印了->

实现：

//打印函数，函数定义放在SL.c中并在SL.h中添加定义
void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;//用cur来遍历链表
	while (cur != NULL)//用于判断是否是最后一个结点
	{
		printf("%d->", cur->data);//每次打印数据+箭头
		cur = cur->next;//获取结点所指向的下一个结点的地址
	}
	printf("NULL\n");//最后一次打印NULL且不带箭头
}

关于建立结点，我们每次实现头插，尾插，指定数据后插入，都要新建结点并链接，所以这里我们可以先实现一个函数专门用于结点的新建

新建结点

关于结点的新建，我们首先需要知道新建好的结点我们应该存入什么数据，并且在函数结束之后我们怎么得到这个结点的信息
所以，新建结点的返回类型一定是我们所定义的结构体类型的指针

实现思路：

1.malloc一个结点的空间，空间的大小利用sizeof计算，并将该空间强制转化为结构体指针类型
2.利用断言判断结点是否建立成功
3.初始化新建的结点，将数据保存到结点，并将结点的next置为NULL
4.返回新建结点

实现：

//新建结点
SLTDateType* BuySListNode(SLTDateType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	assert(newnode);
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

头插

这里我们先实现头插。
首先是需要建立新的结点，其次头插的返回类型可以是空，因为我们需要在函数体内部去改变头结点的关系。
由于我们需要在函数内部改变链表头结点的指针，但是在函数中仅仅是对形参的改变，我们如果需要改变实参就需要对实参的指针进行解引用，即改变头结点的指针我们需要使用二级指针来帮助我们实现，即在使用头插的时候我们需要将头结点指针的指针传给头插函数，通过对头结点指针的指针去解引用从而改变头结点的指针。所以调用的时候为

SListPushFront(&n1, 3);

关于头插，我们是否还需要判断是否链表为空？

首先，在头插时我们将原来链表链接到新建的结点之后，即newnode->next = *pphead，但不论原链表是否为NULL，在我们新建结点的时候我们已经赋值为空，即newnode->next = NULL，所以我们大可不必判断
而且我们在新建结构体的时候就已经对是否建立结点进行了断言，所以这里连断言都不需要

实现思路：

1.利用BuySListNode函数新建一个结点
2.将新建结点链接到链表上（需要利用指针去更改头结点的指向）

实现：

//头插
void SListPushFront(SLTNode** pphead, SLTDateType x)
{
	SLTNode* newnode = BuySListNode(x);

	newnode->next = *pphead;
	*pphead = newnode;
}

尾插

关于尾插，在单链表中，我们仅仅知道头结点的地址，要想在链表之后插入结点，就需要我们遍历整个链表去找到尾结点

实现思路

首先需要新建一个链表结点
接着我们需要通过建立一个临时的结构体指针来遍历整个链表，从而找尾结点的位置
最后将新建的结点链接到尾结点之后即可

但是如果刚开始传进来的就是个空链表呢？

这里我们需要利用if来进行判断：
1.如果刚开始为空的话，我们直接将新建的结点给了链表的头结点即可。这里由于需要改变链表的头结点所以会涉及到二级指针，具体的看前面的头插
2.如果刚开始不为空，我们就按部就班的遍历、链接即可

实现：

//尾插
void SListPushBack(SLTNode** pphead, SLTDateType x)
{
	SLTNode* newnode = BuySListNode(x);
	
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾结点
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

头删

头删简单来说就是将指向链表头结点的指针指向下一个结点，并且要将第一个结点给删除掉(free)
这里需要我们注意的就是我们需要先定义一个临时变量来保存指向下一个结点的指针，然后才能心安理得的free掉头结点
如果刚开始就是一个空链表让头删呢？

这里就需要我们用到断言（assert）来实现

实现思路

1.断言判断被头删的链表是否为空链表
2.新建一个临时变量来存储下一个结点的地址
3.删除掉头结点
4.将头结点改为刚刚存储的临时变量

实现：

//头插
void SListPopFront(SLTNode** pphead)
{
	assert(*pphead != NULL); 
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

尾删

尾删对于单链表来说是最容易实现的，我们只需要遍历整个链表找到尾结点，将尾结点直接free掉即可

但仍然需要我们注意的是如果只有一个结点的情况，甚至没有结点的情况？

在没有结点的情况下我们需要做的就是利用断言来判断
但是当只有一个结点的时候，我们就需要将头结点给free掉，并且不要忘记将头结点置为NULL

当我们找到尾结点，并且将尾结点给Free掉之后，我们怎么可以将尾结点的上一个结点置为NULL？或者说我们怎么可以找到目前的尾结点？

这里我们可以创建两个临时变量
一个专门用来遍历链表找到尾结点
另一个用于存储为尾结点的上一个结点，便于我们之后将新的尾结点的next置为NULL

实现思路：

1.断言是否是空链表，即一个结点都没有的情况
2.利用if语句判断是否只有一个结点的情况
3.如果只有一个结点，只需要将头结点给Free掉，并且将头结点置为NULL
4.如果不是只有一个结点，我们就需要建立两个临时变量来遍历找到尾结点和尾结点的上一个结点。最后将尾结点Free掉并且将尾结点的上一个结点的next置为NULL。

实现：

//尾删
void SListPopBreak(SLTNode** pphead)
{
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{	
		SLTNode* list = (*pphead)->next;
		SLTNode* list2 = *pphead;
		while (list->next != NULL)
		{
			list = list->next;
			list2 = list2->next;
		}
		list2->next = NULL;
		free(list);
	}
}

查找

在实现查找的过程中，我们不会对原来的指针数据产生影响，所以使用一级指针即可。

实现思路：

在查找的过程中，我们需要先建立临时遍历来遍历整个链表从而帮助我们去找到结点所对应的数据,如果找到了我们直接返回该结点的地址，如果没有找到我们就需要返回为NULL

实现：

//查找
SLTNode* SListFind(SLTNode* phead, SLTDateType x)
{
	SLTNode* cur = phead;
	while (cur)//循环遍历整个链表
	{
		if (cur->data == x)
			return cur;//找到之后返回找到的结点的地址
		cur = cur->next;
	}	
	return NULL;
}

在某一位置增加数据

在某一位置增加数据，我们只需要知道该位置的指针，知道要添加的数据，并且新建结点链接起来即可

这里需不需要判断传入的指针是否为NULL？

如果是NULL的话就会引起访问冲突，所以还是添加一个断言吧

实现思路：

1.断言传进来的地址是否为NULL
2.新建一个结点
3.将新建结点的next改为该该结点的next
4.将该结点的next指向新建结点

实现

//在某一位置增加数据
void SListInsertAfter(SLTNode* pos, SLTDateType x)
{
	assert(pos);
	SLTNode* cur = BuySListNode(x);
	cur->next = pos->next;
	pos->next = cur;
}

删除任意位置之后的结点

删除结点，我们只需要知道需要删除结点的地址即可

关于删除某一位置的结点，我们是否还需要判断该结点是否为NULL？

可能在该结点之后链接时容易引起访问冲突，所以还是建议添加断言

实现思路：

1.断言传进来的地址是否为NULL
2.建立一个临时变量去保存下一个结点的地址（用于后续链接）
3.将要删除结点前的结点和其后的结点链接起来
4.Free掉要删除的结点

实现：

//删除任意位置之后的结点
void SListEraseAfter(SLTNode* pos)
{
	assert(pos);
	SLTNode* cur = pos->next;
	pos->next = cur->next;
	free(cur);
}

销毁链表

关于链表的销毁，我们只需要依次删除结点即可。

我们还需要遍历整个链表依次删除吗？

如果我们采用头删的话，删除之后的头结点是不是就变了；即使是尾结点，删除之后的尾结点也就变了
所以我们只需要判断是否已经删除为NULL即可

实现思路：

利用while循环去判断是否已经销毁结束

实现：

//销毁链表
void SListDestroy(SLTNode* plist)
{
	while (plist)
	{
		SListPopFront(plist);
	}
}

这样基本的实现逻辑就已经好了

接下来上完整文件代码

完整代码

头文件（SL.h）

#define  _CRT_SECURE_NO_WARNINGS

#pragma once

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

typedef  int SLTDateType;//重定义类型名
typedef struct SListNode
{
	SLTDateType data;//存放数据
	struct SListNode* next;//指向下个结点的指针
}SLTNode;

void SListPrint(SLTNode* phead);

void SListPushBack(SLTNode** phead, SLTDateType x);

void SListPushFront(SLTNode** phead, SLTDateType x);

void SListPopFront(SLTNode** pphead);

void SListPopBreak(SLTNode** pphead);

SLTNode* SListFind(SLTNode* phead, SLTDateType x);

SLTDateType* BuySListNode(SLTDateType x);

void SListInsertAfter(SLTNode * pos, SLTDateType x);

void SListEraseAfter(SLTNode* pos);

void SListDestroy(SLTNode* plist);

源文件（SL.c）

#define  _CRT_SECURE_NO_WARNINGS

#include "SL.h"

SLTDateType* BuySListNode(SLTDateType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	assert(newnode);
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

void SListPushBack(SLTNode** pphead, SLTDateType x)
{
	SLTNode* newnode = BuySListNode(x);
	
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾结点
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

void SListPushFront(SLTNode** pphead, SLTDateType x)
{
	SLTNode* newnode = BuySListNode(x);

	newnode->next = *pphead;
	*pphead = newnode;
}

void SListPopFront(SLTNode** pphead)
{
	assert(*pphead != NULL); 
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

void SListPopBreak(SLTNode** pphead)
{
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{	
		SLTNode* list = (*pphead)->next;
		SLTNode* list2 = *pphead;
		while (list->next != NULL)
		{
			list = list->next;
			list2 = list2->next;
		}
		list2->next = NULL;
		free(list);
	}
}

SLTNode* SListFind(SLTNode* phead, SLTDateType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}	
	return NULL;
}

void SListInsertAfter(SLTNode* pos, SLTDateType x)
{
	assert(pos);
	SLTNode* cur = BuySListNode(x);
	cur->next = pos->next;
	pos->next = cur;
}

void SListEraseAfter(SLTNode* pos)
{
	assert(pos);
	SLTNode* cur = pos->next;
	pos->next = cur->next;
	free(cur);
}

void SListDestroy(SLTNode* plist)
{
	while (plist)
	{
		SListPopFront(plist);
	}
}

源文件(test.c)

这里的源文件（test.c）只是用来测试上述函数，可以凭借需求任意更改

#define  _CRT_SECURE_NO_WARNINGS

#include "SL.h"

void TestSList1()
{
	SLTNode* n1 = (SLTNode*)malloc(sizeof(SLTNode));
	assert(n1);

	SLTNode* n2 = (SLTNode*)malloc(sizeof(SLTNode));
	assert(n2);

	SLTNode* n3 = (SLTNode*)malloc(sizeof(SLTNode));
	assert(n3);

	SLTNode* n4 = (SLTNode*)malloc(sizeof(SLTNode));
	assert(n4);

	n1->data = 1;
	n2->data = 2;
	n3->data = 3;
	n4->data = 4;

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = NULL;

	SListPrint(n1);//打印
}
void TestSList2()
{
	SLTNode* n1 = NULL;
	SListPushFront(&n1, 1);
	SListPushFront(&n1, 2);
	SListPushFront(&n1, 3);
	SListPushFront(&n1, 3);
	SListPushFront(&n1, 3);


	SListPrint(n1);
	SListPopFront(&n1);


	SLTDateType * pos= SListFind(n1, 2);

	SListInsertAfter(pos, 5);
	SListPrint(n1);

	SListEraseAfter(pos);

	SListPrint(n1);

	SListDestroy(n1);

	SListPrint(n1);

}
int main()
{
	TestSList1();
	TestSList2();
	return 0;
}