单链表保姆级教程

王权小鱼

已于 2024-02-07 05:04:19 修改

阅读量982

点赞数 28

文章标签：链表

于 2024-02-06 16:13:17 首次发布

本文链接：https://blog.csdn.net/2301_79994919/article/details/136054758

版权

前言

线性表分为顺序表和链表，今天小编为大家来详细的解析一下链表。

顾名思义，链表及是用链式存储的方式来实现的线性表，这里或许有小伙伴不明白什么是链式存储，这里小编用一幅图来为小伙伴们解释一下链式存储

对于单链表，其在逻辑结构上是连续的，在物理(存储)结构上是随机的，通过指针进行连接。

在工程上一本使用多文件操作，这里我们定义SLTNode.h文件用来存放定义的链表结构体和函数的声明，SLTNode.c文件用来实现函数体，用test.c文件来进行测试

typedef int SLTDatatype;//这里我们用typedef关键字重新命名int类型，这样做的目的是我们方便修改我们存储数据的类型

typedef struct SLTNode {
	SLTDatatype data;//数据域:定义了一个存放int类型的变量
	struct SLTNode* next;//指针域:定义了一个指向下一个节点的指针
}SLTNode;

在链表的定义中（链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。存放数据的是数据域，存放指针的是指针域。

这里或许有小伙伴对指针域这行代码不理解，这又是什么意思呢？

这里小编给大家举个例子 int* next; 这个不难理解吧，*说明next是一个指针变量，指向int类型的数据，所以说这里的指针域，是一个结构体指针变量，指向下一个节点（结构体）。

void test()
{
	SLTNode* plist = NULL;
}
int main()
{
	test();
	return 0;
}

这里我们声明一个头指针，刚开始的时候表中什么都没有，我们直接初始化plist = NULL;

尾插

逻辑结构：

物理结构：

void SListPushBack(SLTNode** pphead, SLTDatatype x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//申请一个节点
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (*pphead == NULL) //这里判断链表先前是否为空，如果为空，就直接把newnode的地址给*pphead
	{
		*pphead = newnode;
	}
	else {
		SLTNode* cur = *pphead;//这里定义一个指针用来找尾
		while (cur->next != NULL)
		{
			cur = cur->next;
		}
		cur->next = newnode;
	}
}

这里着重强调一下！！！(当头指针发生变化的时候，我们要传址，并非传值），在C语言中，当我们学习到函数这一章节的时候，相信大家的，都知道函数传递参数的时候，形参是实参的一份临时拷贝！！指向的不是同一块空间，当形参发生变化的时候，实参不会发生变化，当形参和实参指向同一块空间的时候，形参的改变才会影响实参的改变！！！

这里小编给大家通过举例论证一下

这里不难看出，plist 和 pphead指向的是同一块空间。

这里再解释一下为什么还要判断链表先前是否为空的情况

打印

上面我们介绍完了尾插，接下来我们分析一个比较简单一点的——打印链表

void SListPrint(SLTNode* pphead)
{
	SLTNode* cur = pphead;
	while (cur!= NULL)//这里主要的思想就是遍历整个链表
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

这里解释一下为什么不传地调用，因为这里的话只是找到并打印cur里面的数据，不改变plist头节点，所以传值调用的话，够用。

头插

这幅图不难理解吧，plist 原本存放A的地址(0x000000001),现在要头插一个B，那么plist里面就要存放B的地址，然后B里面存放A的地址，这里大家可以先暂停一下，试试自己写一写代码。

void SListPushFront(SLTNode** pphead, SLTDatatype x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//申请一个节点
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	SLTNode* node = *pphead;//这里的话，我们根据上面的图，我们不难看出，这里需要保存A节点
	*pphead = newnode;
	newnode->next = node;
}

大家这里也可以思考一下，我们这里需要不需要考虑 plist为空的情况？

这里小编解释一下，

SLTNode* node = *pphead;//当plist是空的时候,这里的node是NULL
*pphead = newnode;//然后*pphead指向newnode
newnode->next = node;//newnode指向NULL

所以说这里不需要考虑plist是否为空的情况。

尾删

这里要删除A的话，那么首先先要找到A，然后A前面的节点不是存放A的地址嘛，然后删除A的话，那么该节点就就指向空（NULL），存放0x00000000，既然这样的话，大家这里可以先自己想一想，这一步需要怎么处理。

这里的话，我们可以定义两个指针(快慢指针),当tail指向最后一个元素的时候，cur刚好指向A(要删除元素的前一个元素),这样的话，我们就可以找到我们需要找的元素。

接下来，我们用代码实现一下吧。

void SListPopBack(SLTNode** pphead)
{
	if (*pphead == NULL)//空表的情况
	{
		return;
	}
	else if ((*pphead)->next == NULL)//只有1个节点的情况
	{
		free(*pphead);
		*pphead = NULL;
	}
	SLTNode* tail = *pphead;
	SLTNode* cur = NULL;
	while (tail->next != NULL)//当只有一个节点的时候，cur=tail这个没有办法进行
	{
		cur = tail;
		tail = tail->next;
	}
	free(tail);
	cur->next = NULL;//者的的话cur是空指针
}

这里我们思考一下，为什么还要考虑只有一个节点的情况？

SLTNode* tail = *pphead;
SLTNode* cur = NULL;
while (tail->next != NULL)//当只有一个节点的时候，cur=tail这个没有办法进行
{
	cur = tail;
	tail = tail->next;
}
free(tail);
cur->next = NULL;//者的的话cur是空指针

头删

头删的话，我们不难在图上看出,plist储存着A的地址，而A却储存着B的地址，现在想删除A的话，不能直接free掉它，为什么呢？

因为A里面储存着B的地址，所以在删除A之前，我们要将B的地址存放在plist中，然后再删除掉A。接下来我们用代码实现一下吧！

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

这里只有一个节点的情况大家也可以思考一下哈。

查找

对于链表来说，逻辑结构上是连续的，物理结构上是不连续的，所以要查找某一个数据元素的话，肯定是要遍历它，接下来，跟着小编一起实现一下吧！

SLTNode* SListFind(SLTNode* pphead, int pos)
{
	SLTNode* cur = pphead;
	while (cur)
	{
		if (cur->data == pos)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

总结

尾插，头插，尾删，头删最终和查找我们可以总结为这几行代码。

这里大家结合一下上面头插，头删，尾插，尾删的处理方法思考一下每一步哈。

void SListInsert(SLTNode** pphead, SLTNode* pos, int x)
{
	if ((*pphead) == pos)
	{
		SListPushFront(pphead, x);
	}
	else {
		SLTNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
		newnode->data = x;
		SLTNode* prev = cur->next;
		newnode->next = prev;
		cur->next = newnode;
	}
}

void SListEarse(SLTNode** pphead, SLTNode* pos)
{
	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else {
		SLTNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = pos->next;
		free(pos);
	}
}

完整代码

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef int SLTDatatype;

typedef struct SLTNode {
	SLTDatatype data;
	struct SLTNode* next;
}SLTNode;

void SListPushBack(SLTNode** pphead , SLTDatatype x);

void SListPrint(SLTNode* pphead);

void SListPushFront(SLTNode** pphead, SLTDatatype x);

void SListPopBack(SLTNode** pphead);

void SListPopFront(SLTNode** pphead);

SLTNode* SListFind(SLTNode* pphead, int pos);

void SListInsert(SLTNode** pphead, SLTNode* pos ,int x);

void SListEarse(SLTNode** pphead, SLTNode* pos);

#define _CRT_SECURE_NO_WARNINGS
#include"SLTNode.h"
void SListPushBack(SLTNode** pphead, SLTDatatype x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//申请一个节点
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (*pphead == NULL) //这里判断链表先前是否为空，如果为空，就直接把newnode的地址给*pphead
	{
		*pphead = newnode;
	}
	else {
		SLTNode* cur = *pphead;//这里定义一个指针用来找尾
		while (cur->next != NULL)
		{
			cur = cur->next;
		}
		cur->next = newnode;
	}
}

void SListPushFront(SLTNode** pphead, SLTDatatype x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//申请一个节点
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	SLTNode* node = *pphead;//当plist是空的时候,这里的node是NULL
	*pphead = newnode;//然后*pphead指向newnode
	newnode->next = node;//newnode指向NULL
}

void SListPrint(SLTNode* pphead)
{
	SLTNode* cur = pphead;
	while (cur!= NULL)//这里主要的思想就是遍历整个链表
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

void SListPopBack(SLTNode** pphead)
{
	if (*pphead == NULL)//空表的情况
	{
		return;
	}
	else if ((*pphead)->next == NULL)//只有1个节点的情况
	{
		free(*pphead);
		*pphead = NULL;
	}
	SLTNode* tail = *pphead;
	SLTNode* cur = NULL;
	while (tail->next != NULL)//当只有一个节点的时候，cur=tail这个没有办法进行
	{
		cur = tail;
		tail = tail->next;
	}
	free(tail);
	cur->next = NULL;//者的的话cur是空指针
}

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

SLTNode* SListFind(SLTNode* pphead, int pos)
{
	SLTNode* cur = pphead;
	while (cur)
	{
		if (cur->data == pos)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

void SListInsert(SLTNode** pphead, SLTNode* pos, int x)
{
	if ((*pphead) == pos)
	{
		SListPushFront(pphead, x);
	}
	else {
		SLTNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
		newnode->data = x;
		SLTNode* prev = cur->next;
		newnode->next = prev;
		cur->next = newnode;
	}
}

void SListEarse(SLTNode** pphead, SLTNode* pos)
{
	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else {
		SLTNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		cur->next = pos->next;
		free(pos);
	}
}

#define _CRT_SECURE_NO_WARNINGS
#include"SLTNode.h"

void test()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist , 1);
	SListPushBack(&plist , 2);
	SListPushBack(&plist , 6);
	SListPushBack(&plist , 3);
	SListPushBack(&plist , 4);
	SListPushFront(&plist, 0);
	/*SListPopBack(&plist);
	SListPopFront(&plist);
	SListPopFront(&plist);*/
	SLTNode* pos = SListFind(plist, 3);
	if (pos)
	{
		//再pos前面插入
		SListInsert(&plist, pos ,30);
	}
	if (pos)
	{
		//删除pos的值
		SListEarse(&plist, pos);
	}
	SListPrint(plist);
}
int main()
{
	test();
	return 0;
}

今天到这里就结束啦，下一期小编为大家带来带头节点的双向循环链表哈。