【数据结构】单链表

最新推荐文章于 2024-08-16 21:49:16 发布

嘿BRE

最新推荐文章于 2024-08-16 21:49:16 发布

阅读量658

点赞数 27

文章标签：数据结构链表

本文链接：https://blog.csdn.net/HEBRE/article/details/137655805

版权

关于链表，我们引入一些关于顺序表的问题：

1. 中间/头部的插⼊删除，时间复杂度为O(N)

2. 增容需要申请新空间，拷⻉数据，释放旧空间。会有不⼩的消耗。

3. 增容⼀般是呈2倍的增⻓，势必会有⼀定的空间浪费。例如当前容量为100，满了以后增容到 200，我们再继续插⼊了5个数据，后⾯没有数据插⼊了，那么就浪费了95个数据空间。

为了解决这些问题，我们引入了链表以解决以上问题。

1.链表的概念及结构

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

链表的结构跟火车车厢相似，淡季时车次的⻋厢会相应减少，旺季时车次的车厢会额外增加几节。只需要将火车里的某节车厢去掉或加上，不会影响其他车厢，每节车厢都是独立存在的。

车厢独立存在，且每节车厢都有车门。想象⼀下这样的场景，假设每节车厢的车门都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从车头⾛到车尾？

最简单的做法：每节车厢里都放⼀把下⼀节车厢的钥匙。

与顺序表不同的是，链表里的每节"车厢"都是独立申请下来的空间，我们称之为“结点/节点”

节点的组成主要有两个部分：当前节点要保存的数据和保存下⼀个节点的地址（指针变量）。

图中指针变量 plist保存的是第⼀个节点的地址，我们称plist此时“指向”第⼀个节点，如果我们希望plist“指向”第⼆个节点时，只需要修改plist保存的内容为0x0012FFA0。

为什么还需要指针变量来保存下⼀个节点的位置？

链表中每个节点都是独立申请的（即需要插⼊数据时才去申请⼀块节点的空间），我们需要通过指针变量来保存下⼀个节点位置才能从当前节点找到下⼀个节点。

结合前⾯学到的结构体知识，我们可以给出每个节点对应的结构体代码：

假设当前保存的节点为整型：

struct SListNode
{
	int data; //节点数据
	struct SListNode* next; //指针变量⽤保存下⼀个节点的地址
};

当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数据，也需要保存下⼀个节点的地址（当下⼀个节点为空时保存的地址为空）。

当我们想要从第⼀个节点⾛到最后⼀个节点时，只需要在前⼀个节点拿上下⼀个节点的地址（下一个节点的钥匙）就可以了。

2.链表的特点

1、链式机构在逻辑上是连续的，在物理结构上不⼀定连续

2、节点⼀般是从堆上申请的

3、从堆上申请来的空间，是按照⼀定策略分配出来的，每次申请的空间可能连续，可能不连续

3.单链表的实现

关于单链表的实现，我们需要实现几个功能。

1.打印单链表

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

这里我们为了不改变原数据用pcur指向phead指针。

2.尾部插入

在尾部插入的时候，因为要利用形参改变实参的值，所以形参要传地址。所以应该将指针变量的地址传过去。同时我们要注意形参好实参对应的形式是怎么样的。

尾插时，我们要分两种情况，

1.链表本来就为空时，直接将头指针指向创建出的新节点newnode

2.链表中有节点时，则需要找到尾结点之后将新节点插入。

在完成这段代码之前，首先要定义一个SLBuyNode函数以创建一个新的节点。

SL* SLBuyNode(SLDataType x)
{
	SL* newnode = (SL*)malloc(sizeof(SL));
	if (newnode==NULL)
	{
		perror("malloc");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

接下来，就是写尾插代码：

void SLPushBack(SL** pphead, SLDataType x)
{
	assert(pphead);//pphead不能为空，否则就会导致之后的解引用失败
	SL* newnode = SLBuyNode(x);
	if (*pphead==NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾
	    SL* ptail = *pphead;
	    while (ptail->next)
	    {
	    	ptail = ptail->next;
	    }
	    ptail->next = newnode;
	}
}

3.头部插入

在写头插代码的时候同样要注意尾插的两种情况，但是两种情况都不影响我们代码的最终结果，所以不需要分情况讨论。

4.尾部删除

我们首先要断言将链表为空（链表为空就代表着没有可以尾删的节点）以及pphead为空的情况排除出去。

尾部删除也要分两种情况来写代码：

1.链表中有节点时，则需要我们释放最后一个节点，然后将最后一个节点之前的节点的next指向NULL。

2.链表中只有一个节时，则需要我们直接释放节点，然后将节点置为NULL。（这里不能直接用第一种情况的原因是第一种情况需要用到最后一个节点前一个节点，当链表中只有一个节点时，无法使用第一种情况）

void SLPopBack(SL** pphead)
{
	assert(pphead && *pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SL* ptail = *pphead;
		SL* ptailprevious = *pphead;
		while (ptail->next)
		{
			ptailprevious = ptail;
			ptail = ptail->next;
		}
		free(ptail);
		ptail = NULL;
		ptailprevious->next = NULL;
	}
}

5.头部删除

头部删除要注意需要先将第一个节点下一个节点的指针存起来，再进行第一个节点的释放，不然会出现信息丢失的问题。

void SLPopFront(SL** pphead)
{
	assert(pphead && *pphead);
	SL* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

6.查找

SL* SLFind(SL* pphead, SLDataType x)
{
	assert(pphead);
	SL* ptail = pphead;
	while (ptail)
	{
		if (ptail->data == x)
		{
			return ptail;
		}
		ptail = ptail->next;
	}
	return NULL;
}

7.在指定位置之前插入数据

在指定位置之前插入数据也有两种情况：

1.pos节点不是第一个节点，这时候需要我们找到pos节点的上一个节点prev节点再讲新节点插入到prev节点好pos节点之间。

2.pos节点为第一个节点，这时我们找不到pos节点上一个节点，那么直接调用头插的函数就可以了。

void SLInsert(SL** pphead, SL* pos, SLDataType x)
{
	assert(pphead && *pphead);//*pphead不能为空的原因是要在pos节点之前插入新节点所以必须存在一个pos节点
	assert(pos);
	if (pos==*pphead)
	{
		SLPushFront(pphead,x);
	}
	else
	{
		SL* newnode = SLBuyNode(x);
		SL* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		newnode->next = pos;
		prev->next = newnode;
	}
}

8.在指定位置之后插入数据

void SLInsertAfter(SL* pos, SLDataType x)
{
	assert(pos);
	SL* newnode = SLBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
	//注意，这两步不可以交换位置，因为如果交换位置就会造成pos->next的数值提前改变而影响后面的结果
}

注意，最后两步不可以交换位置，因为如果交换位置就会造成pos->next的数值提前改变而影响后面的结果。

9.删除pos节点

删除pos节点也有两种情况：

1.pos不是第一个节点，这时候需要找到pos节点之前的节点，然后将pos节点前后两个节点的指针连接起来，最后释放掉pos节点。

2.pos节点时第一个节点，我们直接使用头部删除代码就可以了。

void SLErase(SL** pphead, SL* pos)
{
	assert(*pphead && pphead);
	assert(pos);
	if (pos==*pphead)
	{
		SLPopFront(pphead);
	}
	else
	{
		SL* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

10.删除pos节点之后的节点

void SLEraseAfter(SL* pos)
{
	assert(pos && pos->next);
	SL* ptail = pos->next;
	pos->next=ptail->next;
	free(ptail);
	ptail = NULL;
}

这段代码要注意的是因为要出现pos下一个节点，需要将pos节点下一个节点断言一下。

11.销毁链表

销毁链表需要我们依次找到第一个节点并且将其删除。

void SLDesTroy(SL** pphead)
{
	assert(*pphead && pphead);
	SL* ptail = *pphead;
	while (ptail)
	{
		SL* next = ptail->next;
		free(ptail);
		ptail = NULL;
	}
	*pphead = NULL;
}

最后，我们看看整体代码：

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Slist.h"
void test02()
{
	SL* plist = NULL;
	//输入指令
	SLDesTroy(&plist);
}
int main()
{
	test02();
	return 0;
}

Slist.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Slist.h"
SL* SLBuyNode(SLDataType x)
{
	SL* newnode = (SL*)malloc(sizeof(SL));
	if (newnode==NULL)
	{
		perror("malloc");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
void SLPrint(SL* phead)
{
	SL* ptail = phead;
	while (ptail)
	{
		printf("%d->", ptail->data);
		ptail = ptail->next;
	}
	printf("NULL\n");
}
void SLPushBack(SL** pphead, SLDataType x)
{
	assert(pphead);//pphead不能为空，否则就会导致之后的解引用失败
	SL* newnode = SLBuyNode(x);
	if (*pphead==NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾
	    SL* ptail = *pphead;
	    while (ptail->next)
	    {
	    	ptail = ptail->next;
	    }
	    ptail->next = newnode;
	}
}

void SLPushFront(SL** pphead, SLDataType x)
{
	assert(pphead);
	SL* newnode = SLBuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
void SLPopBack(SL** pphead)
{
	assert(pphead && *pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SL* ptail = *pphead;
		SL* ptailprevious = *pphead;
		while (ptail->next)
		{
			ptailprevious = ptail;
			ptail = ptail->next;
		}
		free(ptail);
		ptail = NULL;
		ptailprevious->next = NULL;
	}
}
void SLPopFront(SL** pphead)
{
	assert(pphead && *pphead);
	SL* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}
SL* SLFind(SL* pphead, SLDataType x)
{
	assert(pphead);
	SL* ptail = pphead;
	while (ptail)
	{
		if (ptail->data == x)
		{
			return ptail;
		}
		ptail = ptail->next;
	}
	return NULL;
}
void SLInsert(SL** pphead, SL* pos, SLDataType x)
{
	assert(pphead && *pphead);//*pphead不能为空的原因是要在pos节点之前插入新节点所以必须存在一个pos节点
	assert(pos);
	if (pos==*pphead)
	{
		SLPushFront(pphead,x);
	}
	else
	{
		SL* newnode = SLBuyNode(x);
		SL* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		newnode->next = pos;
		prev->next = newnode;
	}
}
void SLInsertAfter(SL* pos, SLDataType x)
{
	assert(pos);
	SL* newnode = SLBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
	//注意，这两步不可以交换位置，因为如果交换位置就会造成pos->next的数值提前改变而影响后面的结果
}
void SLErase(SL** pphead, SL* pos)
{
	assert(*pphead && pphead);
	assert(pos);
	if (pos==*pphead)
	{
		SLPopFront(pphead);
	}
	else
	{
		SL* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
void SLEraseAfter(SL* pos)
{
	assert(pos && pos->next);
	SL* ptail = pos->next;
	pos->next=ptail->next;
	free(ptail);
	ptail = NULL;
}
void SLDesTroy(SL** pphead)
{
	assert(*pphead && pphead);
	SL* ptail = *pphead;
	while (ptail)
	{
		SL* next = ptail->next;
		free(ptail);
		ptail = NULL;
	}
	*pphead = NULL;
}

Slist.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>

typedef int SLDataType;

typedef struct SListNode {
	SLDataType data;
	struct SListNode* next;
}SL;
//打印
void SLPrint(SL* phead);
void SLPushBack(SL** pphead, SLDataType x);
void SLPushFront(SL** pphead, SLDataType x);
void SLPopBack(SL** pphead);
void SLPopFront(SL** pphead);
//查找
SL* SLFind(SL* pphead, SLDataType x);
//在指定位置之前插⼊数据
void SLInsert(SL** pphead, SL* pos, SLDataType x);
//在指定位置之后插⼊数据
void SLInsertAfter(SL* pos, SLDataType x);
//删除pos节点
void SLErase(SL** pphead, SL* pos);
//删除pos之后的节点
void SLEraseAfter(SL* pos);
//销毁链表
void SLDesTroy(SL** pphead);

嘿BRE

关注

27
点赞
踩
21

收藏

觉得还不错? 一键收藏
4
评论
【数据结构】单链表

关于链表，我们引入一些关于顺序表的问题：1. 中间/头部的插⼊删除，时间复杂度为O(N)2. 增容需要申请新空间，拷⻉数据，释放旧空间。会有不⼩的消耗。3. 增容⼀般是呈2倍的增⻓，势必会有⼀定的空间浪费。例如当前容量为100，满了以后增容到 200，我们再继续插⼊了5个数据，后⾯没有数据插⼊了，那么就浪费了95个数据空间。为了解决这些问题，我们引入了链表以解决以上问题。1.链表的概念及结构。
复制链接

扫一扫