双向链表_代码实现

Bear on Toilet

已于 2024-07-18 13:17:19 修改

阅读量410

点赞数 5

文章标签：链表数据结构

于 2024-07-18 13:14:30 首次发布

本文链接：https://blog.csdn.net/2301_80682565/article/details/140507112

版权

代码实现的专题：只有手撕代码：），附上重点注释；重要的环节，会配上相应的调试截图与运行截图。

总之，重点在代码，关于基础理论部分：（还在写）

定义双向链表节点的结构

//ListNode.h



//定义双向链表节点的结构
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//定义双向链表节点的结构
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;//表示下一节点的指针
	struct ListNode* prev;//表示上一节点的指针
	
}LTNode;

双向链表_初始化：

ListNode.h

//初始化
void LTInit(LTNode** pphead);

//ListNode.c

#include "ListNode.h"

//申请空间，创建链表节点
LTNode* LTBuyNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	newnode->data = x;
	newnode->prev = newnode->next = newnode;//双向链表的特殊之处；
}
void LTInit(LTNode** pphead)
{
	*pphead = LTBuyNode(-1);
}

//test.c

#include "ListNode.h"

void ListNodeTest01()
{
	LTNode* plist = NULL;//创建一个节点，先分配无效地址
	LTInit(&plist);//测试初始化方法
}
int main()
{
	ListNodeTest01();//测试代码区域专门放入这个函数里
	return 0;
}

初始化方法调试：

进入初始化方法：

退出BuyNode方法后，*pphead接收返回值：

初始化，传的是&plist,(形参的改变要想影响实参，就得传实参的地址)

结果看到，plist的值已经与形参的一样---说明初始化成功

另一种写法：

LTNode* Init();

//申请空间，创建链表节点
LTNode* LTBuyNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	newnode->data = x;
	newnode->prev = newnode->next = newnode;//双向链表的特殊之处；
}
LTNode* Init()
{
	LTNode* phead = LTBuyNode(-1);//创建一个指针接收返回值
	return phead;//phead此时已经申请好空间，完成初始化
}

//测试
LTNode* plist = Init();//让plist接收返回值

双向链表_打印

为了方便我们后续链表增删查改方法的检验，我们增加双向链表打印的方法

void LTPrint(LTNode* phead);

void LTPrint(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->",pcur->data);
		pcur = pcur->next;//记得让pcur走，循环条件若不改变，肯定会死循环
	}
	printf("\n");

}

增

双向链表的尾插

void LTPushBack(LTNode* phead,LTDataType x);

//哨兵位节点不能被删除，节点的地址也不能发生改变
//不改变哨兵位的位置，因此传一级即可
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	//创建新节点
	LTNode* newnode = LTBuyNode(x);

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

	phead->prev->next = newnode;//这两行代码不能交换
	phead->prev = newnode;//一旦发生交换，就找不到原先的尾节点
}

测试代码：

void ListNodeTest01()
{
	LTNode* plist = NULL;
	LTInit(&plist);
	//测试尾插
	LTPushBack(plist,1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPrint(plist);
}
int main()
{
	ListNodeTest01();
	return 0;
}

结果输出：

双向链表的头插

void LTPushFront(LTNode* phead, LTDataType x)

//头插——插在哨兵位的后面，成为新的第一个有效节点
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);//链表必须有效，双链表至少得有个有效的哨兵位，不然甚至称不上是双向链表
	LTNode* newnode = LTBuyNode(x);
	// phead newnode phead->next
	newnode->prev = phead;
	newnode->next = phead->next;

	phead->next->prev = newnode;//这两行代码同样不能换顺序
	phead->next = newnode;//一旦交换，找不到原来的第一个有效节点

}

#include "ListNode.h"

void ListNodeTest01()
{
	LTNode* plist = NULL;
	LTInit(&plist);
	//测试尾插
	LTPushBack(plist,1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPrint(plist);//1->2->3->
	//测试头插
	LTPushFront(plist, 1);
	LTPushFront(plist, 2);
	LTPushFront(plist, 3);
	LTPrint(plist);
}
int main()
{
	ListNodeTest01();
	return 0;
}

运行截图：

删

双向链表的尾删

void LTPopBack(LTNode* phead);

void LTPopBack(LTNode* phead)
{
	assert(phead && phead->next != phead);//链表必须有效，且不能删哨兵位（链表不能为空）
	LTNode* del = phead->prev;
	del->prev->next = phead;
	phead->prev = del->prev;
	free(del);
	del = NULL;

}

void ListNodeTest01()
{
	LTNode* plist = NULL;
	LTInit(&plist);
	//测试尾插
	LTPushBack(plist,1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPrint(plist);//1->2->3->

	//....
	
	//测试尾删
	LTPopBack(plist);
	LTPrint(plist);
}

运行截图：

双向链表的头删

void LTPopFront(LTNode* phead);

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

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

	free(del);
	del = NULL;
}

void ListNodeTest01()
{
	LTNode* plist = NULL;
	LTInit(&plist);
	//测试尾插
	LTPushBack(plist,1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPrint(plist);//1->2->3->

	//测试头删
	LTPopFront(plist);
	LTPrint(plist);
}

运行截图：

查

双向链表的查找

//根据数据查找
LTNode* LTFind(LTNode* phead,LTDataType x);

//查找
LTNode* LTFind(LTNode* phead, LTDataType 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* phead, LTDataType x);

//在pos位置之后插入数据
void LTInsert(LTNode* pos,LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	//pos newnode pos->next

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

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

//测试在pos之后插入数据
	LTNode* find = LTFind(plist, 2);//返回下标为2的节点指针
	LTInsert(find,666);//2后插入666
	LTPrint(plist);

运行截图：

删除指定位置的节点

//删除指定pos节点
void LTErase(LTNode * pos);

//删除指定pos节点
void LTErase(LTNode* pos)
{
	assert(pos);
	//pos->prev pos pos->next
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

    //测试在pos之后插入数据
	LTNode* find = LTFind(plist, 2);
	LTInsert(find,666);
	LTPrint(plist);

	//测试指定pos删除节点
	LTErase(find);
	LTPrint(plist);
	LTErase(find);
	LTPrint(plist);

运行截图：

结果节点2确实被指定删除了

双向链表_销毁

//删除链表
void LTDesTroy(LTNode* phead);

//销毁
void LTDesTroy(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//现在只剩哨兵位节点未释放
	free(phead);
	phead = NULL;

}

//测试
	LTDesTroy(plist);
	plist = NULL;

调试一番，在DesTroy函数结束后，形参phead被释放，但是主调函数里的实参plist可以看到并没有被销毁（即存着有效地址），但是后面的节点已然被删除，需要主动plist = null;不然你还可以利用plist，进行尾插之类的操作——这怎么能叫销毁呢？——原理还是：形参的改变要影响实参，还得传地址

这里传的形参，phead头节点想要被改变，就得传&phead,但是我写的方法里面为什么不传二级指针（&phead），因为：为了保持接口的一致性

前面的增删查改的参数都传的是plist,但是到了初始化和销毁，一旦涉及头结点的改变，就要传二级，这就加大了用户/同事使用接口的记忆量，所以我们尽量保持传参的统一，都传plist，或者像初始化的第二个方法，不传参。

完整代码参考：

ListNode.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//定义双向链表节点的结构
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;//表示下一节点的指针
	struct ListNode* prev;//表示上一节点的指针
	
}LTNode;

//初始化
void LTInit(LTNode** pphead);
void LTPrint(LTNode* phead);
//尾插和头插
void LTPushBack(LTNode* phead,LTDataType x);
void LTPushFront(LTNode* phead, LTDataType x);
//尾删和头删
void LTPopBack(LTNode* phead);
void LTPopFront(LTNode* phead);
//在pos位置之后插入数据
void LTInsert(LTNode* phead, LTDataType x);
//根据数据查找
LTNode* LTFind(LTNode* phead,LTDataType x);
//删除指定pos节点
void LTErase(LTNode * pos);
//删除链表
void LTDesTroy(LTNode* phead);

ListNode.c

#include "ListNode.h"

LTNode* LTBuyNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	newnode->data = x;
	newnode->prev = newnode->next = newnode;//双向链表的特殊之处；
}
void LTInit(LTNode** pphead)
{
	*pphead = LTBuyNode(-1);//哨兵位节点
}
LTNode* Init()
{
	LTNode* phead = LTBuyNode(-1);
	return phead;
}
//哨兵位节点不能被删除，节点的地址也不能发生改变
//不改变哨兵位的位置，因此传一级即可
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	//创建新节点
	LTNode* newnode = LTBuyNode(x);

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

	phead->prev->next = newnode;//这两行代码不能交换
	phead->prev = newnode;//一旦发生交换，就找不到原先的尾节点
}

//打印
void LTPrint(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->",pcur->data);
		pcur = pcur->next;//记得让pcur走，循环条件若不改变，肯定会死循环
	}
	printf("\n");

}
//头插——插在哨兵位的后面，成为新的第一个有效节点
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);//链表必须有效，双链表至少得有个有效的哨兵位，不然甚至称不上是双向链表
	LTNode* newnode = LTBuyNode(x);
	// phead newnode phead->next
	newnode->prev = phead;
	newnode->next = phead->next;

	phead->next->prev = newnode;//这两行代码同样不能换顺序
	phead->next = newnode;//一旦交换，找不到原来的第一个有效节点

}
//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead && phead->next != phead);//链表必须有效，且不能删哨兵位（链表不能为空）
	LTNode* del = phead->prev;
	del->prev->next = phead;
	phead->prev = del->prev;
	free(del);
	del = NULL;

}

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

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

	free(del);
	del = NULL;
}

//在pos位置之后插入数据
void LTInsert(LTNode* pos,LTDataType x)
{
	assert(pos);
	LTNode* newnode = LTBuyNode(x);
	//pos newnode pos->next

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

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

//查找
LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
			return pcur;
		pcur = pcur->next;
	}
	return NULL;

}

//删除指定pos节点
void LTErase(LTNode* pos)
{
	assert(pos);
	//pos->prev pos pos->next
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

//销毁
void LTDesTroy(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//现在只剩哨兵位节点未释放
	free(phead);
	phead = NULL;

}

test.c

#include "ListNode.h"

void ListNodeTest01()
{
	LTNode* plist = Init();
	//测试尾插
	LTPushBack(plist,1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPrint(plist);//1->2->3->

	测试头插
	//LTPushFront(plist, 1);
	//LTPushFront(plist, 2);
	//LTPushFront(plist, 3);
	//LTPrint(plist);
	
	测试尾删
	//LTPopBack(plist);
	//LTPrint(plist);
	
	测试头删
	//LTPopFront(plist);
	//LTPrint(plist);

	测试在pos之后插入数据
	//LTNode* find = LTFind(plist, 2);
	//LTInsert(find,666);
	//LTPrint(plist);

	测试指定pos删除节点
	//LTErase(find);
	//LTPrint(plist);

	//测试
	LTDesTroy(plist);
	plist = NULL;
}
int main()
{
	ListNodeTest01();
	return 0;
}