【数据结构】单链表的增删查改

最新推荐文章于 2024-07-25 02:49:15 发布

岸边露伴'

最新推荐文章于 2024-07-25 02:49:15 发布

阅读量417

点赞数

分类专栏：数据结构文章标签：数据结构 c语言 c++

本文链接：https://blog.csdn.net/StandDev/article/details/132219341

版权

数据结构专栏收录该内容

7 篇文章 0 订阅

订阅专栏

前言

在上一节中我们提到了顺序表有如下缺陷：

在头部/中间的插入与删除需要挪动数据，时间复杂度为O(N)，效率低；

增容需要申请新空间，可能会拷贝数据，释放旧空间，会有不小的时间消耗；

增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到 200，如果我们再继续插入了5个数据，后面没有数据插入了，那么会浪费95个数据空间；

基于顺序表的这些不足，我们设计出了链表。

一、链表

1. 链表的概念和结构

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

链表和顺序表的不同之处在于：顺序表不仅要求逻辑结构上连续，还要求物理结构上也连续；而链表只要求逻辑结构上连续，物理结构上可以不连续；

所谓的逻辑结构指的是数据在逻辑上是如何存储的，这是由人们主观想象出来的；而物理结构则是数据在物理内存中实际存储的方式，不随人们的主观意志而改变。

链表的逻辑结构如下：

在这里插入图片描述

从上面的图中我们也可以看出：链表在逻辑结构上连续指的是链表的每一个节点都记录着下一个节点的地址，我们可以根据此地址来找到链表的下一个节点，就好像它们被一根线连起来了一样；而实际上链表的每一个节点都是在堆区上随机申请的，相邻结点的地址没有任何关系。

2. 链表的分类

在实际应用中，链表根据带头/不带头、循环/不循环、双向/单向这三种选择一共可以组合出8种结构。

单向或者双向：双向链表对比单向链表来说，其结构体中会多一个结构体指针变量，用来存储前一个节点的地址。

在这里插入图片描述

带头或者不带头：带头与不带头的区别就是链表最开始的时候会有一个头节点，这个节点不用来存储数据，仅仅作为链表的头部使用，还是一个节点都没有。

在这里插入图片描述

循环或者非循环：非循环链表的最后一个节点的指针指向NULL，而循环链表的最后一个节点的next指向链表的第一个节点。

在这里插入图片描述

3. 最常用的两种链表

虽然链表有这么多种结构，但是我们实际上最常用还是以下两种结构：无头单向非循环链表和带头双向循环链表。

无头单向非循环链表

无头单向非循环链表结构最简单，一般不会单独用来存数据，实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等；另外这种结构在笔试面试题中出现很多；如果不做特殊声明，单链表一般情况下指的就是无头单向非循环链表

在这里插入图片描述

带头双向循环链表

带头双向循环链表结构最复杂，一般用于单独存储数据；实际中我们使用的链表数据结构，都是带头双向循环链表；虽然它结构最复杂，但是使用代码实现最简单，使用起来最方便省心。

在这里插入图片描述

二、单链表的实现

1.单链表结点的定义

与顺序表一样，单链表也需要一个变量data来记录数据，且我们应该对data的类型重命名，使得我们的链表可以管理不同类型的数据；其次，由于单链表中需要存储下一个节点的地址，所以我们应该有一个指向结构体的指针。

typedef int SLTDataType;

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

2. 创建新结点

由于单链表的每一个节点都需要单独开辟，所以我们可以把创建节点封装成一个函数，避免在头插、尾插、任意位置插入这些位置重复实现。

需要注意的是，由于我们这里实现的单链表是不带头的，即单链表一开始就是空的，所以我们并不需要对其进行初始化操作，只需要定义一个指向NULL节点指针 plist 即可。

SListNode* BuyNewNode(SLTDataType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

3. 头插

特别注意：不管我们在什么地方插入数据，我们都需要传递二级指针，因为链表一开始是空的，所以我们在插入第一个数据的时候需要让 plist 指向我们新开辟的这一个节点，即头结点；而我们知道，这里的 plist 是一个结构体指针变量，我们想要改变它，让它从 NULL 变为第一个节点的地址，就需要传递结构体指针的地址，即二级指针才能实现。

其次，我们在改变节点中的next指针的时候使用的是结构体指针，即一级指针，并没有用到二级指针，这是因为我们修改节点中的next是改变结构体，而要改变结构体我们只需要使用结构体指针即可，而不用像上面修改结构体指针一样使用二级指针。

同时，结构体指针的地址是一定不为空的，因为即使是链表为空即 plist == NULL 的时候，&plist 也不等于空，所以我们需要对 pphead 进行断言；而链表又是可能为空的，所以我们不需要对 *pphead (即 plist) 进行断言。

如果我们使用带头节点的单链表就不需要传递二级指针，因为不管我们对链表进行什么操作，头指针都始终不会改变。

void SListPushFront(SListNode** pphead, SLTDataType x)
{
	assert(pphead);
	SListNode* newnode = BuyNewNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

4. 尾插

在尾部插入数据我们需要先找到的尾结点，因为我们需要让尾结点的next指针指向新开辟的节点，而我们的单链表只能找到下一个节点的地址，想要找到尾结点需要从头开始遍历，所以单链表尾插的效率是比较低的，时间复杂度为O(N)。

void SListPushBack(SListNode** pphead, SLTDataType x)
{
	assert(pphead);
	if (*pphead == NULL)
	{
		*pphead = BuyNewNode(x);
		return;
	}
	SListNode* tail = *pphead;
	while (tail->next)
	{
		tail = tail->next;
	}
	tail->next = BuyNewNode(x);
}

5. 按值查找

查找数据不会改变头指针，所以我们只需要传递一级指针。

SListNode* SListFind(SListNode* phead, SLTDataType x)
{
	while (phead)
	{
		if (phead->data == x)
		{
			return phead;
		}
		phead = phead->next;
	}
	return phead;
}

6. 在pos位置前插

和尾插一样，我们需要从头遍历链表，找到 pos 节点的前一个节点，让该节点的next指向新开辟的节点，新开辟的结点再指向pos结点，使得链表成功链接。

//在pos位置前插入数据
void SListInsert(SListNode** pphead, SListNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)  //如果pos等于*pphead，相当于头插
	{
		SListPushFront(pphead, x);
		return;
	}

	SListNode* newNode = BuyNewNode(x);
	//找到pos位置的前一个节点
	SListNode* prev = *pphead;
	while (prev->next != pos)
	{
		assert(prev->next);  //如果prev->next为空循环还没停止，说明在链表中找不到pos，直接报错
		prev = prev->next;
	}
	prev->next = newNode;
	newNode->next = pos;
}

7. 在pos位置后插

由于单链表在某一节点的前面插入数据时需要从头遍历寻找该节点的前一个节点，导致时间复杂度为O(N)，所以人们为了提高单链表的效率，为单链表单独设计了在pos位置后插入数据的函数；除了单链表，其他数据结构插入数据都是在前面插入。

void SListInsertAfter(SListNode* pos, SLTDataType x)
{
	assert(pos);
	SListNode* temp = BuyNewNode(x);
	temp->next = pos->next;
	pos->next = temp;
}

8. 头删

特别注意：和插入数据一样，因为我们删除的可能是链表中的最后一个数据，即可能会改变 plist 的指向 (让 plist 重新指向 NULL)，所以不管我们在什么地方删除数据，都需要传递二级指针。

其次，由于我们这里是删除数据，所以函数调用者需要保证调用此函数时链表中至少是含有一个数据的；所以我们对 *pphead (等价于 plist) 进行断言，当调用者错误使用此函数时，我们直接报错并结束程序。

void SListPopFront(SListNode** pphead)
{
	assert(pphead && *pphead);
	SListNode* temp = *pphead;
	*pphead = (*pphead)->next;
	free(temp);
}

9. 尾删

在尾部删除数据面临着和尾插一样的问题，需要改变前一个节点的next指针，所以时间复杂度也为O(N)。

void SListPopBack(SListNode** pphead)
{
	assert(pphead);
	SListNode* temp = *pphead;
	if (*pphead == NULL)
	{
		printf("单链表为空，删除失败！\n");
		return;
	}
	if ((*pphead)->next == NULL)
	{
		*pphead = NULL;
		free(temp);
		return;
	}
	while (temp->next->next)
	{
		temp = temp->next;
	}
	SListNode* tail = temp->next;
	temp->next = NULL;
	free(tail);
}

10. 删除pos位置后的结点

void SListEraseAfter(SListNode* pos)
{
	assert(pos && pos->next);
	SListNode* temp = pos->next;
	pos->next = temp->next;
	free(temp);
}

11. 打印链表

打印数据也不会改变头指针，所以这里传一级指针；当链表为空的时候我们打印的逻辑也是正常的，只是说调用此函数什么都不打印而已，但是我们不能对其断言让其为空时报错。

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

12. 销毁链表

销毁链表需要将 plist 置为空，所以这里我们传递二级指针。

void SListDestroy(SListNode* plist)
{
	if (plist == NULL)
	{
		return;
	}
	while (plist)
	{
		SListPopFront(&plist);
	}
}

三、完整代码

1. single_list.h

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int SLTDataType;

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

//打印单链表
void PrintSList(SListNode* phead);

//单链表头插
void SListPushFront(SListNode** pphead, SLTDataType x);

//单链表头删
void SListPopFront(SListNode** pphead);

//单链表尾插
void SListPushBack(SListNode** pphead, SLTDataType x);

//单链表尾删
void SListPopBack(SListNode** pphead);

//单链表查找
SListNode* SListFind(SListNode* phead, SLTDataType x);

//单链表在pos位置之前插入x
void SListInsert(SListNode** pphead, SListNode* pos, SLTDataType x);

//单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDataType x);

//单链表删除pos位置之后的结点
void SListEraseAfter(SListNode* pos);

//销毁单链表
void SListDestroy(SListNode* plist);

2. single_list.c

#include"single_list.h"

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

SListNode* BuyNewNode(SLTDataType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

void SListPushFront(SListNode** pphead, SLTDataType x)
{
	assert(pphead);
	SListNode* newnode = BuyNewNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

void SListPopFront(SListNode** pphead)
{
	assert(pphead && *pphead);
	SListNode* temp = *pphead;
	*pphead = (*pphead)->next;
	free(temp);
}

void SListPushBack(SListNode** pphead, SLTDataType x)
{
	assert(pphead);
	if (*pphead == NULL)
	{
		*pphead = BuyNewNode(x);
		return;
	}
	SListNode* tail = *pphead;
	while (tail->next)
	{
		tail = tail->next;
	}
	tail->next = BuyNewNode(x);
}

void SListPopBack(SListNode** pphead)
{
	assert(pphead);
	SListNode* temp = *pphead;
	if (*pphead == NULL)
	{
		printf("单链表为空，删除失败！\n");
		return;
	}
	if ((*pphead)->next == NULL)
	{
		*pphead = NULL;
		free(temp);
		return;
	}
	while (temp->next->next)
	{
		temp = temp->next;
	}
	SListNode* tail = temp->next;
	temp->next = NULL;
	free(tail);
}

SListNode* SListFind(SListNode* phead, SLTDataType x)
{
	while (phead)
	{
		if (phead->data == x)
		{
			return phead;
		}
		phead = phead->next;
	}
	return phead;
}

void SListInsert(SListNode** pphead, SListNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)  //如果pos等于*pphead，相当于头插
	{
		SListPushFront(pphead, x);
		return;
	}

	SListNode* newNode = BuyNewNode(x);
	//找到pos位置的前一个节点
	SListNode* prev = *pphead;
	while (prev->next != pos)
	{
		assert(prev->next);  //如果prev->next为空循环还没停止，说明在链表中找不到pos，直接报错
		prev = prev->next;
	}
	prev->next = newNode;
	newNode->next = pos;
}

void SListInsertAfter(SListNode* pos, SLTDataType x)
{
	assert(pos);
	SListNode* temp = BuyNewNode(x);
	temp->next = pos->next;
	pos->next = temp;
}

void SListEraseAfter(SListNode* pos)
{
	assert(pos && pos->next);
	SListNode* temp = pos->next;
	pos->next = temp->next;
	free(temp);
}

void SListDestroy(SListNode* plist)
{
	if (plist == NULL)
	{
		return;
	}
	while (plist)
	{
		SListPopFront(&plist);
	}
}

3. test.c

#include"single_list.h"

void TestSList1()
{
	SListNode* plist = NULL;
	
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 4);
	SListPushFront(&plist, 5);
	PrintSList(plist);

	SListPopFront(&plist);
	SListPopFront(&plist);
	SListPopFront(&plist);
	PrintSList(plist);
}

void TestSList2()
{
	SListNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPushBack(&plist, 5);
	PrintSList(plist);
	
	SListPopBack(&plist);
	SListPopBack(&plist);
	SListPopBack(&plist);
	PrintSList(plist);
}

void TestSList3()
{
	SListNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPushBack(&plist, 5);
	PrintSList(plist);
	SListInsertAfter(SListFind(plist, 2), 20);
	SListInsertAfter(SListFind(plist, 3), 30);
	SListInsertAfter(SListFind(plist, 4), 40);
	PrintSList(plist);
	SListEraseAfter(SListFind(plist, 1));
	SListEraseAfter(SListFind(plist, 20));
	SListEraseAfter(SListFind(plist, 30));
	PrintSList(plist);
	SListDestroy(plist);
	plist = NULL;
}

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

四、单链表的缺陷

这一节中我们学习了单链表，但是我们发现单链表有如下缺陷：

1、在尾部插入、删除数据时间复杂度为O(N)，效率低；

2、在pos位置前插入、删除数据时间复杂度为O(N)，效率低；

3、进行插入、删除数据时因为有可能改变头指针，所以需要传递二级指针，不易理解；

为了解决单链表的这些缺陷，我们设计出了带头双向循环链表，带头双向循环链表能够完美地解决单链表所存在的所有缺陷。

岸边露伴'

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
【数据结构】单链表的增删查改

在上一节中我们提到了顺序表有如下缺陷：在头部/中间的插入与删除需要挪动数据，时间复杂度为O(N)，效率低；增容需要申请新空间，可能会拷贝数据，释放旧空间，会有不小的时间消耗；增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到 200，如果我们再继续插入了5个数据，后面没有数据插入了，那么会浪费95个数据空间；基于顺序表的这些不足，我们设计出了链表。
复制链接

扫一扫