C语言数据结构双向链表、初始化双向链表、打印双向链表、销毁双向链表、双向链表尾插、头插、尾删、头删、查找指定数值位置节点、指定位置之前插入、指定位置删除等的介绍

前言

C语言数据结构双向链表、初始化双向链表、打印双向链表、销毁双向链表、双向链表尾插、头插、尾删、头删、查找指定数值位置节点、指定位置之前插入、指定位置删除等的介绍

---

链表的分类

• 通常地
• 单链表指的是 不带头单向不循环链表
• 双向链表指的是 带头双向循环链表

一、 结构创建

结构的创建

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>

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

---

二、 初始化结构

初始化结构定义

 // 链表的初始化
//void LTInit(LTNode** pphead)
//{
//	*pphead = BuyListNode(-1);
//
//
//	(*pphead)->next = *pphead;
//	(*pphead)->prev = *pphead;
//}

LTNode* LTInit()
{
	LTNode* phead = BuyListNode(-1);

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

	return phead;
}

• 可以传递二级指针来完成
• 也可以不传参数来实现。

---

三、双向链表打印

双向链表打印定义

// 打印链表
void LTPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	
	printf("<=head=>");
	while (cur != phead)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

四、销毁双向链表

销毁双向链表定义

// 销毁链表
void LTDestroy(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;

	while (cur != phead)
	{
		LTNode* next = cur->next;

		free(cur);
		cur = next;
	}
	free(cur);
	cur = NULL;
}

五、双向链表尾插

双向链表尾插定义

// 尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* newnode = BuyListNode(x);

	LTNode* tail = phead->prev;

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

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

---

双向链表尾插测试

void ListTest01()
{
	LTNode* plist = LTInit();
	/*LTNode* plist = NULL;
	LTInit(&plist);*/

	// 尾插
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	
	// 打印
	LTPrint(plist);

	// 销毁链表
	LTDestroy(plist);
	plist = NULL;
}

效果如下：

五、双向链表尾删

双向链表尾删定义

// 判断链表是否为空
bool LTEmpty(LTNode* phead)
{
	assert(phead);

	return (phead->next == phead);
}

// 尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	LTNode* tail = phead->prev;

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

	free(tail);
	tail = NULL;
}

---

双向链表尾删测试

void ListTest01()
{
	LTNode* plist = LTInit();
	/*LTNode* plist = NULL;
	LTInit(&plist);*/

	// 尾插
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);

	// 尾删
	LTPopBack(plist);
	LTPopBack(plist);
	//LTPopBack(plist);
	//LTPopBack(plist);
	//LTPopBack(plist);


	// 打印
	LTPrint(plist);

	// 销毁链表
	LTDestroy(plist);
	plist = NULL;
}

效果如下：

六、双向链表头插

双向链表头插定义

// 头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* newnode = BuyListNode(x);

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

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

---

双向链表头插测试

void ListTest02()
{
	LTNode* plist = LTInit();
	/*LTNode* plist = NULL;
	LTInit(&plist);*/

	// 头插
	LTPushFront(plist, 1);
	LTPushFront(plist, 2);
	LTPushFront(plist, 3);
	LTPushFront(plist, 4);

	// 打印
	LTPrint(plist);

	// 销毁链表
	LTDestroy(plist);
	plist = NULL;
}

效果如下：

七、双向链表头删

双向链表头删定义

// 头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(!LTEmpty(phead));

	LTNode* del = phead->next;

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

	free(del);
	del = NULL;

}

---

双向链表头删测试

void ListTest02()
{
	LTNode* plist = LTInit();
	/*LTNode* plist = NULL;
	LTInit(&plist);*/

	// 头插
	LTPushFront(plist, 1);
	LTPushFront(plist, 2);
	LTPushFront(plist, 3);
	LTPushFront(plist, 4);

	LTPrint(plist);

	// 头删
	LTPopFront(plist);
	LTPopFront(plist);
	//LTPopFront(plist);
	//LTPopFront(plist);
	//LTPopFront(plist);

	// 打印
	LTPrint(plist);

	// 销毁链表
	LTDestroy(plist);
	plist = NULL;
}

效果如下：

八、查找指定数值的节点位置

查找指定数值的节点位置定义

// 查找指定数值对应的节点
LTNode* LTFindPos(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* cur = phead;

	while (cur->next != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

---

查找指定数值的节点位置测试

void ListTest03()
{
	LTNode* plist = LTInit();
	/*LTNode* plist = NULL;
	LTInit(&plist);*/

	// 尾插
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);

	// 查找指定数值位置
	LTNode* find = LTFindPos(plist, 3);

	if (find != NULL)
	{
		// 将找到的节点数值乘2
		find->data *= 2;
	}
	else
	{
		printf("没找到\n");
	}


	// 打印
	LTPrint(plist);

	// 销毁链表
	LTDestroy(plist);
	plist = NULL;
}

效果如下：

九、双向链表指定位置之前插入

双向链表指定位置之前插入定义

// 指定位置之前插入
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* newnode = BuyListNode(x);

	LTNode* prev = pos->prev;

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

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

---

双向链表指定位置之前插入测试

void ListTest04()
{
	LTNode* plist = LTInit();
	/*LTNode* plist = NULL;
	LTInit(&plist);*/

	// 尾插
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);

	LTNode* find = LTFindPos(plist, 3);

	// 指定位置之前插入
	// 头插
	LTInsert(plist->next, 60);
	LTPrint(plist);

	// 尾插
	LTInsert(plist, 99);
	LTPrint(plist);

	// 指定数值3的位置之前插入
	LTInsert(find, 66);


	// 打印
	LTPrint(plist);

	// 销毁链表
	LTDestroy(plist);
	plist = NULL;
}

效果如下：

十、双向链表指定位置删除

双向链表指定位置删除定义

// 指定位置删除
void LTErase(LTNode* pos)
{
	assert(pos);

	LTNode* prev = pos->prev;

	prev->next = pos->next;
	pos->next->prev = prev;

	free(pos);
	pos = NULL;
}

---

双向链表指定位置删除测试

void ListTest05()
{
	LTNode* plist = LTInit();
	/*LTNode* plist = NULL;
	LTInit(&plist);*/

	// 尾插
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPrint(plist);

	LTNode* find = LTFindPos(plist, 3);

	// 指定位置删除
	// 指定数值3的位置删除
	LTErase(find);
	LTPrint(plist);

	// 头删
	LTErase(plist->next);
	LTPrint(plist);

	// 尾删除
	LTErase(plist->prev);

	// 打印
	LTPrint(plist);

	// 销毁链表
	LTDestroy(plist);
	plist = NULL;
}

效果如下：

---

总结

C语言数据结构双向链表、初始化双向链表、打印双向链表、销毁双向链表、双向链表尾插、头插、尾删、头删、查找指定数值位置节点、指定位置之前插入、指定位置删除等的介绍