刷爆链表（一）—— 链表一通则百通

1. 链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
结构：链表一共有八种结构。
对于链表的性质，有带头和不带头，循环和非循环，单向或双向，2 * 2 * 2共八种。

1. 单向或者双向

2. 带头或者不带头

3. 循环或者非循环

其中无头单向不循环链表是基础，了解了这种链表的结构以及相关的数据操作后，其他种类的链表

实现起来就轻而易举了。

带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都
是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带
来很多优势，实现反而简单了，后面我们代码实现了就知道了。

2.相关接口

SGL.h

#pragma once
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<assert.h>
using namespace std;
typedef int SLDataType;
typedef struct SLT
{
	SLDataType data;
	struct SLT* next;
}SLTNode;

//
void SLTPrint(SLTNode* phead);
void SLTPushFront(SLTNode** phead, SLDataType x);
void SLTPushBack(SLTNode** phead, SLDataType x);
// 单链表头删
void SLTPopFront(SLTNode** pphead);
// 单链表的尾删
void SLTPopBack(SLTNode** pplist);
SLTNode* SLFind(SLTNode* phead, SLDataType x);

// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
void SLInsertAfter(SLTNode* pos, SLDataType x);

void SLEraseAfter(SLTNode* pos);
void SLErase(SLTNode** pphead, SLTNode* pos);

void SLDestroy(SLTNode* phead);

SGL.c

• 链表打印

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

• 链表的初始化

由于经常要对数据进行插入，开辟新的节点，所以这里我们写一个BuySLNode函数，进行复用。

SLTNode* BuySLNode(SLDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc failed");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

• 链表头插

void Test2()
{
	SLTNode* SLT = NULL;
	SLTPushFront(&SLT, 1);
	SLTPushFront(&SLT, 2);
	SLTPushFront(&SLT, 3);
	SLTPushFront(&SLT, 4);
	SLTPushFront(&SLT, 5);
	}

void SLTPushFront(SLTNode** phead, SLDataType x)
{
	SLTNode* newnode = BuySLNode(x);
	newnode->next = *phead;
	*phead = newnode;
}

​注意看，这里使用了二级指针SLTNode** phead来接收，我们传给头插函数SLTPushFront
的参是 &SLT，作为SLTNode* 的指针变量。
因此，为了改变phead，必须使用二级指针来接收。

这里画个图来帮助童鞋们更好地理解。

形参只是实参的一份临时拷贝，要改变值，就传值的地址；
要改变地址，就传地址的地址。

• 链表尾插

void SLTPushBack(SLTNode** pphead, SLDataType x)
{
   SLTNode* tail = *pphead;
   while (tail->next!=NULL)
   {
   	tail = tail->next;
   }
   SLTNode* newnode = BuySLNode(x);
   tail->next = newnode;
}

• 链表头删

void SLTPopFront(SLTNode** pphead)
{
	//若空
	assert(*pphead);

	SLTNode* cur = *pphead;
	*pphead = (*pphead)->next;
	free(cur);
}

• 链表尾删

void SLTPopBack(SLTNode** pphead)
{
	assert(*pphead);

	//单节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next->next != NULL)
		{
			cur = cur->next;
		}
		free(cur->next);
		cur->next = NULL;
	}

}

• 查找元素

SLTNode* SLFind(SLTNode* phead, SLDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			puts("");
			printf("%p\n", cur);
			return cur;
		}
		cur = cur->next;
	}
	puts("");
	printf("not found\n");
	return NULL;
}

• 在pos位置后插入数据

void SLInsertAfter(SLTNode* pos, SLDataType x)
{
	SLTNode* newnode = BuySLNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

• 删pos位置数据

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

• 删除pos后的节点数据

这里要考虑的问题无非就是一个节点越界访问和多个节点的问题。

void SLEraseAfter(SLTNode* pos)
{
	//漏了判断空
	assert(pos);
	//单节点删什么删
	assert(pos->next);
	SLTNode* cur = pos->next;
	pos->next = pos->next->next;
	free(cur);
}

• 链表销毁

void SLDestroy(SLTNode* phead)
{
   phead->next = NULL;
   free(phead);
}

• 测试

void Test2()
{
	SLTNode* SLT = NULL;
	SLTPushFront(&SLT, 1);
	SLTPushFront(&SLT, 2);
	SLTPushFront(&SLT, 3);
	SLTPushFront(&SLT, 4);
	SLTPushFront(&SLT, 5);

	SLTNode* pos = SLFind(SLT, 3);
	SLInsertAfter(pos, 999);
	SLTPrint(SLT);

	//删后一个
	SLTNode* pos2 = SLFind(SLT, 5);
	SLEraseAfter(pos2);
	SLTPrint(SLT);

	//删当前
	SLTNode* pos3 = SLFind(SLT, 1);
	SLErase(&SLT, pos3);
	SLTPrint(SLT);
	SLDestroy(SLT);
}

int main()
{
	//Test1();
	Test2();
	return 0;
}

结果：

总结

链表这块的知识重点在于理清链表的结构，多多练习才是王道。

结语

创作不易，如有帮助请三连支持(๑╹◡╹)ﾉ"“”