数据结构——单链表

时间书写

已于 2023-10-08 14:38:03 修改

阅读量265

点赞数 1

分类专栏：数据结构文章标签：数据结构链表 c语言算法

于 2023-04-19 17:04:44 首次发布

本文链接：https://blog.csdn.net/aqlll_/article/details/130236296

版权

数据结构专栏收录该内容

8 篇文章 1 订阅

订阅专栏

单链表

😋前言
一、链表的概念💬
二、链表的种类💬
三、单链表💬

今日一言：“每一个想要学习的瞬间，都可能是未来的你在向你求救。”💖

😋前言

上一期我们介绍了动态内存管理的顺序表，但是顺序表存在一个问题：进行头插、头删操作的时候要挪动n个数据，时间复杂度是O(N)，效率很低。因此，今天我们来介绍链表，链表就不存在这方面的问题。
那么什么是链表呢？

一、链表的概念💬

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

光文字或许难以理解，我们直接上图😉
在这里插入图片描述

二、链表的种类💬

单向或双向、带头或不带头、循环或非循环，这些因素相互组合，就得到很多种类型的链表，实际上链表有8种类型，在这里，我们先讨论最为简单的无头单向非循环链表。
无头单向非循环链表结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。

三、单链表💬

下面展示实现单链表三个模块的代码：

3.1 单链表的三个模块⭐️

1️⃣3.1.1 SList.h

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


typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

//打印
void SLTPrint(SLTNode* phead);
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);
//尾删
void SLTPopBack(SLTNode** pphead);
//尾插
void SLTPopFront(SLTNode** pphead);
//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);
//在pos位置之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//在pos位置删除
void SLTErase(SLTNode** pphead, SLTNode* pos);
//在pos位置之后插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x);
//在pos位置之后删除
void SLTEraseAfter(SLTNode* pos);
//销毁链表
void SLTDestory(SLTNode* phead);

2️⃣3.1.2 SList.c

#include"SList.h"

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

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (NULL == newnode)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* tail = *pphead;
	if (tail->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

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

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

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySLTNode(x);
		newnode->next = pos;
		prev->next = newnode;
	}
}

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
	}
}

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

void SLTDestory(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

3️⃣3.1.3 Test.c

#include"SList.h"

void TestSLTNode1()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTNode* pos1 = NULL;
	pos1 = SLTFind(plist, 3);
	SLTInsert(&plist, pos1, 0);
	SLTPrint(plist);

	SLTNode* pos2 = NULL;
	pos2 = SLTFind(plist, 0);
	SLTErase(&plist, pos2);
	SLTPrint(plist);
	SLTDestory(plist);
	plist = NULL;
}

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

3.2 注意项❗️

3.2.1 assert

在定义各个函数的时候，要适当使用assert库函数来进行断言操作，以防止函数传参时传了错误的数据。
但是我们要明白，当我可以接受某个指针为空的时候，就不用为其断言，但当我们程序不能接收指针为空时，就必须为指针断言。
比如：
上述的SLTPrint函数，功能是打印链表，就算传来空指针，也无非就是打印不出结果（或打印NULL），此时的指针是否为空对程序影响不大，可以不断言。
但是SLTPopBack函数，功能是删除链表的尾，此时如果传来空指针，删除的程序就进行不下去了（编译器：你都没有东西让我怎么删啊！！！），所以我们要断言，防止使用这个函数的人传错了指针。

3.2.2 一级指针or二级指针❗️❓❗️

对于上述函数里的二级指针pphead来说，pphead是指向plist的指针，plist是指向链表第一个节点的指针。有时候我们需要改变plist的指向（增删操作时），比如一开始为空表，增加一个数据之后，plist就不再指向NULL了，而是要指向新的地址，此时我们如果传一级指针进入函数，是没有办法改变plist指针的指向的，只能够改变plist指针指向的那块空间。而传二级指针，就能改变plist指针的指向了。
在这里插入图片描述

3.2.3 两个错误代码🚫

代码一：尾插函数的实现
在这里插入图片描述
正确写法是：

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

虽然表面上tail = *pphead，但是可不能通过tail改变 *pphead！因为tail只是 *pphead的一份临时拷贝。

代码二：尾删函数的实现
在这里插入图片描述
这就是上面提到的一级指针还是二级指针的问题。
正确写法是：

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* tail = *pphead;
	if (tail->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

3.3 拓展⭐️

我们知道单链表是一个接着一个的，只有上一级能够找到下一级，但是下一级找不到上一级，因此当我们需要在某个位置pos之前进行增、删操作的时候，就麻烦了，就只能从头开始找，直到找到pos的上一级。这样效率就很低了。
那是否有办法不从头开始找，就能对pos的之前进行操作呢？
还真有！
在这里插入图片描述