链表基础操作汇总

一.包含头文件

#pragma once/*一个头文件仅仅会被包含一次，防止包含次数过多影响程序运行效率*/
#include<stdio.h>
#include<stdlib.h>/*于是可以调用malloc分配动态内存*/
#include<assert.h>/*用于断言某一处代码是否是正确的*/

二.细节问题解释

1）关于元素类型的定义

我们可以首先进行预定义把数据类型定义为一个新的名称SLTDataType，这样方便我们后续更改元素的类型，比如我们想把int改为float，这样只需要把int改为float即可，而无需在整段的代码中找到int改为float。

【这里可能有聪明的小朋友会说我们可以用全局关键词替换，但是可能有的int是我们本来就需要设置为int的类型，因此这么一键更改并不划算】

typedef int SLTDataType;

2）进行链表的插入删除等需要更改原链表的操作时

在主函数中需要传入的实参是SLTPushBack（&plist，1），在我们自己定义的函数中“大标题”应该写为，也就是二级指针，因为我们需要用二级指针来接受一级指针的地址，这样才能在根本上对我们的链表做出改变！

void SLTPushBack(SLTNode** pphead, SLTDataType x)

三.具体操作的实现和注释

1）打印链表

//打印链表
void SLTPrint(SLTNode* phead)/*传入需要打印的链表的头节点*/ 
{
	SLTNode* pcur = phead;/*用pcur接收phead，保证对链表遍历时不会使我们找不到原来的头节点了*/
	while (pcur)/*当没有指到NULL节点一直进行输出*/
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;/*pcur是指针，因此我们读取数据时用'->'而不是'.'*/
	}
	printf("NULL\n");
}

2）创建新的节点

//创建新的节点
SLTNode* SLTBuyNode(SLTDataType x) /*返回一个节点指针*/
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));/*动态申请一个新节点*/
	if (newnode == NULL) /*这一步是为了防止我们动态申请失败*/
    {
		perror("malloc fail!");/*打印出来malloc这一步失败的原因，perror是专门针对错误信息打印的输出操作*/
		exit(1);/*非正常退出程序运行*/
	}
	newnode->data = x;
	newnode->next = NULL;
	
	return newnode;
}

3）尾插一个节点

//尾插一个节点
void SLTPushBack(SLTNode** pphead, SLTDataType x) /*传入二级指针的表头*/
{
	assert(pphead);/*防止我们输入的二级指针是空指针*/
	
	SLTNode* newnode = SLTBuyNode(x);
	
	/*如果原链表为空，那么新节点就是头节点*/
	if (*pphead == NULL) {
		*pphead = newnode;/**pphead才是一级指针*/
		return;
	}

	/*原链表不为空，找尾节点*/
	SLTNode* ptail = *pphead;/*防止更改原链表的头节点进而丢失*/
	while (ptail->next)/*此时找到的ptail指向的next节点就是NULL*/
	{
		ptail = ptail->next;
	}
	/*ptail就是尾节点*/
	ptail->next = newnode;
}

4）头插一个节点

//头插一个节点
void SLTPushFront(SLTNode** pphead, SLTDataType x) 
{
	assert(pphead);/*防止输入空节点*/
	SLTNode* newnode = SLTBuyNode(x);
    /*直接新节点的next节点等于原本的头节点*/
	newnode->next = *pphead;
	*pphead = newnode;/*把头节点的位置更新为新节点*/
}

5）尾删一个节点

//尾删一个节点
void SLTPopBack(SLTNode** pphead) 
{
    /*防止输入的二级指针是NULL*/
	assert(pphead);
	/*既然尾删那么说明这个链表肯定也不能是空链表*/
	assert(*pphead);
	
	/*这个链表只有一个节点*/
	if ((*pphead)->next == NULL) {
		free(*pphead);/*首先释放这个节点*/
		*pphead = NULL;/*其次把这个节点置为空节点*/
		return;
	}
    /*这个链表不止是一个节点，那么去寻找尾节点*/
    /*先明确思路：我们需要找到尾节点的上一个节点，让上一个节点的next节点置为空，因此我么需要两个指针*/
	SLTNode* ptail = *pphead;/*用于寻找尾节点*/
	SLTNode* prev = NULL;/*记录next节点等于ptail的节点*/
	while (ptail->next)/*如果此时没有找到尾节点*/
	{
		prev = ptail;/*prev先存储现在的节点*/
		ptail = ptail->next;/*ptail继续往下进行寻找尾节点*/
	}
	
	prev->next = NULL;/*prev美美成为尾节点*/
	//销毁尾结点
	free(ptail);/*销毁原本尾节点*/
	ptail = NULL;
}

6）头删一个节点

//头删一个节点
void SLTPopFront(SLTNode** pphead) 
{
    /*依旧是二级和一级指针都不能为空*/
	assert(pphead);
	assert(*pphead);
	/*需要先存储第二个节点，用来成为头节点，NULL也没事*/
	SLTNode* next = (*pphead)->next;
	free(*pphead);/*释放原本头节点的元素*/
	*pphead = next;/*头节点的位置更改*/
}

7）查找等于x的节点

//查找等于x的节点
SLTNode* SLTFind(SLTNode** pphead, SLTDataType x) {
	assert(pphead);
	/*开始遍历链表*/
	SLTNode* pcur = *pphead;/*防止找不到头节点*/
	while (pcur) /*等价于pcur != NULL*/
	{
		if (pcur->data == x) {
			return pcur;
		}
		pcur = pcur->next;
	}
	/*没有找到*/
	return NULL;
}

8）在指定位置之前插入数据

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) 
{
	assert(pphead);/*防止二级指针是空指针*/
	assert(pos);/*需要加上的节点也不能是空节点*/
	assert(*pphead);/*既然是某一个位置插入数据了那么这个链表也肯定不能是空链表*/
	
	SLTNode* newnode = SLTBuyNode(x);
	/*pos刚好是头结点*/
	if (pos == *pphead) {
		/*直接调用咱的头插即可*/
		SLTPushFront(pphead, x);
		return;
	}
	
	/*pos不是头结点*/
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	/*说明此时的prev节点已经是我们需要插入的地方的之前的那个节点了*/
	prev->next = newnode;/*直接插入即可*/
	newnode->next = pos;/*新节点的next节点等于指定位置的节点*/
}

9）在指定位置之后插入节点

//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x) 
{
	assert(pos);/*防止这个需要插入之后的节点是空节点*/
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = pos->next;/*直接夹在中间就行*/
	pos->next = newnode;/*更新这个需要插入之后的这个节点的后节点*/
}

10）删除pos节点

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos) 
{
	/*既然删除某个节点，那么这个链表肯定不是空的*/
    assert(pphead);/*无论如何都需要判断的*/
	assert(*pphead);
	assert(pos);
	
	/*pos刚好是头结点，没有前驱节点，执行头删*/
	if (*pphead == pos) 
    {
		SLTPopFront(pphead);
		return;
	}
    
    /*不是头节点，目的是寻找pos之前的节点*/	
	SLTNode* prev = *pphead;
	while (prev->next != pos)/*只要next不是pos节点那么就用prev代替*/
	{
		prev = prev->next;
	}
	prev->next = pos->next;/*完美略过pos节点*/
	free(pos);
	pos = NULL;
}

11）删除pos之后的节点

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos) {
	assert(pos);/*不需要通过遍历原链表*/
	/*pos->next不能为空*/
	assert(pos->next);
    /*存储需要删除的点，不然就没有需要被释放的点了*/
	SLTNode* del = pos->next;
	pos->next = pos->next->next;/*其实也就是del->next*/
	free(del);
	del = NULL;
}

12）销毁链表

//销毁链表
void SListDesTroy(SLTNode** pphead) 
{
	assert(pphead);
	assert(*pphead);
	
	SLTNode* pcur = *pphead;
	while (pcur)
	{
        /*挨个释放*/
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

四.纯享版

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

//data的数据类型
typedef int SLTDataType;

//节点的结构体创建
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

//打印链表
void SLTPrint(SLTNode* phead) {
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

//创建新的节点
SLTNode* SLTBuyNode(SLTDataType x) {
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL) {
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	
	return newnode;
}

//尾插一个节点
void SLTPushBack(SLTNode** pphead, SLTDataType x) {
	assert(pphead);
	
	SLTNode* newnode = SLTBuyNode(x);
	
	//链表为空，新节点作为phead
	if (*pphead == NULL) {
		*pphead = newnode;
		return;
	}
	//链表不为空，找尾节点
	SLTNode* ptail = *pphead;
	while (ptail->next)
	{
		ptail = ptail->next;
	}
	//ptail就是尾节点
	ptail->next = newnode;
}

//头插一个节点
void SLTPushFront(SLTNode** pphead, SLTDataType x) {
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	
	//newnode *pphead
	newnode->next = *pphead;
	*pphead = newnode;
}

//尾删一个节点
void SLTPopBack(SLTNode** pphead) {
	assert(pphead);
	//链表不能为空
	assert(*pphead);
	
	//链表不为空
	//链表只有一个节点，有多个节点
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
		return;
	}
	SLTNode* ptail = *pphead;
	SLTNode* prev = NULL;
	while (ptail->next)
	{
		prev = ptail;
		ptail = ptail->next;
	}
	
	prev->next = NULL;
	//销毁尾结点
	free(ptail);
	ptail = NULL;
}

//头删一个节点
void SLTPopFront(SLTNode** pphead) {
	assert(pphead);
	//链表不能为空
	assert(*pphead);
	
	//让第二个节点成为新的头
	//把旧的头结点释放掉
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

//查找
SLTNode* SLTFind(SLTNode** pphead, SLTDataType x) {
	assert(pphead);
	
	//遍历链表
	SLTNode* pcur = *pphead;
	while (pcur) //等价于pcur != NULL
	{
		if (pcur->data == x) {
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) {
	assert(pphead);
	assert(pos);
	//要加上链表不能为空
	assert(*pphead);
	
	SLTNode* newnode = SLTBuyNode(x);
	//pos刚好是头结点
	if (pos == *pphead) {
		//头插
		SLTPushFront(pphead, x);
		return;
	}
	
	//pos不是头结点的情况
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	//prev -> newnode -> pos
	prev->next = newnode;
	newnode->next = pos;
}

//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x) {
	assert(pos);
	
	SLTNode* newnode = SLTBuyNode(x);
	
	//pos newnode pos->next
	newnode->next = pos->next;
	pos->next = newnode;
}
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos) {
	assert(pphead);
	assert(*pphead);
	assert(pos);
	
	//pos刚好是头结点，没有前驱节点，执行头删
	if (*pphead == pos) {
		//头删
		SLTPopFront(pphead);
		return;
	}
	
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	//prev pos pos->next
	prev->next = pos->next;
	free(pos);
	pos = NULL;
}
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos) {
	assert(pos);
	//pos->next不能为空
	assert(pos->next);
	
	//pos  pos->next  pos->next->next
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

//销毁链表
void SListDesTroy(SLTNode** pphead) {
	assert(pphead);
	assert(*pphead);
	
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

五.数组模拟链表

（一）用数组模拟单链表

#include<stdio.h>
const int N =100010;

// head存储链表头
//e[]存储节点的值
//ne[]存储节点的next指针
//idx表示当前用到了哪个节点
int head, e[N], ne[N], idx;

// 初始化
void init()
{
    head = -1;
    idx = 0;
}

// 在链表头插入一个数a
void insert(int a)
{
    e[idx] = a;/*能用的地方插入一个a*/
    ne[idx] = head;/*这个节点指向的下一个指针变为空指针,ne等于-1表示空*/
    head=idx;/*重新定义头节点*/
    idx++;/*更新可用节点*/
}

//把x插到下标为k的坐标的后面
void add(int k,int x)
{
    e[idx]=x;
    ne[idx]=ne[k];
    ne[k]=idx;
    idx++;
}

//单链表的删除操作，将下标是k的点后面的点删除
void remove(int k)
{
    ne[k]=ne[ne[k]];/*k的下一个节点等于k的下一个节点的下一个节点*/
}

（二）双链表

每个节点会有两个个指针，一个指向前一个指向后

#include<stdio.h>
const int N=100010;
int m;
int e[N],l[N],r[N],idx;

//初始化
void init()
{
    //0表示左端点，1表示右端点（只是两个边界，不算实质内容）
    r[0]=1,l[1]=0;
    idx=2;
}

//如何去插入一个点：可以插到某个点的左边也可以插入右边
//在下标为k的右边插入一个点x
void add_k_right(int k,int x)
{
    e[idx]=x;
    r[idx]=r[k];
    l[idx]=k;
    l[r[k]]=idx;/*原本k的右边的左边连上idx*/
    r[k]=idx;
}

//如果想在下标为k的左边插入一个点x，把k赋值为l[k]即可
void add_k_left(int k,int x)
{
    e[idx]=x;
    /*关键的四步，先连idx再连左右两边的*/
    r[idx]=k;
    l[idx]=l[k];
    r[l[k]]=idx;/*k左边的右边等于idx*/
    l[k]=idx;/*k的左边等于idx*/
}

//删除第k个点
void remove(int k)
{
    r[l[k]]=r[k];/*k的左边的右边等于k的右边*/
    l[r[k]]=l[k];/*k的右边的左边等于k的左边*/
}