【数据结构】双向链表（带头双向循环链表）——超详细代码

已于 2022-08-19 16:47:01 修改
阅读量2k 收藏 22
点赞数 3
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2022-08-15 16:28:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59702185/article/details/126332169
版权

文章目录

1. 双链表

1.1 前言

在上一篇文章我们已经介绍了链表的分类，链表的种类非常多，分为带头还是不带头、单向的还是多向的、单向还是双向循环……上一节我们学习了不带头单向的不循环的链表，这一节，我们主要实现带头双向循环的链表。如果我们把这两种结构的链表掌握的话，那么所有类型的链表我们都可以自己实现了

1.2 带头双向循环链表

带头双向循环链表是链表中结构最复杂的，一般用在单独存储数据。在实际解决问题的过程中，我们遇到大多数的链表都是这种带头双向循环的链表。这种链表虽然结构比较复杂，但是代码比较简单，处理方式非常简单高效，会有很多优势。
这种链表是有两个指针域的，分为前驱指针和后继指针。前驱指针指向前一个节点，后继指针指向后一个节点。而且这种指针是循环的，所以最后一个节点会指向头结点，形成一个环的结构，即循环。

2. 带头双向循环链表的实现

首先，我们还是先创建一个工程：
在这里插入图片描述

  • List.h—带头双向循环链表的定义、接口函数的声明、以及头文件的引用
  • List.c—接口函数的具体实现
  • test.c—主函数、测试

2.1 双向链表的定义声明

带头双向链表有一个数据域和两个指针域。指针域一个是前驱指针，指向前一个节点，一个是后继指针，指向后一个节点。

typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* prev;//前驱节点
	struct ListNode* next;//后继节点
	LTDataType data;//数据域
};

2.2 双向链表的初始化

在这里插入图片描述

初始化双向链表，首先动态申请一个节点，让自己的前驱和后继指针都指向自己，形成一个循环。

动态申请一个节点：

//动态申请一个新节点
ListNode* BuyListNode(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)//判断是否申请节点成功
	{
		printf("malloc fail");
		exit(-1);
	}
	newnode->next = NULL;//先置空
	newnode->prev = NULL;//先置空
	newnode->data = x;//赋值
}

初始化双向链表：

//初始化双向链表
void ListInit(ListNode** pphead)
{
	*pphead = BuyListNode(-1);//动态申请的是头结点
	(*pphead)->prev = *pphead;//前驱指向自己
	(*pphead)->next = *pphead;//后继指针自己，形成循环的链表
}

初始化双向链表时，我们需要改变头指针的指向，所以要传二级指针

2.3 释放双向链表

在释放双向链表的时候，要将plist的头指针置空，所以传二级指针。但是，也可以传一级指针，因为我们是带头的双向指针，头节点是一直不变的，下面的头插、头删、尾插、尾删等操作中我们都只需要传一级指针即可。

//释放双向链表
void ListDestory(ListNode** pphead)
{
	assert(*pphead);//断言
	assert(pphead);//断言
	ListNode* cur = (*pphead)->next;
	while (cur != *pphead)//遍历双向链表
	{
		ListNode* next = cur->next;//切记要记录cur的后继节点
		free(cur);
		cur = next;
	}
	free(*pphead);//释放头指针
	*pphead = NULL;//置空头结点
}

2.4 打印双向链表

//打印双向链表
void ListPrint(ListNode* phead)
{
	assert(phead);//断言
	ListNode* cur = phead->next;//记录第一个节点
	printf("head <-> ");
	while (cur != phead)//遍历链表
	{
		printf("%d <-> ", cur->data);
		cur = cur->next;
	}
	printf("head\n");
}

2.5 双向链表尾插

在这里插入图片描述
双向链表尾插步骤：

  1. 记录尾结点（切记不要忘记，不然最后找不到）
  2. 尾结点的后继指针指向新节点
  3. 新节点的前驱指针指向尾结点
  4. 新节点的后继指针指向头指针
  5. 头指针的前驱指针指向新节点
//尾插
void ListPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);//头指针不可以为空
	ListNode* newnode = BuyListNode(x);//动态申请一个节点
	ListNode* tail = phead->prev;//记录尾结点
	tail->next = newnode;//1.尾结点的后继指针指向新节点
	newnode->prev = tail;//2.新节点的前驱指针指向尾结点
	newnode->next = phead;//3.新节点的后继指针指向头指针
	phead->prev = newnode;//4.头指针的前驱指针指向新节点
}

注意：双向链表的尾插操作不需要考虑 是否是第一个元素，都是成立的，这就是双向链表的优势。

测试一下尾插：
在这里插入图片描述

2.6 双向链表尾删

在这里插入图片描述
双向链表尾插的步骤:

  1. 记录尾结点（切记不要忘记，不然最后找不到）
  2. 尾结点的前驱节点（倒数第二个节点）的next指针指向头结点
  3. 头结点的前驱指针指向尾结点的前驱节点（倒数第二个节点）
  4. 释放尾结点
//尾删
void ListPopBack(ListNode* phead)
{
	assert(phead);//断言
	assert(phead->next != phead);//链表不能为空
	ListNode* tail = phead->prev;//记录尾结点
	ListNode* tailPrev = tail->prev;//记录尾结点的前驱节点
	tailPrev->next = phead;//1.尾结点的前驱指针的next指向头结点
	phead->prev = tailPrev;//2.头指针指向尾结点的前驱指针
	free(tail);//3.释放尾结点
}

测试一下尾删：
在这里插入图片描述

2.7 双向链表头插

在这里插入图片描述

//头插
void ListPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);//断言
	ListNode* newnode = BuyListNode(x);//动态申请一个节点
	ListNode* first = phead->next;//记录第一个节点

	phead->next = newnode;//头结点的next指向新节点
	newnode->next = first;//新节点的next指向原来的第一个节点
	newnode->prev = phead;//新节点的前驱节点指向头指针
	first->prev = newnode;//原来的第一个节点的前驱节点指向新节点
}

测试一下头插：
在这里插入图片描述

2.8 双向链表头删

在这里插入图片描述

//头删
void ListPopFront(ListNode* phead)
{
	assert(phead);//断言
	assert(phead->next != phead);//双向链表不能为空
	ListNode* first = phead->next;//记录原来的第一个节点
	phead->next = first->next;//phead的next指向原来第一个节点的后继节点
	first->next->prev = phead;//原来第一个节点的后继节点的prev指向头结点
	free(first);//头删操作
}

测试一下头删：
在这里插入图片描述

2.9 查找双向链表指定值的元素

若查到此元素，返回该元素的地址；若没有找到，返回NULL

//查找指定值的元素，若找到，返回该元素的地址，若没有找到，返回NULL
ListNode* ListFind(ListNode* phead, LTDataType x)
{
	assert(phead);//断言
	assert(phead->next != NULL);//双向链表不能为空
	ListNode* cur = phead->next;//记录第一个节点
	while (cur != phead)//遍历双向链表
	{
		if (cur->data == x)
		{
			return cur;//找到了，返回该元素的地址
		}
		cur = cur->next;
	}
	return NULL;//没有找到，返回NULL
}

2.10 在指定位置pos之前插入元素

在这里插入图片描述

//在指定位置pos之前插入元素
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);//pos的合法性
	ListNode* newnode = BuyListNode(x);//动态申请一个节点
	ListNode* posPrev = pos->prev;//记录pos的前驱节点
	posPrev->next = newnode;//pos的前驱节点的next指向新节点
	newnode->next = pos;//新节点的next指向pos
	newnode->prev = posPrev;//新节点的prev指向pos的前驱节点
	pos->prev = newnode;//pos的prev指向新节点
}

测试一下（配合查找）：

在这里插入图片描述

2.11 删除指定位置pos处的元素

在这里插入图片描述

//删除指定位置pos处的元素
void ListErase(ListNode* pos)
{
	assert(pos);//pos的合法性
	ListNode* posPrev = pos->prev;//记录pos的前驱节点
	ListNode* posNext = pos->next;//记录pos的后继节点
	posPrev->next = posNext;//pos的前驱节点的next指向pos的后继节点
	posNext->prev = posPrev;//pos的后继节点的prev指向pos的前驱节点
	free(pos);//释放pos
}

测试一下（配合查找）：
在这里插入图片描述

3. 完整代码展示

  • List.h
#pragma once

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

typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* prev;//前驱节点
	struct ListNode* next;//后继节点
	LTDataType data;//数据域
}ListNode;

ListNode* BuyListNode(LTDataType x);//动态申请一个新节点
void ListInit(ListNode** pphead);//初始化双向链表
void ListDestory(ListNode** pphead);//释放双向链表
void ListPrint(ListNode* phead);//打印双向链表
void ListPushBack(ListNode* phead, LTDataType x);//尾插
void ListPopBack(ListNode* phead);//尾删
void ListPushFront(ListNode* phead, LTDataType x);//头插
void ListPopFront(ListNode* phead);//头删
ListNode* ListFind(ListNode* phead, LTDataType x);//查找指定值的元素，若找到，返回该元素的地址，若没有找到，返回NULL
void ListInsert(ListNode* pos, LTDataType x);//在指定位置pos之前插入元素
void ListErase(ListNode* pos);//删除指定位置pos处的元素
  • List.c
#include "List.h"

//动态申请一个新节点
ListNode* BuyListNode(LTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)//判断是否申请节点成功
	{
		printf("malloc fail");
		exit(-1);
	}
	newnode->next = NULL;//先置空
	newnode->prev = NULL;//先置空
	newnode->data = x;//赋值
	return newnode;
}

//初始化双向链表
void ListInit(ListNode** pphead)
{
	*pphead = BuyListNode(-1);//动态申请的是头结点
	(*pphead)->prev = *pphead;//前驱指向自己
	(*pphead)->next = *pphead;//后继指针自己，形成循环的链表
}

//释放双向链表
void ListDestory(ListNode** pphead)
{
	assert(*pphead);//断言
	assert(pphead);//断言
	ListNode* cur = (*pphead)->next;
	while (cur != *pphead)//遍历双向链表
	{
		ListNode* next = cur->next;//切记要记录cur的后继节点
		free(cur);
		cur = next;
	}
	free(*pphead);//释放头指针
	*pphead = NULL;//置空头结点
}

//打印双向链表
void ListPrint(ListNode* phead)
{
	assert(phead);//断言
	ListNode* cur = phead->next;//记录第一个节点
	printf("head <-> ");
	while (cur != phead)//遍历链表
	{
		printf("%d <-> ", cur->data);
		cur = cur->next;
	}
	printf("head\n");
}

//尾插
void ListPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);//头指针不可以为空
	ListNode* newnode = BuyListNode(x);//动态申请一个节点
	ListNode* tail = phead->prev;//记录尾结点
	tail->next = newnode;//1.尾结点的后继指针指向新节点
	newnode->prev = tail;//2.新节点的前驱指针指向尾结点
	newnode->next = phead;//3.新节点的后继指针指向头指针
	phead->prev = newnode;//4.头指针的前驱指针指向新节点
}

//尾删
void ListPopBack(ListNode* phead)
{
	assert(phead);//断言
	assert(phead->next != phead);//链表不能为空
	ListNode* tail = phead->prev;//记录尾结点
	ListNode* tailPrev = tail->prev;//记录尾结点的前驱节点
	tailPrev->next = phead;//1.尾结点的前驱指针的next指向头结点
	phead->prev = tailPrev;//2.头指针指向尾结点的前驱指针
	free(tail);//3.释放尾结点
}

//头插
void ListPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);//断言
	ListNode* newnode = BuyListNode(x);//动态申请一个节点
	ListNode* first = phead->next;//记录第一个节点

	phead->next = newnode;//头结点的next指向新节点
	newnode->next = first;//新节点的next指向原来的第一个节点
	newnode->prev = phead;//新节点的前驱节点指向头指针
	first->prev = newnode;//原来的第一个节点的前驱节点指向新节点
}

//头删
void ListPopFront(ListNode* phead)
{
	assert(phead);//断言
	assert(phead->next != phead);//双向链表不能为空
	ListNode* first = phead->next;//记录原来的第一个节点
	phead->next = first->next;//phead的next指向原来第一个节点的后继节点
	first->next->prev = phead;//原来第一个节点的后继节点的prev指向头结点
	free(first);//头删操作
}

//查找指定值的元素，若找到，返回该元素的地址，若没有找到，返回NULL
ListNode* ListFind(ListNode* phead, LTDataType x)
{
	assert(phead);//断言
	assert(phead->next != NULL);//双向链表不能为空
	ListNode* cur = phead->next;//记录第一个节点
	while (cur != phead)//遍历双向链表
	{
		if (cur->data == x)
		{
			return cur;//找到了，返回该元素的地址
		}
		cur = cur->next;
	}
	return NULL;//没有找到，返回NULL
}

//在指定位置pos之前插入元素
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);//pos的合法性
	ListNode* newnode = BuyListNode(x);//动态申请一个节点
	ListNode* posPrev = pos->prev;//记录pos的前驱节点
	posPrev->next = newnode;//pos的前驱节点的next指向新节点
	newnode->next = pos;//新节点的next指向pos
	newnode->prev = posPrev;//新节点的prev指向pos的前驱节点
	pos->prev = newnode;//pos的prev指向新节点
}

//删除指定位置pos处的元素
void ListErase(ListNode* pos)
{
	assert(pos);//pos的合法性
	ListNode* posPrev = pos->prev;//记录pos的前驱节点
	ListNode* posNext = pos->next;//记录pos的后继节点
	posPrev->next = posNext;//pos的前驱节点的next指向pos的后继节点
	posNext->prev = posPrev;//pos的后继节点的prev指向pos的前驱节点
	free(pos);//释放pos
}
  • test.c
#include "List.h"

void test01()
{
	ListNode* plist = NULL;
	ListInit(&plist);//初始化双链表，创建头结点
	//尾插几个数据
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 5);

	//删除指定位置pos处的元素
	ListNode* pos = ListFind(plist, 3);
	ListErase(pos);

	在指定位置pos出的前面插入元素
	//ListNode* pos = ListFind(plist, 3);
	//ListInsert(pos, 50);

	头删
	//ListPopFront(plist);
	//ListPopFront(plist);

	头插几个数据
	//ListPushFront(plist, 10);
	//ListPushFront(plist, 20);
	//ListPushFront(plist, 30);

	尾删
	//ListPopBack(plist);
	//ListPopBack(plist);

	//打印双向链表
	ListPrint(plist);
}

int main()
{
	test01();
	system("pause");
	return 0;
}
孙同学要努力
关注
专栏目录
【数据结构】链表其实并不难 —— 手把手带你实现双向链表
StackFrame
11-10 3198
简述双向链表概念、C语言实现双向链表
【最强链表结构】双向带头循环链表——C实现
m0_63816268的博客
04-04 1492
前言🎆 笔者也仅是大一萌新，写博客为了记录和巩固知识✨ 赠人玫瑰，手留余香，欢迎各位读者进行交流和建议🥰 能与大家一起学习，一起进步是我的荣幸🌹 如果这篇文章有帮助到您，还请留个赞支持一下哦🤞 ✨往期文章✨ 🎃顺序表🎃 🎃单链表🎃 目录🎆 链表的种类 双向带头循环链表实现 1.代码声明 2.初始化 3.打印函数 4.扩容函数 5.尾插尾删 6.头插头删 7.查找函数 8.pos插删 9.清空函数 10.总代码 链表的种类✨ 1.单向或双向 2.带头或者不带头 3.循环或者非循环 .
双向链表代码
11-30
双向链表示范代码，详细解释了双向链表的使用方法
双向循环链表代码
m0_49201977的博客
02-09 240
双向链表也叫双链表，是链表的一种，它的每个数据结中都有两个指针，分别指向直接后驱和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便的访问它的前驱结点和后驱结点。易班我们都称为双向循环链表 public class LinkedList<E> implements List<E> , Dequeue<E> , Stack<E> { @Override public void addFirst(E element) { .
双向链表代码实现
weixin_44001521的博客
12-26 248
#include<iostream> using namespace std; typedef int ElementType;//定义类型 typedef struct DuLNode { ElementType data; struct DuLNode * prior;//前继 struct DuLNode * next;//后继 }DuLNode,* DuLinkLi...
C# 实现双向链表
RoySummy的博客
09-08 1332
双向链表 目录双向链表节点代码代码框架思路遍历直接添加到链表末尾依据编号顺序添加修改删除 节点代码 class Node { public int ID { get; set; } public string Name { get; set; } public string NickName { get; set; } public Node Next { get; set; } public Node Pre
数据结构c版（1）-线性表之双向带头循环链表代码
最新发布
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
数据结构：带头双向循环链表——增加、删除、查找、修改，详细解析
昵称就是昵称吧的博客
04-09 4915
读者可以先阅读这一篇：数据结构——单链表的增加、删除、查找、修改，详细解析_昵称就是昵称吧的博客-CSDN博客，可以更好的理解带头双向循环链表。 一、带头双向循环链表的处理和介绍 1、带头双向循环链表的概念 链表的概念：链表是一种物理存储结构上非连续、非顺序的数据结构——单链表的增加、删除、查找、修改，详细解析_昵称就是昵称吧的博客-CSDN博客，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 带头双向循环链表是链表中最复杂的，因为它具有了链表存在的结构中所有的结构：带头...
数据结构——双向循环链表（C语言实现）
GDYJLXQ的博客
10-22 319
双向循环链表：结构复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势。
C++实现双向链表（完整代码）
05-10
使用面向对象实现的双向链表，适合初学者的学习与借鉴。（完整代码已测试）
双向链表源代码
道法自然
11-10 920
list.c #include #include #include #include "list.h" LLIST *llist_create(int size) { LLIST *newnode; newnode=malloc(sizeof(*newnode)); if(newnode==NULL) ret
双向链表的代码实现
m0_66971047的博客
09-27 278
双向链表的实现
双向链表 代码
dellme99的专栏
01-25 489
 #include #include typedef struct node {  struct node *prev;  struct node *next;  int value; } Node; class linked_list { private:  Node * head;  Node * cur; public:  linked_list()
双向链表代码实现-C语言
Zechin的专栏
04-28 1965
双向链表C语言代码实现......
双向循环链表代码实践
NineFailure的博客
03-28 547
双向循环链表代码实践
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值