【数据结构】第三站：单链表

青色_忘川

已于 2023-10-15 23:50:01 修改

阅读量1k

点赞数 18

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

于 2023-03-17 23:40:42 首次发布

本文链接：https://blog.csdn.net/jhdhdhehej/article/details/129585713

版权

【数据结构】专栏收录该内容

17 篇文章 5 订阅

订阅专栏

一、顺序表的缺陷

在上一篇文章中，我们了解了顺序表的结构以及他的接口的实现。但同时我们也发现了他的一些缺陷

问题：
1. 中间/头部的插入删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
思考：如何解决以上问题呢？下面给出了链表的结构来看看

二、链表

1.链表的概念以及结构

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

2.链表的分类

链表一共有八种类型，他们可由是单向还是双向，是循环还是非循环，是带头结点还是不带头结点进行排列组合出八种结构

虽然有很多种结构，但是只有两种最为常用

无头单向非循环链表和带头双向循环链表

这里我们先只需要了解无头单向非循环链表，其他链表后续了解

3.单链表的逻辑结构与物理结构

如下图所示，是链表的实际的物理结构与逻辑结构。物理结构就是实实在在数据在内存中的变化，逻辑结构就是为了方便理解，形象化出来的

三、单链表的实现

1.单链表的定义

typedef int SLTDateType;

typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;
如上代码所示，单链表有数据域和指针域两部分组成，指针是用于指向下一个结点的指针

2.单链表的接口定义

//单链表的打印
void SListPrint(SListNode* plist);
//单链表的尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
//单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
//单链表的尾删
void SListPopBack(SListNode** pplist);
//单链表的头删
void SListPopFront(SListNode** pplist);
//单链表的查找
SListNode* SListFind(SListNode* plist,SLTDateType x);
//单链表在pos位置之后插入
void SListInsertAfter(SListNode* pos, SLTDateType x);
//单链表在pos位置之前插入
void SListInsertPrev(SListNode** pplist, SListNode* pos, SLTDateType x);
//单链表在pos之后删除
void SListEraseAfter(SListNode* pos);
//单链表在pos之前删除
void SListErasePrev(SListNode** pplist, SListNode* pos);
//单链表在pos位置删除
void SListErase(SListNode** pplist, SListNode* pos);
//单链表的销毁
void SListDestroy(SListNode** pplist);

如上代码所示，是我们的单链表需要实现的接口，对于链表和顺序表一样都是为了实现数据的管理，区别就是前者是离散的，后者是连续的。我们的目的还是增删查改

3.单链表的接口实现

1.单链表的打印
//单链表的打印
void SListPrint(SListNode* plist)
{
	SListNode* cur = plist;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}
我们先来完成单链表的打印，对于单链表的打印，还是比较简单的，只需要先将头结点的指针给保存下来，然后依次去遍历单链表即可

2.单链表的尾插以及获取结点函数
//获取一个结点
SListNode* BuySListNode(SLTDateType x)
{
	SListNode* tmp = (SListNode*)malloc(sizeof(SListNode));
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
	tmp->next = NULL;
	tmp->data = x;
	return tmp;
}

//单链表的尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* newnode = BuySListNode(x);
	if (*pplist == NULL)
	{
		*pplist = newnode;
		return;
	}
	SListNode* tail = (*pplist);
	while (tail->next != NULL)
	{
		tail = tail->next;
	}
	tail->next = newnode;
}
对于单链表的尾插，我们要特别注意了。pplist是单链表头结点的地址，所以一定不为空

首先是获取结点，我们为了方便，先直接将其封装为一个函数。

有了结点了，那么我们还要思考如何尾插，那么我们先完成一般情况，假设已经有了一个很长的单链表了，我们还想要继续尾插一个值，那么只需要先找到原来的尾结点，然后将尾结点和新结点进行链接即可

当然还是存在一些特殊情况的，比如说原来的单链表压根就没有尾结点，也就是说链表是空的，那么上面的一般方法肯定行不通，这里其实就需要特殊处理一下，直接将新节点和链表头链接起来即可

3.单链表的头插
//单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* newnode = BuySListNode(x);
	SListNode* first = *pplist;
	*pplist = newnode;
	newnode->next = first;
}
对于单链表的头插，就比较简单了，我们直接创建一个新结点，然后记录下原来的第一个结点的地址，然后让链表头与新节点链接起来，然后新节点与原来的第一个结点链接起来，这里我们会发下，其实是不需要处理空链表的情况的，这里体现了单链表适合头插

4.单链表的尾删
//单链表的尾删
void SListPopBack(SListNode** pplist)
{
	assert(pplist);
	assert(*pplist);
	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		SListNode* tail = *pplist;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}
对于单链表的尾删，我们要想清楚了，首先是一般情况，当链表很长的时候，我们想要删除最后一个结点，那么得先找到前一个结点，然后释放最后一个结点，最后让前一个结点指向空。

我们还需要注意链表为空的状态，这个肯定是不可以删除的，所以我们直接断言掉。

然后是链表为一个结点的情况，如果链表只有一个结点，那么我们会发现，压根找不到前一个结点，所以我们也特殊处理，我们直接释放掉第一个结点，然后置空即可。

5.单链表的头删
//单链表的头删
void SListPopFront(SListNode** pplist)
{
	assert(pplist);
	assert(*pplist);

	SListNode* second = (*pplist)->next;
	free(*pplist);
	*pplist = second;
}
对于单链表的头删，我们同样断言掉链表为空的状态

然后我们需要做的就是记录第二个结点，然后释放原来的第一个结点，最后连接链表头和第二个结点。这样我们就实现了我们的目的。值得注意的是，我们发现链表的头删也是比较有优势的。

6.单链表的查找
//单链表的查找
SListNode* SListFind(SListNode* plist,SLTDateType x)
{
	SListNode* cur = plist;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
对于单链表的查找，这个也很简单，他和单链表的打印思路是一样的，不同的是只需要返回结点的地址即可。

7.单链表在pos位置之后的插入
//单链表在pos位置之后插入
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);
	SListNode* newnode = BuySListNode(x);
	SListNode* next = pos->next;
	pos->next = newnode;
	newnode->next = next;
}
单链表在pos位置之后的插入也是比较简单的，我们只需要先申请一个结点，然后记录pos位置的下一个结点，然后连接就可以了。值得注意的是，pos的位置不可能为空。因为他不是一个有效的结点地址

8.单链表在pos位置之前的插入
//单链表在pos位置之前插入
void SListInsertPrev(SListNode** pplist, SListNode* pos, SLTDateType x)
{
	assert(pplist);
	assert(pos);
	assert(*pplist);

	SListNode* newnode = BuySListNode(x);
	if (*pplist == pos)
	{
		*pplist = newnode;
		newnode->next = pos;
	}
	else
	{
		SListNode* prev = *pplist;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = newnode;
		newnode->next = pos;
	}
}
对于在pos位置之前的插入，确实是比较繁琐了。我们要思考，首先pos和pplist不可能为空，然后这个链表也是不可能为空链表的，至少也要有一个值。否则如果存在pos这个结点呢？

然后我们在来考虑一般情况，我们假设链表很长，在中间位置pos之前插入一个结点，那么毫无疑问的是，我们需要先申请一个结点，然后在通过遍历的方式要找到pos之前的那个结点。

有了这两个结点，那么我们就可以进行连接了。

然后是特殊情况，假如这个链表只有一个结点呢，这个结点正好就是pos，我们发现pos就没有前一个结点，其实这个就等效于头插。我们采用头插的方式即可

9.单链表在pos之后删除
//单链表在pos之后删除
void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	assert(pos->next);
	SListNode* next = pos->next;
	pos->next = next->next;
	free(next);
	next = NULL;
}
单链表在pos之后删除的话，首先pos和pos的下一个结点不会为空，否则题目就矛盾了。所以我们得断言，然后我们直接记录pos 的下一个结点，然后连接pos和pos之后的结点。最后释放掉pos的下一个结点即可。

10.单链表在pos之前删除
//单链表在pos之前删除
void SListErasePrev(SListNode** pplist, SListNode* pos)
{
	assert(pos);
	assert(pplist);
	assert(pos != *pplist);
	assert(*pplist);

	if ((*pplist)->next == pos)
	{
		SListNode* del = *pplist;
		*pplist = pos;
		free(del);
		del = NULL;
	}
	else
	{
		SListNode* prev = *pplist;
		while (prev->next->next != pos)
		{
			prev = prev->next;
		}
		SListNode* del = prev->next;
		prev->next = pos;
		free(del);
		del = NULL;
	}
}
对于单链表在pos之前删除确实就比较复杂了，首先pos，pplist，*pplist肯定不可能为空，然后pos也绝不可以是头节点，所以pos！=*pplist

我们现在来思考，假设一般情况，链表很长，在中间位置是pos，删除pos的前一个结点，那么我们就需要找到pos 的前一个的前一个结点。然后记录pos的前一个结点。释放pos 的前一个结点，然后进行连接即可

对于特殊情况，也就是，pos在第二个结点上，这样我们无法找到pos的前一个的前一个结点，但是这个就是头删，我们直接采用类似的思路即可

11.单链表在pos位置的删除
//单链表在pos位置删除
void SListErase(SListNode** pplist, SListNode* pos)
{
	assert(pplist);
	assert(pos);
	assert(*pplist);
	
	if (*pplist == pos)
	{
		free(pos);
		*pplist = pos = NULL;
	}
	else
	{
		SListNode* prev = *pplist;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
这个与上一个接口是基本一致的思路。不同的是，pos可以在头结点了，如果是头节点就是头删。

如果不是，就是先找到前一个结点，然后进行删除连接即可

12.单链表的销毁
//单链表的销毁
void SListDestroy(SListNode** pplist)
{
	SListNode* cur = *pplist;
	while (cur != NULL)
	{
		SListNode* next = cur->next;
		free(cur);
		cur = next;
	}
}
对于单链表的销毁，这个也很简单，就直接遍历销毁即可，与打印和查找的思路是一致的

四、单链表的实现完整代码

SList.h文件

#pragma once

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

typedef int SLTDateType;

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

//单链表的打印
void SListPrint(SListNode* plist);
//单链表的尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
//单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
//单链表的尾删
void SListPopBack(SListNode** pplist);
//单链表的头删
void SListPopFront(SListNode** pplist);
//单链表的查找
SListNode* SListFind(SListNode* plist,SLTDateType x);
//单链表在pos位置之后插入
void SListInsertAfter(SListNode* pos, SLTDateType x);
//单链表在pos位置之前插入
void SListInsertPrev(SListNode** pplist, SListNode* pos, SLTDateType x);
//单链表在pos之后删除
void SListEraseAfter(SListNode* pos);
//单链表在pos之前删除
void SListErasePrev(SListNode** pplist, SListNode* pos);
//单链表在pos位置删除
void SListErase(SListNode** pplist, SListNode* pos);
//单链表的销毁
void SListDestroy(SListNode** pplist);

SList.c文件

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

//单链表的打印
void SListPrint(SListNode* plist)
{
	SListNode* cur = plist;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

//获取一个结点
SListNode* BuySListNode(SLTDateType x)
{
	SListNode* tmp = (SListNode*)malloc(sizeof(SListNode));
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
	tmp->next = NULL;
	tmp->data = x;
	return tmp;
}

//单链表的尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* newnode = BuySListNode(x);
	if (*pplist == NULL)
	{
		*pplist = newnode;
		return;
	}
	SListNode* tail = (*pplist);
	while (tail->next != NULL)
	{
		tail = tail->next;
	}
	tail->next = newnode;
}

//单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* newnode = BuySListNode(x);
	SListNode* first = *pplist;
	*pplist = newnode;
	newnode->next = first;
}

//单链表的尾删
void SListPopBack(SListNode** pplist)
{
	assert(pplist);
	assert(*pplist);
	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		SListNode* tail = *pplist;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

//单链表的头删
void SListPopFront(SListNode** pplist)
{
	assert(pplist);
	assert(*pplist);

	SListNode* second = (*pplist)->next;
	free(*pplist);
	*pplist = second;
}

//单链表的查找
SListNode* SListFind(SListNode* plist,SLTDateType x)
{
	SListNode* cur = plist;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
//单链表在pos位置之后插入
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);
	SListNode* newnode = BuySListNode(x);
	SListNode* next = pos->next;
	pos->next = newnode;
	newnode->next = next;
}
//单链表在pos位置之前插入
void SListInsertPrev(SListNode** pplist, SListNode* pos, SLTDateType x)
{
	assert(pplist);
	assert(pos);
	assert(*pplist);

	SListNode* newnode = BuySListNode(x);
	if (*pplist == pos)
	{
		*pplist = newnode;
		newnode->next = pos;
	}
	else
	{
		SListNode* prev = *pplist;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = newnode;
		newnode->next = pos;
	}
}
//单链表在pos之后删除
void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	assert(pos->next);
	SListNode* next = pos->next;
	pos->next = next->next;
	free(next);
	next = NULL;
}
//单链表在pos之前删除
void SListErasePrev(SListNode** pplist, SListNode* pos)
{
	assert(pos);
	assert(pplist);
	assert(pos != *pplist);
	assert(*pplist);

	if ((*pplist)->next == pos)
	{
		SListNode* del = *pplist;
		*pplist = pos;
		free(del);
		del = NULL;
	}
	else
	{
		SListNode* prev = *pplist;
		while (prev->next->next != pos)
		{
			prev = prev->next;
		}
		SListNode* del = prev->next;
		prev->next = pos;
		free(del);
		del = NULL;
	}
}
//单链表在pos位置删除
void SListErase(SListNode** pplist, SListNode* pos)
{
	assert(pplist);
	assert(pos);
	assert(*pplist);
	
	if (*pplist == pos)
	{
		free(pos);
		*pplist = pos = NULL;
	}
	else
	{
		SListNode* prev = *pplist;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
//单链表的销毁
void SListDestroy(SListNode** pplist)
{
	SListNode* cur = *pplist;
	while (cur != NULL)
	{
		SListNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

Test.c文件

#define _CRT_SECURE_NO_WARNINGS 1

#include"Slist.h"

void TestSList1()
{
	SListNode* phead = NULL;
	SListPushBack(&phead, 1);
	SListPushBack(&phead, 2);
	SListPushBack(&phead, 3);
	SListPushBack(&phead, 4);
	SListPushBack(&phead, 5);
	SListPrint(phead);

	SListPushFront(&phead, 6);
	SListPushFront(&phead, 7);
	SListPushFront(&phead, 8);
	SListPushFront(&phead, 9);
	SListPushFront(&phead, 10);
	SListPrint(phead);

	SListPopBack(&phead);
	SListPopBack(&phead);
	SListPopBack(&phead);
	SListPopBack(&phead);
	SListPrint(phead);
	SListPopBack(&phead);
	SListPrint(phead);

	

}
void TestSList2()
{
	SListNode* phead = NULL;
	SListPushBack(&phead, 1);
	SListPushBack(&phead, 2);
	SListPushBack(&phead, 3);
	SListPushBack(&phead, 4);
	SListPushBack(&phead, 5);
	SListPrint(phead);

	SListPopFront(&phead);
	SListPopFront(&phead);
	SListPopFront(&phead);
	SListPopFront(&phead);
	SListPrint(phead);
	SListPopFront(&phead);
	SListPrint(phead);
}
void TestSList3()
{
	SListNode* phead = NULL;
	SListPushBack(&phead, 1);
	SListPushBack(&phead, 2);
	SListPushBack(&phead, 3);
	SListPushBack(&phead, 4);
	SListPushBack(&phead, 5);
	SListPrint(phead);

	SListNode* pos = SListFind(phead, 3);
	pos->data = 100;
	SListPrint(phead);
	SListInsertAfter(pos, 200);
	SListInsertAfter(pos, 300);
	SListInsertAfter(pos, 400);
	SListInsertAfter(pos, 500);
	SListPrint(phead);

	SListNode* pos2 = SListFind(phead, 1);
	SListInsertPrev(&phead, pos2, 101);
	SListInsertPrev(&phead, pos2, 102);
	SListInsertPrev(&phead, pos2, 103);
	SListInsertPrev(&phead, pos2, 104);
	SListPrint(phead);

	SListEraseAfter(pos2);
	SListEraseAfter(pos2);
	SListEraseAfter(pos2);
	SListPrint(phead);
	

}


void TestSList4()
{
	SListNode* phead = NULL;
	SListPushBack(&phead, 1);
	SListPushBack(&phead, 2);
	SListPushBack(&phead, 3);
	SListPushBack(&phead, 4);
	SListPushBack(&phead, 5);
	SListPrint(phead);

	SListNode* pos = SListFind(phead, 5);

	SListErasePrev(&phead, pos);
	SListPrint(phead);
	SListErasePrev(&phead, pos);
	SListPrint(phead);


	SListErase(&phead, pos);
	SListPrint(phead);

	SListDestroy(&phead);
}

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

本节内容到此位置，感谢您的阅读

如果对你有帮助的话，不要忘记点赞加收藏哦！！！