【数据结构】拆分详解 - 双向链表

---

前言

文章细分了各个知识点，可在目录中快速跳转。
手机端用户在查看代码块时建议点击代码右上角放大查看，每一段代码均有完整注释。

画图很重要，学会作图才能理解其中的核心思想，代码的实现反而是其次的，要画图，然后看图写代码。本文在讲解时也遵循先配图，再进行代码实现的先后顺序。

---

一、单链表与双向链表

1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，下面我们就来实现。

---

二、接口实现 - 带头双向循环链表

  0. 声明

typedef int ListDataType;  //注释1

typedef struct ListNode
{
	ListDataType val;
	struct ListNode* prev;
	struct ListNode* next;
}LTNode;  //注释2

双向循环链表的节点内拥有两个指针，一个指向前一个节点，一个指向后一个节点

注释：

1. 由于后期我们可能会改变链表存储数据的类型，而一但更改，我们需要对每一个调用该类型的地方进行修改，十分麻烦，使用typedef对数据的类型进行重命名，这样以后要更换类型只需要更改此处就可以达到全文替换的目的。

2. 重命名简便后续输入，注意我们为什么不直接命名简便一点呢？每个命名都是基于英文单词的释义，这样可以增加在多人协作，以及后续维护代码时的可读性。

  1. 创建新节点

LTNode* ListCreate(ListDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	newnode->val = x;
	newnode->next = NULL;
	newnode->prev = NULL;

	return newnode;
}

  2. 创建并初始化

LTNode* ListInit()
{
	LTNode* phead = ListCreate(-1); //哨兵位的val值随意赋一个即可
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

哨兵位： 我们创建时，首先开辟一个哨兵点，随意赋值即可，因为哨兵位的作用就是使链表始终有一个节点方便指向，不需要它存放数据。

  3. 销毁

void ListDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead;
	LTNode* next = phead->next;

	while (cur->next != phead)
	{
		free(cur);  //free可以置空也可以不置空
		cur = next;
		next = next->next;
	}
}

free后要不要置空：如果指针是在接口函数（局部函数）中创建的，可以不置空，因为函数结束会自动销毁所有局部变量，作为养成一个好习惯，我们可以置空，置空一定没有错。

  4. 打印

void ListPrint(LTNode* phead)
{
	assert(phead);
	printf("哨兵位<=>");

	LTNode* cur = phead->next;
	while (cur != phead) //注释1
	{
		printf("%d<=>", cur->val);
		cur = cur->next;
	}
}

注释：

1. 也可以写成cur->next != head, 但这样如果我们赋值cur的时候直接赋值成phed（哨兵位）时，这种写法会访问到哨兵位的节点值，有可能乍看一眼发现不了，这是我们不希望的。
   而使用前种写法，我们在打印时就会发现什么都没打印，就会去寻找问题。

  5. 头插

• 方法1

void ListPushFront(LTNode* phead, ListDataType x)
{
	assert(phead);
	LTNode* newnode = ListCreate(x);
	LTNode* first = phead->next;

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

• 方法2

//要考虑链接的先后顺序
void ListPushFront2(LTNode* phead, ListDataType x)
{
	assert(phead);
	LTNode* newnode = ListCreate(x);

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

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

这里我们提供两种写法，对于后面的接口函数也是可以分成两种写法：

1. 一种是多维护一些指针，这样就不用考虑链接的先后顺序，非常方便。
2. 一种是不用指针，可以极致节省空间，但需要考虑链接的先后顺序，但对于99%的情况，完全没有必要，只有在嵌入式，单片机这种内存极小的环境下才需要考虑。

  6. 头删

void ListPopFront(LTNode* phead)
{
	assert(phead);
	LTNode* first = phead->next;
	LTNode* second = first->next;

	phead->next = second;
	second->prev = phead;
	free(first);
	first = NULL;
}

  7. 尾插

void ListPushBack(LTNode* phead, ListDataType x)
{
	assert(phead);
	LTNode* newnode = ListCreate(x);
	LTNode* tail = phead->prev;

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

  8. 尾删

void ListPopBack(LTNode* phead)
{
	assert(phead);
	LTNode* tail = phead->prev;
	LTNode* tailprev = tail->prev;

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

	free(tail);
	tail = NULL;
}

  9. 查找

LTNode* ListFind(LTNode* phead, ListDataType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->val)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

  10. pos位置前插入

void ListInsert(LTNode* pos, ListDataType x)
{
	assert(pos);
	LTNode* newnode = ListCreate(x);
	LTNode* posprev = pos->prev;

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

  11.删除pos位置

void ListErase(LTNode* pos)
{
	LTNode* posprev = pos->prev;
	LTNode* posnext = pos->next;

	posprev->next = posnext;
	posnext->prev = posprev;

	free(pos);
	pos = NULL;
}

    1. 利用Insert实现头插

void ListPushFront(LTNode* phead, ListDataType x)
{
	assert(phead);
	//ListInsert(pHead->next, x);
}

    2. 利用Insert实现尾插

void ListPushBack(LTNode* phead, ListDataType x)
{
	assert(phead);
	//ListInsert(pHead, x);
}

    3. 利用Erase实现头删

void ListPopFront(LTNode* phead)
{
	assert(phead);
	//ListErase(pHead->next);
}

    4. 利用Erase实现尾删

void ListPopBack(LTNode* phead)
{
	assert(phead);
	//ListErase(pHead->prev);
}

---

三、链表与顺序表

• 链表（双向）

优势：

1. 任意位置插入删除时间复杂度都是O(1);【已知位置的地址前提下】
2. 按需申请释放，合理利用空间，不存在浪费

问题：

1. 下标随机访问不方便，时间复杂度为O(N)

• 顺序表

优势：

1. 支持随机的下标访问，复杂度为O(1)，适合大规模排序

问题:

1. 头部或中间删除效率低，需要挪动元素，复杂度为O(N)
2. 空间不够需要扩容，扩容有一定的消耗，且可能造成空间浪费
3. 只适合尾插尾删

---

总结

本文拆分讲解了无头单向不循环链表的接口实现，并配有步骤图解。对比了单双向链表以及链表与顺序表，总结了它们的优缺点。如果对你有所帮助，还望点赞收藏支持博主。
文章中有什么不对的丶可改正的丶可优化的地方，欢迎各位来评论区指点交流，博主看到后会一一回复。