【C数据结构】——单链表的相关操作，双向链表

链表介绍

链表（ linked list ）是一种物理存储单元上非连续、非顺序的常见的存储结构，用于存储一系列的结（亦可写作 “节” ）点。与顺序表不同，链表的每个结点不仅要存储数据元素，还要有指向下一个结点的指针。链表中的结点可以按照次序连接在一起，形成一个链式结构。链表中的第一个结点被称为头结点，最后一个结点被称为尾结点，指向NULL。如图：

链表和顺序表的不同
如下图所示：

\	链表	顺序表
存储方式	使用不相邻的内存块	连续的内存空间
插入和删除操作时间复杂度	O(1)	O(n)
是否支持随机访问	否	是
空间占用比较	较大	较小
扩容缩容操作	不需要复制数据	需要复制数据

综上所述，链表适用于频繁的插入和删除操作，而顺序表适用于频繁的访问操作。选择使用哪种数据结构取决于具体的需求和操作的频率。

有时，我们为了更加方便地对链表进行操作，会在单链表的第一个储存数据的结点位置设置一个头结点，也叫哨兵结点，通常它不存储任何信息。本文介绍的是没有哨兵结点的单链表。
下面开始介绍单链表的相关操作。

一.单链表相关操作（增，删，查，改）

定义结点

typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SListNode;

Ⅰ.头插，尾插，指定位置插入

头插
在头插时，需要更新链表的头指针。为了实现这一操作，可以使用一个二级指针。

一级指针是指针变量，存储了一个地址。二级指针是指向一级指针的指针，即它存储的是一级指针的地址。通过使用二级指针，可以修改一级指针的值。

这里的二级指针 SListNode ** 接受了头指针的地址，在函数内部，解引用过后就可以修改头指针的值，从而实现头插。

//头插
void SListPushFront(SListNode** pplist, SLTDataType x) {
	SListNode* newnode = BuySListNode(x);	//这个函数的作用是新建结点
	newnode->next = *pplist;
	*pplist = newnode;
}

尾插
尾插中的二级指针同理。

//尾插
void SListPushBack(SListNode** pplist, SLTDataType x) {
	assert(pplist);		//保证结构体指针不为空
	SListNode* newnode = BuySListNode(x);	//这个函数的作用是新建结点
	SListNode* tail = *pplist;
	if (*pplist == NULL)	//1.链表为空
		*pplist = newnode;
	else {					//2.链表不为空，找尾
		while (tail->next) {
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

指定位置插入
分两种情况，一是在pos之后插入。

1 //在pos之后插入x
2 void SListInsertAfter(SListNode* pos, SLTDataType x) {
3	 assert(pos); 	//保证pos位置有效
4	 SListNode* newnode = BuySListNode(x);
5	 newnode->next = pos->next;
6	 pos->next = newnode;
7 }

这里需要注意的是，5，6两行代码顺序不能交换，如果交换的话，其实结果就等同于 newnode -> next =newnode，这样就失败了。

二是在pos之前插入。

而如果在pos之前插入，又有两种情况。

1. pos位置是头结点
2. 不是头结点

//在pos之前插入x
void SLTInsert(SListNode** pplist, SListNode* pos, SLTDataType x) {
	assert(pplist);		//保证结构体指针不为空
	assert(pos);		//保证pos位置有效
	assert(*pplist);	//保证原链表有元素
	SListNode* newnode = BuySListNode(x);
	if (*pplist == pos) {		//1.pos位置是头结点，头插
		SListPushFront(pplist, x);
	}
	SListNode* cur = *pplist;
	while (cur->next != pos)	//2.遍历找pos的前一个位置
	{
		cur = cur->next;
	}
	newnode->next = pos;
	cur->next = newnode;
}

Ⅱ.头删，尾删，指定位置删除

头删
头删相对简单，只需要一个临时结点即可。

//头删
void SListPopFront(SListNode** pplist) {
	assert(*pplist);	//保证原链表有元素
	SListNode* tmp = *pplist;
	*pplist = (*pplist)->next;
	free(tmp);
}

尾删
尾删相较头删，要麻烦些许，要分两种情况。

1. 链表只有一个元素
2. 链表有两个及以上的元素

//尾删
void SListPopBack(SListNode** pplist) {
	assert(pplist);		//保证结构体指针不为空
	assert(*pplist);	//保证原链表有元素
	SListNode* tail = *pplist;
	if ((*pplist)->next == NULL) {		//1.链表只有一个元素
		free(*pplist);
		*pplist = NULL;
	}
	else {								//2.链表有两个及以上的元素
		while (tail->next->next) {		//找尾
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

指定位置删除
分两种情况，一是删除pos之后的位置，二是删除pos位置。
而如果是删除pos位置，又有两种情况。

1. 位置是头结点
2. 不是头结点

//删除pos之后的位置
void SListEraseAfter(SListNode* pos) {
	assert(pos&&pos->next);		//保证pos位置和pos位置的下一个节点不为NULL
	SListNode* tmp = pos->next;
	pos->next = pos->next->next;
	free(tmp);
	tmp = NULL;
}

//删除pos位置
void SLTErase(SListNode** pplist, SListNode* pos) {
	assert(pplist && *pplist);		//保证结构体指针不为空，原链表有元素
	if (*pplist == pos)				//1.位置是头结点
		SListPopFront(pplist);		//头删
	SListNode* prev = *pplist;		//2.位置不是头结点
	while (prev->next != pos)		//检查链表是否已排查完
		prev = prev->next;
	prev->next = pos->next;
	free(pos);
	pos = NULL;
}

注意，所有的结点在删除后，都需要进行释放置空的操作，否则可能会出现野指针

Ⅲ.查找元素

SListNode* SListFind(SListNode* plist, SLTDataType x) {
	assert(plist);	//保证结构体不为空
	SListNode* cur = plist;
	while (cur) {	//遍历整个链表，直到NULL
		if (cur->data == x) 
			return cur;
		else 
			cur = cur->next;
	}
	return NULL;
}

下面是相关函数声明

// 头插
void SListPushFront(SListNode** pplist, SLTDataType x);
// 尾插
void SListPushBack(SListNode** pplist, SLTDataType x);
// 在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDataType x);
// 在pos位置之前插入x
void SLTInsert(SListNode** pplist, SListNode* pos, SLTDataType x);
// 头删
void SListPopFront(SListNode** pplist);
// 尾删
void SListPopBack(SListNode** pplist);
// 删除pos位置之后的值
void SListEraseAfter(SListNode* pos);
// 删除pos位置
void SLTErase(SListNode** pplist, SListNode* pos);
// 查找
SListNode* SListFind(SListNode* plist, SLTDataType x);

二.双向链表

双向链表可以带有哨兵位头结点，也可以不带，本文要介绍的是带哨兵位头结点的双向循环链表。
双向链表，顾名思义，就是一个结点有两个指向的链表，每个节点包含指向前一个节点和后一个节点的指针。如下图所示：

Ⅰ.双向链表和单链表的比较

双向链表和单链表的主要区别是节点的结构不同。单链表的节点（Node）通常包含一个数据元素和一个指向下一个节点的指针，而双向链表的节点除了包含一个数据元素外，还包含一个指向前一个节点的指针。

双向链表相对单链表的优点：

1. 可以快速地在任意位置插入或删除节点，而单链表需要去遍历链表。
2. 可以方便地实现双向遍历，可以从任意一个节点开始向前或向后遍历整个链表。

然而，双向链表相对于单链表也有一些缺点：

1. 由于每个节点需要额外的指针来指向前一个节点，因此占用的内存空间相对要更多一些。
2. 在插入或删除节点时，需要同时更新前后节点的指针，操作相对复杂一些。

总的来说，双向链表相对于单链表在插入和删除节点的操作上更加方便快捷，但在内存占用上相对更大。在查找和修改节点的操作上，两者没有太大差异。因此，在具体使用时，需要根据实际需求来选择适合的链表。

Ⅱ.双向链表的相关操作（增，删，查，改）

首先定义结点

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;

函数声明

// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);

函数实现

插入操作

在增加操作上，单链表需要修改指针来建立节点之间的连接，而双向链表只需要修改两个指针即可。

//头插
void ListPushFront(ListNode* pHead, LTDataType x) {
	assert(pHead);
	ListNode* newnode = ListCreate(x);		//新建一个结点。
	ListNode* next = pHead->next;
	pHead->next = newnode;
	newnode->prev = pHead;
	next->prev = newnode;
	newnode->next = next;
}
//尾插
void ListPushBack(ListNode* pHead, LTDataType x) {
	assert(pHead);
	ListNode* tail = pHead->prev;
	ListNode* newnode = ListCreate(x);
	newnode->next = pHead;
	pHead->prev = newnode;
	newnode->prev = tail;
	tail->next = newnode;
}
//pos位置前面插入
void ListInsert(ListNode* pos, LTDataType x) {
	assert(pos);
	ListNode* newnode = ListCreate(x);
	ListNode* posprev = pos->prev;
	posprev->next = newnode;	
	newnode->prev = posprev;	
	newnode->next = pos;
	pos->prev = newnode;
}

删除操作

删除操作中，单链表需要遍历找到待删除节点的前一个节点来修改指针，而双向链表仍只需要修改两个指针即可。

//头删
void ListPopFront(ListNode* pHead) {
	assert(pHead);
	assert(pHead->next != pHead);
	ListNode* next = pHead->next;
	ListNode* next2 = next->next;
	pHead->next = next2;
	next2->prev = pHead;
	free(next);
}
//尾删
void ListPopBack(ListNode* pHead) {
	assert(pHead);
	assert(pHead->next != pHead);
	ListNode* tail = pHead->prev;
	tail->prev->next = pHead;
	pHead->prev = tail->prev;
	free(tail);
}
//指定位置删除
void ListErase(ListNode* pos) {
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
}

查找pos位置

而在查找操作上，单链表和双向链表没有本质上的区别，都需要从头节点开始遍历直到找到目标节点。

ListNode* ListFind(ListNode* pHead, LTDataType x) {
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead) {
		if (cur->data == x)
			return cur;
		else
			cur = cur->next;
	}
	return NULL;
}