请回答数据结构【单链表】

0. Intro

为什么我们要来引入链表？

我们说顺序表是有一定问题的：

⚡️ 顺序表里面数据的结构是连续的，每次要移动一个数据就要连带着移动好几个数据，这样带来的影响是会带来比较大的消耗，当我们做头插或中间插入删除时，挪动数组都将带来时间复杂度O（N）

⚡️ 同时我们会遇到要求增容的情况，那就要用到realloc，此时如果有空间就直接原地增容，也一定程度造成了消耗但是如果没有，就要找一个新的空间，然后拷贝数据，开辟新的空间，会造成更多消耗

⚡️ 增容的时候一般2倍来增，这会导致增容到后面翻好几次2倍之后会浪费很多空间，增容这种选择，增多增少都不好，增少了操作频繁，降低性能，增多了空间会浪费

总结：

顺序表有缺陷，当数据一多，会影响性能，导致消耗

于是链表应运而生

1.链表的概念

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

为什么链表能解决问题？

顺序表好比手表，如果不够长只能换个表带，这样代价很大，但是链表就比较特殊，仿佛一个链式带子，只要在链子后面再连一个链条就可以增长。

链表通过扣子互相来连接，c语言中通过指针互相链接

2.链表的优点与缺点

2.1 优点

🌿 不存在扩容代价，也不存在空间浪费，只需要按需申请空间

🌿 头插或者中间插，也不需要挪动数据了

2.2 缺点

链表致命的缺点就是不能用下标找到数据，所以链表再强也不能够取代顺序表，顺序表就可以通过下标找到数据。

总结：

两者相辅相承

3.链表分类

链表总的来说有八种链表结构，可以互相来组合

🌸 单向vs双向

🌸 带头vs不带头

🌸 循环vs非循环

我们本章分析单链表为主

4. 单链表的逻辑结构和物理结构：

4.1 单链表的逻辑结构

链表结点分为两部分，上层用于存储数据 ; 下层用指针指向下一个结点,以达到连接目的

4.2 单链表的物理结构

链表的指针节点放下一个节点的地址，最后一个node的指针节点存放的地址是NULL，后面的节点地址完全有可能比前面的大或者小，不一定是按顺序递增的

现实中的数据结构

5.顺序表vs单链表开辟增容：

1. 顺序表是利用realloc一次性动态调整出一大块空间,所以这一大块空间中的每个单元,地址都是连续的。
2. 单链表每一次都是用的malloc开辟的一个空间,则每个空间的地址一定是不一样且不连续的（但是要搞清楚，malloc连续开辟一长段空间是连续的，只是当前是一次开辟一个）

6. 实现一个无头单链表

6.1 单链表需要的源文件与头文件

文件名	功能作用
SList.c	创建单链表，单链表主要函数的实现
SList.h	声明用头文件，实现每个函数的声明，用来引用
test.c	测试运行文件，主函数在这里

6.2 用结构体来创建一个单链表

图片来源于Crash Course Computer Science

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data; // val
	struct SListNode* next; // 存储下一个节点的地址
}SListNode, SLN;

无头单链表并不用初始化函数，和顺序表不一样，一开始的时候就是没有节点的

6.3 在写单链表之前

在书写单链表之前一定要记一下传参问题，形参的拷贝不影响实参
在PushBack中就会体现，就是如果或要改变一级指针，一定要通过二级指针才能改变phead，所以传phead的指针，即二级指针pphead才可以

还有一点是后面的代码，我们一定要去思考去得到更加健全的代码，也即是说要考虑全面

🌰 举一个Swap函数的栗子

我们都知道通常交换两个int需要通过指针交换

void SwapInt(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
int a = 0, b = 1;
	SwapInt(&a, &b);

那么显而易见的是如果我要改变int*类型的变量实现交换在c语言中，如果我不用cpp中的引用的话需要传二级指针

void SwapPInt(int** pp1, int** pp2)
{
	int* tmp = *pp1;
	*pp1 = *pp2;
	*pp2 = tmp;
}
// 函数中想改变实参int*变量，要传int**  
	int* pa = &a, * pb = &b;
	//SwapInt(pa, pb);//err
	SwapPInt(&pa, &pb);//right

因此比如说我要在链表中实现尾插，改变这个链表，我想改变的是SListNode* plist就要传入SListNode** plist

⛓ SListPrint

打印链表，这里我采用了cpp的cout，免得改了数据类型就输出不了

void SListPrint(SListNode* phead)
{//不用assert，因为链表可能一开始没有数据
	SListNode* cur = phead;
	while (cur != NULL)
	{
		//printf("%d->", cur->data);
			cout << cur->data<<"->";
		cur = cur->next;
	}
	printf("NULL\n");
}

⛓BuySListNode

为什么要写这个函数，也就是能够在后期晚上接口时能够做到复用，只要调用一下函数就可以加一个新节点
重点时这个

SListNode* BuySListNode(SLTDataType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	else
	{//init node
		newnode->data = x;
		newnode->next = NULL;
	}
	return newnode;
}

⛓ SListPushBack

尾插
先获取一个Node，然后判断是不是头，是头的话，只需要把链表的头节点指向newnode就可以了，若不是的话，需要遍历一遍找到链表的尾然后接入

void SListPushBack(SListNode** pphead, SLTDataType x)
{
    	assert(pphead);

	SListNode* newnode = BuySListNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
        // 错误写法，这里没有链接起来
		/*SListNode* tail = *pphead;
		while (tail != NULL)
		{
		tail = tail->next;
		}

		tail = newnode;*/
        
		// 正确写法find the tail node
		SListNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		//连接
		tail->next = newnode;
	}
}

⛓ SListPushFront

头插
单链表的头插就比顺序表高效且简单，不需要移动数据，

void SListPushFront(SListNode** pphead, SLTDataType x)
{
    	assert(pphead);
	SListNode* newnode = BuySListNode(x);
	//link
	newnode->next = *pphead;
	//new head
	*pphead = newnode;
}

⛓SListPopBack

尾删要判断情况

可能会存在如下三种情况

1. 空
2. 一个节点
3. 多个节点

下面先写一下对前两种方法的判断，其实对传空的判断建议不要assert，因为太暴力了，不过STL中的list倒是暴力的

	assert(pphead);//二级指针no传空
	// 暴力检查为空的情况
	//assert(*pphead != NULL);
	if (*pphead == NULL)  // 温柔检查
	{
		return;
	}
	else if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}

然后是对多个节点的处理，多节点其实可以有两种处理方式

其一，我们可以用两个指针，到尾之后同时记上前一个节点的位置，才可以

else
	{//一前一后两指针方式
		SListNode* prev = NULL;
		SListNode* tail = *pphead;
		while (tail->next != NULL)
		{
		prev = tail;
		tail = tail->next;
		}

		free(tail);
		tail = NULL;
		prev->next = NULL;
	}

其二，我们可以用next的next

	else
	{
       	        SListNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
    }

⛓ SListPopFront

头删也是要判断两种情况

1. 空
2. 非空

void SListPopFront(SListNode** pphead)
{
	assert(pphead);

	// 1、空
	// 2、非空
	if (*pphead == NULL)
		return;
	else
	{
		SListNode* next = (*pphead)->next;
		free(*pphead);
		*pphead = next;
	}
}

⛓ SListFind

查找

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

		cur = cur->next;
	}

	return NULL;
}

⛓ SListInsert(Before)

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

	// 1、pos是第一个节点
	// 2、pos不是第一个节点
	if (pos == *pphead)
	{//fu'yong
		SListPushFront(pphead, x);
	}
	else
	{
		SListNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		SListNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

⛓ SListInsert(After)

在给出的位置之后插入

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

⛓ SListErase

删除pos位置的值

头删要分开讨论

void SListErase(SListNode** pphead, SListNode* pos)
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		SListNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

⛓ SListEraseAfter

删除pos位置之后一个节点

void SListEraseAfter(SListNode* pos)
{
	assert(pos);

	SListNode* next = pos->next;
	if (next)//不要没有next
	{
		pos->next = next->next;
		free(next);
		next = NULL;
	}
}

⛓ SListDestroy

一个个释放就可以了，保存下一个，然后删除当前这个

void SListDestroy(SListNode** pphead)
{
	assert(pphead);

	SListNode* cur = *pphead;
	while (cur)
	{
		SListNode* next = cur->next;
		free(cur);
		cur = next;
	}

	*pphead = NULL;
}

7. 带头链表

带头节点的单链表，这个头通常又被叫做哨兵位，这个节点的特点就是它是一个不带值的空节点，那这个结构有什么特别的作用呢？

我们可以通过做题目来体会，不带头节点省去了我们有时候对传入指针为空值的判断，也就是不用判空

比如我之前博客中的一道题目https://blog.youkuaiyun.com/Allen9012/article/details/121171870，就提到了带头结点的作用

注意返回时返回头结点的next就可以了，提前保存一下next节点，可以free一下头节点

8. 顺序表 V.S. 链表

单链表的实现代码可至我的gitee库中查看https://gitee.com/allen9012/c-language/tree/master/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/%E5%8D%95%E9%93%BE%E8%A1%A82

注：部分图片来源于外网转载，如有侵权请联系我删除