【数据结构与算法】双向带头循环链表（附源码）

最新推荐文章于 2024-11-05 11:47:58 发布
最新推荐文章于 2024-11-05 11:47:58 发布
阅读量1.0k 收藏 39
点赞数 54
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 算法 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73868817/article/details/129602277
版权
本文介绍了双向带头循环链表的结构，包括头节点、前驱后继指针以及循环特性。文章详细阐述了链表的初始化、插入（头插、尾插、任意位置插入）、删除（头删、尾删、任意位置删除）等操作的接口实现，并提供了源码实现。双链表简化了插入和删除操作，无需寻找前驱或后继节点。
摘要由CSDN通过智能技术生成

 

目录

一.前言

二.双向带头循环链表的结构

三.接口实现

A.初始化 ListNodeinit 和销毁 Listdestroy

1.ListNodeinit

2.Listdestroy

B.插入

1.头插  ListNodepushfront

2.尾插 ListNodepushback

3.插入 ListNodeinsert

C.删除

1.头删 ListNodepopfront

2.尾删 ListNodepopback

3.删除 ListNodeerase

D.打印  ListNodeprint

四.源码

List.h

List.c

test.c

一.前言

在前面的博客中，我们学习了顺序表和结构最简单的链表——单链表，但是单链表存在在着一些不足，比如单链表的插入和删除的操作，总是要找到指定节点的前驱或是后继，这样就会比较麻烦。

那么本篇文章所讲述的双向带头循环链表（以后简称双链表），就可以很好解决这个问题。

二.双向带头循环链表的结构

1.该链表有一个哨兵位节点，即头节点；

2.每个节点都包含一个prev 指针和 next 指针，分别指向当前节点的前驱和后继；

3.头节点的 prev 指向的是尾节点，尾节点的next 指向的是头节点，这样就实现了循环。

请看图示：

 别看结构这么复杂，但其实它是一个很厉害的结构，代码实现会很简单。

三.接口实现

A.初始化 ListNodeinit 和销毁 Listdestroy

1.ListNodeinit

这个接口用来创建哨兵位头节点，并使该节点的 prev 和 next 都指向自己以实现循环的目的。

LNode* Buynewnode(DLdatatype x)   //定义一个 malloc 新节点的函数，以便后续需要
{
	LNode* newnode = (LNode*)malloc(sizeof(LNode));
	assert(newnode);
	newnode->prev = NULL;
	newnode->next = NULL;
	newnode->data = x;
	return newnode;
}
LNode* ListNodeinit()
{
	LNode* phead = (LNode*)malloc(sizeof(LNode));
	assert(phead);
	phead->prev = phead;  //使其都指向自己
	phead->next = phead;
	phead->data = -1;
	return phead;
}

2.Listdestroy

我们需要遍历链表，并定义一个next 来保存 cur 的下一个节点，在链表都free 完后，再销毁头节点；

注意：应该是从头节点的 next 开始遍历。

void ListNodedestroy(LNode* phead)
{
	assert(phead);

	LNode* cur = phead->next;
	while (cur != phead)
	{
		LNode* next = cur->next;
		free(cur);
		cur = next;
	}

	free(phead);
	phead = NULL;
}

B.插入

1.头插  ListNodepushfront

1.这里要头插就太简单了，但是我们最好保存一下头节点的 next ，这样就不应考虑链接时的顺序问题；

2.使头节点的 next 指向新节点，然后新节点的 prev 指向头节点；

3.新节点的 next 指向保存的节点，保存的节点的 prev 指向新节点；

这里并不需要考虑链表为空的情况，这就是双链表的强大之处。

void ListNodepushfront(LNode* phead, DLdatatype x)
{
	assert(phead);

	LNode* newnode = Buynewnode(x);

	LNode* first = phead->next;  //保存头节点的下一个

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

2.尾插 ListNodepushback

1.尾插就需要找尾；

2.这里的找尾很简单，就是头节点的 prev；

3.将尾节点与新节点链接起来。

void ListNodepushback(LNode* phead, DLdatatype x)
{
	assert(phead);

	LNode* newnode = Buynewnode(x);
	LNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;

}

3.插入 ListNodeinsert

1.再插入前需要写一个 find 函数，用来寻找指定的位置 pos；

2.找到 pos 的前驱 prev ；

3.将前驱，pos，新节点链接起来。

LNode* ListNodefind(LNode* phead,DLdatatype x)
{
	assert(phead);

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

		cur = cur->next;

	}

	return NULL;
}

void ListNodeinsert(LNode* pos, LNode* phead, DLdatatype x)
{
	assert(phead);
	assert(pos);

	LNode* newnode = Buynewnode(x);
	LNode* prev = pos->prev;

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

总结：其实可以用一个插入接口就可以实现头插和尾插这两个接口。

C.删除

1.删除时要注意的点是不能把头节点也给删了，如果删了就破坏了双链表的结构；

2.如果是空链表也不能删除。

1.头删 ListNodepopfront

1.删除时保存其下一个节点；

2.链接头节点 phead 和 保存的下一个节点；

3.删除 phead 的next。

void ListNodepopfront(LNode* phead)
{
	assert(phead);
	assert(ListNodeempty(phead));
	if (phead->next == phead)
	{
		perror("ListNodepopfront");
		return;
	}

	LNode* first = phead->next;
	LNode* second = first->next;
	phead->next = second;
	second->prev = phead;

	free(first);
	first = NULL;

	
}

2.尾删 ListNodepopback

1.找尾，即：phead的prev；

2.找尾节点的前驱 prev ，使其next指向phead，phead的prev指向该前驱；

void ListNodepopback(LNode* phead)
{
	assert(phead);
	assert(ListNodeempty(phead));

	if (phead->next == phead)
	{
		perror("ListNodepopback");
		exit(-1);
	}

	LNode* tail = phead->prev;
	LNode* prev = tail->prev;

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

3.删除 ListNodeerase

1.调用 find 函数找到要删除的节点pos；

2.找到 pos 的前驱和后继；

3.链接其前驱，后继；

4.删除pos。

void ListNodeerase(LNode* pos, LNode* phead)
{
	assert(phead);
	assert(pos);

	if (phead->next == phead)
	{
		perror("ListNodeerase");
		exit(-1);
	}
	LNode* prev = pos->prev;
	LNode* next = pos->next;

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

	free(pos);
	pos = NULL;
}

总结：这里可以复用删除函数去实现头删和尾删。

D.打印  ListNodeprint

注意是从头节点的下一个节点开始遍历，且循环终止条件是看是否等于 phead，因为双链表没有 NULL。

void ListNodeprint(LNode* phead)
{
	assert(phead);
	LNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d <=> ", cur->data);
		cur = cur->next;
	}

	printf("\n");

	
}

四.源码

List.h

#pragma once


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

typedef int DLdatatype;

typedef struct ListNode
{
	struct ListNode* prev;
	struct ListNode* next;
	DLdatatype data;
}LNode;

LNode* ListNodeinit();

void ListNodeprint(LNode* phead);

void ListNodepushback(LNode*phead,DLdatatype x);

void ListNodepushfront(LNode* phead, DLdatatype x);

void ListNodepopback(LNode* phead);

void ListNodepopfront(LNode* phead);

LNode* ListNodefind(LNode* phead,DLdatatype x);

void ListNodeinsert(LNode* pos, LNode* phead, DLdatatype x);

void ListNodeerase(LNode* pos, LNode* phead);

void ListNodedestroy(LNode* phead);

List.c

#define _CRT_SECURE_NO_WARNINGS

#include "List.h"

LNode* Buynewnode(DLdatatype x)
{
	LNode* newnode = (LNode*)malloc(sizeof(LNode));
	assert(newnode);
	newnode->prev = NULL;
	newnode->next = NULL;
	newnode->data = x;
	return newnode;
}

LNode* ListNodeinit()
{
	LNode* phead = (LNode*)malloc(sizeof(LNode));
	assert(phead);
	phead->prev = phead;
	phead->next = phead;
	phead->data = -1;
	return phead;
}

void ListNodeprint(LNode* phead)
{
	assert(phead);
	LNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d <=> ", cur->data);
		cur = cur->next;
	}

	printf("\n");

	
}

void ListNodepushback(LNode* phead, DLdatatype x)
{
	assert(phead);

	/*LNode* newnode = Buynewnode(x);
	LNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;*/

	ListNodeinsert(phead, phead, x);

	
}

void ListNodepushfront(LNode* phead, DLdatatype x)
{
	assert(phead);

	/*LNode* newnode = Buynewnode(x);

	LNode* first = phead->next;

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

	ListNodeinsert(phead->next, phead, x);
}

bool ListNodeempty(LNode* phead)
{
	assert(phead);

	return phead->next == phead;
}

void ListNodepopback(LNode* phead)
{
	assert(phead);
	//assert(ListNodeempty(phead));

	if (phead->next == phead)
	{
		perror("ListNodepopback");
		exit(-1);
	}

	/*LNode* tail = phead->prev;
	LNode* prev = tail->prev;

	prev->next = phead;
	phead->prev = prev;
	free(tail);
	tail = NULL;*/

	ListNodeerase(phead->prev, phead);
}

void ListNodepopfront(LNode* phead)
{
	assert(phead);
	//assert(ListNodeempty(phead));
	if (phead->next == phead)
	{
		perror("ListNodepopfront");
		return;
	}

	/*LNode* first = phead->next;
	LNode* second = first->next;
	phead->next = second;
	second->prev = phead;

	free(first);
	first = NULL;*/

	ListNodeerase(phead->next, phead);
}

LNode* ListNodefind(LNode* phead,DLdatatype x)
{
	assert(phead);

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

		cur = cur->next;

	}

	return NULL;
}

void ListNodeinsert(LNode* pos, LNode* phead, DLdatatype x)
{
	assert(phead);
	assert(pos);

	LNode* newnode = Buynewnode(x);
	LNode* prev = pos->prev;

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

void ListNodeerase(LNode* pos, LNode* phead)
{
	assert(phead);
	assert(pos);

	if (phead->next == phead)
	{
		perror("ListNodeerase");
		exit(-1);
	}
	LNode* prev = pos->prev;
	LNode* next = pos->next;

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

	free(pos);
	pos = NULL;
}

void ListNodedestroy(LNode* phead)
{
	assert(phead);

	LNode* cur = phead->next;
	while (cur != phead)
	{
		LNode* next = cur->next;
		free(cur);
		cur = next;
	}

	free(phead);
	phead = NULL;

}

test.c

至于test.c 就不贴出来了，这里面主要是一些测试接口的代码，没必要贴出来。

😽本篇文章到此就结束了，若有错误或是建议，欢迎小伙伴们指出；😻

😍请多多支持博主哦~🥰

🤩谢谢你的阅读~😃

 

nagiY
关注
专栏目录
C语言实现循环链表Circularly Linked List(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-02 312
循环链表Circularly Linked Listnode结构体循环链表Circularly Linked List完整源码（定义，实现，main函数测试） node结构体 struct node { int data ; struct node *next ; } ; 循环链表Circularly Linked List完整源码（定义，实现，main函数测试） #include <stdio.h> #include <conio.h> #include &l
实现C#循环链表 - 附完整源码
BUG？不存在的！
04-15 237
循环链表是一种特殊的链表，它与普通链表不同的是，它的最后一个节点指向第一个节点，形成了一个环状结构。在C#中，我们可以通过定义一个节点类来实现循环链表。首先，我们定义一个节点类CircularListNode，该类包含三个属性：数据data、前一个节点previous和后一个节点next。以上就是实现C#循环链表的方法和完整源代码。通过定义一个节点类和一个循环链表类，我们可以方便地进行插入、删除、查找和遍历等操作。接下来，我们定义循环链表类CircularLinkedList，该类包含一个头结点head。
循环链表的源代码
05-16
循环链表的实现，包括查找删除修改的实现，其中详细介绍了循环链表的原理，以及各个部分的代码实现
循环链表源代码实现
天蝎技术专栏
09-17 1008
    所谓循环链表，实质上与单向链表不同的是，尾结点的下一指向不再为NULL,而是指向了链表头，形成了一个串烧；当你检测是否到尾结点的时候，只需要检测尾结点的下一指向是否是头结点，如果是，则终止循环条件即可。下面是我实现的一个循环链表：#include using namespace std;struct MyLink{ int Volue; MyLink *next;};typedef struct MyLink LinkStruct;typedef LinkStruct* pLinkStruct;//
c语言最简单循环链表,c语言循环单链表(示例代码)
weixin_36410316的博客
05-21 392
/*************************************************************************> File Name: singleLineTable.c> Author: zshh0604> Mail: [emailprotected]> Created Time: 2014年10月15日 星期三 11时34分08秒...
三郎数据结构学习笔记：双向循环链表（判断是否对称）附源码
m0_51684972的博客
11-05 406
双向循环链表题目思想实验结果完整源代码 题目 建立一个带头结点的双向循环链表， 赋值，判断是否对称，写出算法计算时间复杂度 思想 travel the Link ；遍历链表 put values into a array ；赋值给一个数组 compare the array to know whether it belong to symmetry 比较数组是否对称 采用问题转化的思想 将链表问题转换成数组问题，大大降低了思考难度 时间复杂度O（n^2） 因为有两个for循环 实验结果 比较次数本来可以更
【数据结构与算法】带头双向循环链表
weixin_60478154的博客
08-03 5463
【数据结构与算法】——带头双向循环链表
数据结构与算法详解——链表篇（附c++实现代码）
JMasker的博客
05-01 3253
链表详解及完整实现
数据结构与算法 | 带头双向循环链表
凌桓丶的博客
02-13 479
上一节里实现的是最简单的链表，在实际中那种链表不会单独用来存储数据，更多是作为其他数据结构的子结构，如图的邻接表等。而比较常用的就是带头双向循环链表。 通过对比我们可以看出有三个不同，多了头节点，链表中的元素之间不再是单向而是双向，头尾节点相连，构成循环链表。 虽然结构比起之前的复杂了一点，但是优势却十分明显。 如普通链表要访问最后的元素时，只能通过遍历链表来取得，而这个可以直接取头节点的前一...
数据结构-基本算法-不带头结点的循环链表
05-21
数据结构-基本算法-不带头结点的循环链表(学生时代源码，调试可运行)
关于destroy（）与list集合之间的问题
So_langdechibang的博客
10-31 1599
最近在学习做一塔防游戏： 炮塔如何选择攻击目标，一般来说就是攻击第一个检测到的敌人，直到其血量为空死亡 一、为炮塔添加collider 确定其攻击范围，为导弹添加collider做碰撞 二、编写炮塔collider脚本： public List enemys = new List(); public void ListEnemysAdd(GameObject enemysList) //
第三周项目1-(3)ListInsert、ListDelete、InitList、DestroyList函数
热门推荐
lalala_wm的博客
09-16 1万+
/* *Copyright (c) 2015,烟台大学计算机学院 *All rights reserved. *文件名称：test.cpp *作者：王敏 *完成日期：2015年09月14日 *版本号：v1.0 * *问题描述：测试“建立线性表”的算法ListInsert、ListDelete、InitList函数 *输入描述： 程序输出： */ #inc
循环单链表（代码完整）
weixin_41475854的博客
12-26 3146
头文件： #include <iostream> #include <cstring> using namespace std; struct Node { int data; Node *next; }; class CCircleList { public: CCircleList(); //创建一个头结点，next 指向自己 virtua...
在javascript将NodeList作为Array数组处理的方法
vicky_lxw的博客
08-28 2137
比如： 复制代码 代码如下: var anchors = document.getElementsByTagName("a"); for (i = 0; i < anchors.length; i++) { var ele=anchors[i];//取某一个元素 //some code here } 上面的代码表示获取文档中的所有链接元素，然后遍历做一些事情。 也许你会问，通过这种...
对于ListNode的学习
weixin_45739050的博客
03-02 499
import java.util.ArrayList; import java.util.Stack; public class Solution { public ArrayList printListFromTailToHead(ListNode listNode) { ArrayList list = new ArrayList();//返回一个列表 Stack stack...
＜数据结构与算法＞带头双向循环链表
prodigy623的博客
03-29 420
双向带头循环链表
java实现带头双向循环链表(附完整源码)
06-08
该代码实现了带头双向循环链表的数据结构，支持在链表末尾添加元素、在指定位置插入元素、删除指定位置的元素、获取指定位置的元素、获取链表长度等操作。在算法实现中，通过一个Node类来表示链表中的节点，包含数据...
c++ listnode 赋值_C++操作单链表ListNode
weixin_35677043的博客
01-26 1914
C++操作单链表ListNode通过C++进行单链表的创建、打印以及利用栈实现逆序打印。单链表的创建和打印#include using namespace std;//定义结构体struct ListNode{int val;ListNode* next;};class operateList{public:/*创建单链表*/void createList(ListNode *head){int ...
【进阶】java基础之集合(2)数据结构＜树＞
Y0UZI的博客
11-05 359
二叉查找树，又称二叉排序树或者二叉搜索树。:任意节点左右子树高度差不超过1。
python - leetcode【数据结构-算法】-入门/通关手册
最新发布
weixin_44151034的博客
11-05 994
因为笔者马上要去面试了，正在刷leetcode，同时准备着与leetcode相关的python知识点。所以其实主要就是介绍上面两个和python相关的算法帖子。Python学习笔记【Python 和 LeetCode 】Python 基础｜LeetCode 算法知识点总结 ｜ 刷LeetCode笔记 ｜ 整理中。。。LeetCode刷题必知的Python知识Python 必知必会知识点python基础语法——常量、变量、注释、输入输出和运算符python教程。
评论 44
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值