数据结构 —— 链表

一、链表的背景

对于我们常用的数组（顺序表），你是否会有以下烦恼：

1.中间/头部的插⼊删除，时间复杂度为O(N)
2.增容需要申请新空间，拷⻉数据，释放旧空间。会有不⼩的消耗。
3.增容⼀般是呈2倍的增⻓，势必会有⼀定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插⼊了5个数据，后⾯没有数据插⼊了，那么就浪费了95个数据空间。
 

是否有一种数据结构，能够解决以上顺序表表现出来的问题：

1）中间/头部的插入删除，可以一步到位，不需要挪动数据

2）不需要扩容

3） 不会造成空间浪费

链表和顺序表都是线性表，区别在于：链表的物理结构上并不是线性的

二、链表的结构

链表是由一个一个节点组成的，每个节点由两个部分组成：要存储的数据+指针

很明显，这里的指针是结构体指针，保存的是下一个节点的地址，这样就可以实现串连

链表的结构又细分有很多：

三、链表的分类

可以根据这个图细分成8种：

 注意：此处的“头节点”，并不是所谓的第一个节点，而是在第一个节点之前还有一个结点，也称为哨兵位，不存储任何有效信息，只存储第一个节点的地址

 虽然链表种类非常之多，但是使用比较多的只有两种：单链表（不带头单向不循环链表）和双链表（带头双向循环链表）

四、单链表的基本功能实现

（此处的单链表为“不带头单向不循环链表”）

链表的创建

typedef int SLNDataType;

typedef struct SListNode
{
	SLNDataType val;
	struct SListNode* next;
}SLNode;

链表的打印

void SLTPrint(SLNode* phead)
{
//暂没定义哨兵位
	SLNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->val);
		cur = cur->next;
	}
	printf("NULL\n");
}

//这里需要注意的是：必须重新定义一个cur，不能直接用phead
//否则会导致phead最后变成空，会破坏原有链表

节点的创造

SLNode* CreateNode(SLNDataType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->val = x;
	newnode->next = NULL;
	return newnode;
}

 单链表的增删查改

1、尾插（二级指针易错！）

//调用函数：SLTPushBack(plist,x)时，我们发现，传的是plist
//而plist是一个一级指针，我们要改变的是这个一级指针内部的指向
//因此我们需要传址调用，对一级指针取地址即二级指针

void SLTPushBack(SLNode** pphead, SLNDataType x)
{
    SLNode* newnode = CreateNode(x);

    //分两种情况，链表为空或不为空
	if (*pphead == NULL)  *pphead = newnode;

    //不为空的时候要去找尾节点
	else
	{
    //找尾
     SLNode* tail = *pphead;
	 while (tail->next)
	 {
        tail= tail->next;
	 }
    //找到尾了
	tail->next = newnode;
	}
}

2、尾删

void SLTPopBack(SLNode** pphead)
{
	SLNode *tail = *pphead;

    //同样也分多节点和只有一个节点两种情况
    
    //只有一个节点
	if ((*pphead)->next== NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
    //多个节点
	else
	{
    //找到要删节点的前一个节点
		while (tail->next->next)
		{
			tail = tail->next;
		}
		SLNode* tmp = tail->next;
		tail->next = NULL;
		free(tmp);
        //单链表中这样也可以：
        //free(tail->next);
        //tail->next = NULL;
	}
}

3、头插

 void SLTPushFront(SLNode**pphead, SLNDataType x)
{
	 assert(pphead);
	 SLNode* newnode = CreateNode(x);
    
    //这里要注意顺序o
	 newnode->next = *pphead;
	 *pphead = newnode;
}

4、头删

void SLTPopFront(SLNode** pphead)
{
	assert(pphead);

	SLNode* tmp = *pphead;
	*pphead = (*pphead)->next;
	free(tmp);
}

5、查找

SLNode* SLTFind(SLNode* phead, SLNDataType x)
{
	SLNode* cur = phead;
	while (cur)
	{
		if (cur->val != x) 
            cur = cur->next;
		else 
            return cur;
	}
	return NULL;
}
//就是简单的遍历一遍

6、修改

（1）在pos位置之前插入数据

void SLTInsert(SLNode** pphead, SLNode* pos, SLNDataType x)
{
	assert(pphead);
	assert(pos);
	assert(*pphead);

	//仍然要分pos是否为头节点

	if (pos == *pphead) {
		SLTPushFront(pphead,x);
		return;
	}

	else
	{
    SLNode* newnode = CreateNode(x);

	//找前驱
	SLNode* prev = *pphead;

	//定位
	while (prev->next != pos)
	{
		prev = prev->next;
	}

	prev->next = newnode;
	newnode->next = pos;
	}
	
}

(2) 在pos位置之后插入节点

void SLTInsertAfter(SLNode* pos, SLNDataType x)
{
	//标准的错误写法
	//pos->next = newnode;
	此时的pos->next已经是newnode了
	//newnode->next = pos->next;

	assert(pos);
	SLNode* newnode = CreateNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

(3) 删除pos位置的节点

void SLTErase(SLNode** pphead, SLNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);

	//仍然还是讨论头节点的问题，那么直接就头删除，因为没有前驱
	if (*pphead == pos)
	{
		SLTPopFront(pphead);
		return;
	}
	else
	{
	SLNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}

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

（4）删除pos位置后面的节点

void SLTEraseAfter(SLNode* pos)
{
	assert(pos->next);
	SLNode* tmp = pos->next;
	pos->next = pos->next->next;
	free(tmp);
	tmp = NULL;
}

单链表的销毁

void SLTDestroy(SLNode** pphead)
{
	assert(pphead);
	SLNode* cur = *pphead;

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

	*pphead = NULL;//这一步要想着，防止*pphead变成野指针
}

五、带头双向循环链表

1、基本结构

特点：

此处的head为哨兵位：该节点不存储有效数据

双向：指向前驱节点指针，指向后继节点指针

//定义双向链表中节点的结构

typedef int LTDateType;

typedef struct ListNode
{
	LTDateType data;
	struct ListNode* prev;
	struct ListNode* next;
}LTNode;

2、初始化

void LTInit(LTNode** pphead)
{
    //初始化哨兵位节点
	*pphead = (LTNode*)malloc(sizeof(LTNode));
	if (*pphead == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	(*pphead)->data = -1;

	//初始化时，头节点前驱和后继都指向自己
	(*pphead)->next = (*pphead)->prev = *pphead;
}

3、打印

双向链表打印的难点在于遍历，一不小心就会死循环

4、头插、尾插

明确一个概念：当链表中只有哨兵位节点的时候，我们称该链表为空链表，即哨兵位是不能删除也不能修改的，即不改变哨兵位本身的地址，所以此时就不需要传二级指针了！

这里不要进入误区：我们虽然会改变头节点结构体中next和prev的指向，但是这并不是改变头节点结构体的地址！，因此并不需要传二级指针，这里不明白的同学可以类比数组，我们在数组作为形参的时候传递的不也是一级指针，但是可以正常改变数组内部的元素的值，所以是一样的道理

尾插：

void LTPushBack(LTNode* phead, LTDateType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);
	//改变：
	//phead phead->prev(tail)  newnode
	newnode->next = phead;
	newnode->prev = phead->prev;

	phead->prev->next = newnode; //这里的phead->prev->next 即 ptail->next=newnode
	phead->prev = newnode;       //因此这样一定要有顺序，否则找不到尾节点
}

头插：

void LTPushFront(LTNode* phead, LTDateType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	newnode->next = phead->next;
	newnode->prev = phead;

	(phead->next)->prev = newnode;
	phead->next = newnode;
	//这两句的顺序还是不可更改的，要注意！
}

5、头删、尾删

//头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);
	LTNode* del = phead->next;
	LTNode* next = del->next;

	next->prev = phead;
	phead->next = next;

	free(del);
	del = NULL;
}

//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	//链表为空：只有一个哨兵位节点
	assert(phead->next != phead);

	//定义尾节点
	LTNode* del = phead->prev;
	//定义倒数第二个节点
	LTNode* prev = del->prev;

	prev->next = phead;
	phead->prev = prev;

	free(del);
	del = NULL;
}

6、对指定位置的操作

查找：

LTNode* LTFind(LTNode* phead, LTDateType x)
{
	assert(phead);

	//查找就是遍历
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//没找到
	return NULL;
}

在pos位置之后插入数据

void LTInsert(LTNode* pos, LTDateType x)
{
	assert(pos);

	LTNode* newnode = LTBuyNode(x);
	newnode->next = pos->next;
	newnode->prev = pos;

	pos->next->prev = newnode;
	pos->next = newnode;
	//这里也是：顺序不能错
}

删除pos位置的节点

void LTErase(LTNode* pos)
{
	assert(pos);
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;

	free(pos);
	pos = NULL;
}

7、双向链表的销毁

void LTDestory(LTNode** pphead)
{
	assert(pphead);
	assert(*pphead);

	LTNode* pcur = (*pphead)->next;
	while (pcur != *pphead)
	{
		//一定要临时保存，否则无法访问下一个节点
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(*pphead);
	*pphead = NULL;
}

ps：这里的销毁其实也可以传递一级指针，唯一不同的是不会销毁哨兵位，需要在调用函数后多加一步释放，哨兵位的步骤，但是我们发现在双向链表中均为一级指针，所以这样做可以保持接口的一致性，是一种好习惯

六、顺序表与单链表的对比

不同点	顺序表	链表（单链表
存储空间	物理上一定连续	逻辑上连续，但物理上不⼀定连续
随机访问	⽀持O(1)	不⽀持：O(N)
任意位置插⼊或者删除元素	可能需要搬移元素，效率低O(N)	只需修改指针指向
插⼊	动态顺序表，空间不够时需要扩 容	没有容量的概念
应⽤场景	元素⾼效存储+频繁访问	任意位置插⼊和删除频繁

七、结语

本次链表部分的知识分享就到此结束啦，希望能对每一位观者起到帮助，下一次的数据结构内容为栈和队列，创作不易，多多点赞评论啦~