带虚拟头结点的双向循环链表

最新推荐文章于 2024-07-25 16:50:09 发布
最新推荐文章于 2024-07-25 16:50:09 发布
阅读量167 收藏
点赞数 3
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asan_334/article/details/127274759
版权

双向 (循环)链表. 整个链表只能单方向从表头访问到表尾，这种结构的链表统称为 “单向链表”或“单链表”。. 如果算法中需要频繁地找某结点的前趋结点，单链表的解决方式是遍历整个链表，增加算法的时间复杂度，影响整体效率。. 为了快速便捷地解决这类问题，在单向链表的基础上，给各个结点额外配备一个指针变量，用于指向每个结点的直接前趋元素。. 这样的链表被称为“双向链表”或者“双链表”。.

循环双链表与循环单链表类似, 只是在某些操作上有所不同.

首先是定义, 这里的命名为:

pre: 前驱元素

next:后继元素

由此, 对于单向链表的尾指针, 相当于双向链表头结点的前驱元素

typedef struct ListNode{
	ListNode *pre, *next;
	int val;
}ListNode;

结点和链表的初始化:

ListNode *initListNode(int val){
	ListNode *node = (ListNode *)malloc(sizeof(ListNode));
	node->pre = node->next = NULL;
	node->val = val;
	return node;
}

LinkList *initLinkList(){
	LinkList *list = (LinkList *)malloc(sizeof(LinkList));
	list->head.val = 0;
	list->head.pre = list->head.next = &(list->head);
	return list;
}

这里list->head.pre = list->head.next = &(list->head)的原因与单向循环链表的tail及head.next是一样的, 与下面函数的操作有很大关联.

链表的清空与单链表有所不同(单向循环链表里面忘记提及，这里补一下):

void clearLinkList(LinkList *list){
	if(list == NULL) return;
	ListNode *p = list->head.next, *q;
	while(p != &(list->head)){
		q = p->next;
		clearListNode(p);
		p = q;
	}
	free(list);
	return;
}

这里将clear相当于destroy，想要分别实现两种操作请参考单向链表;

由于list->head.val维护了list的长度, 而双向链表可以有两种遍历方向, 于是可以考虑根据操作下标在链表中的位置来优化时间↓↓↓

插入和删除:        内部操作与普通双链表一致, 但是带有位置优化，使得期望时间复杂度低于O(n)

bool insert(LinkList *list, int ind, int val){
	if(list == NULL || ind < 0 || ind > list->head.val) return false;
	//考虑一下双向链表对于插入与删除的优化;

	ListNode *node = initListNode(val), *p = &(list->head);
	if(ind > (list->head.val >> 1)){
		ind = list->head.val + 1 - ind;
		while(ind--) p = p->pre;
		node->pre = p->pre;
		node->next = p;
		p->pre->next = node;
		p->pre = node;
	}else{
		while(ind--) p = p->next;
		node->next = p->next;
		node->pre = p;
		p->next->pre = node;
		p->next = node;
	}
	
	list->head.val++;
	return true;
}

删除:

bool erase(LinkList *list, int ind){
	if(list == NULL || ind < 0 || ind >= list->head.val) return false;
	
	ListNode *p = &(list->head), *q;
	if(ind > (list->head.val >> 1)){
		ind = list->head.val + 1 - ind;
		while(ind--) p = p->pre;
		q = p->pre->pre;
		clearListNode(p->pre);
		p->pre = q;
		q->next = p;
	}else{
		while(ind--) p = p->next;
		q = p->next->next;
		clearListNode(p->next);
		p->next = q;
		q->pre = p;
	}
	list->head.val--;
	return true;
}

由于双向链表的两个方向, 所以遍历方式也有两种: ordered顺序遍历, reverse逆序遍历

void orderedOutput(LinkList *list){
	if(list == NULL) return;
	puts("Ordered output:");
	printf("LinkList(%d): head-> ", list->head.val);
	for(ListNode *p = list->head.next; p != &(list->head); p = p->next){
		printf("%d-> ", p->val);
	}
	puts("head\n");
	return;
}

void reverseOutput(LinkList *list){
	if(list == NULL) return;
	puts("Reverse output:");
	printf("LinkList(%d): head<- ", list->head.val);
	for(ListNode *p = list->head.pre; p != &(list->head); p = p->pre){
		printf("%d<- ", p->val);
	}
	puts("head\n");
	return;
}

 下面是双向循环链表的完整代码:(带DEBUG)

#include<bits/stdc++.h>
using namespace std;

typedef struct ListNode{
	ListNode *pre, *next;
	int val;
}ListNode;

typedef struct LinkList{
	ListNode head;
}LinkList;

ListNode *initListNode(int val){
	ListNode *node = (ListNode *)malloc(sizeof(ListNode));
	node->pre = node->next = NULL;
	node->val = val;
	return node;
}

LinkList *initLinkList(){
	LinkList *list = (LinkList *)malloc(sizeof(LinkList));
	list->head.val = 0;
	list->head.pre = list->head.next = &(list->head);
	return list;
}

void clearListNode(ListNode *node){
	if(node == NULL) return;
	free(node);
	return;
}

void clearLinkList(LinkList *list){
	if(list == NULL) return;
	ListNode *p = list->head.next, *q;
	while(p != &(list->head)){
		q = p->next;
		clearListNode(p);
		p = q;
	}
	free(list);
	return;
}

bool insert(LinkList *list, int ind, int val){
	if(list == NULL || ind < 0 || ind > list->head.val) return false;
	//考虑一下双向链表对于插入与删除的优化;

	ListNode *node = initListNode(val), *p = &(list->head);
	if(ind > (list->head.val >> 1)){
		ind = list->head.val + 1 - ind;
		while(ind--) p = p->pre;
		node->pre = p->pre;
		node->next = p;
		p->pre->next = node;
		p->pre = node;
	}else{
		while(ind--) p = p->next;
		node->next = p->next;
		node->pre = p;
		p->next->pre = node;
		p->next = node;
	}
	
	list->head.val++;
	return true;
}

bool erase(LinkList *list, int ind){
	if(list == NULL || ind < 0 || ind >= list->head.val) return false;
	
	ListNode *p = &(list->head), *q;
	if(ind > (list->head.val >> 1)){
		ind = list->head.val + 1 - ind;
		while(ind--) p = p->pre;
		q = p->pre->pre;
		clearListNode(p->pre);
		p->pre = q;
		q->next = p;
	}else{
		while(ind--) p = p->next;
		q = p->next->next;
		clearListNode(p->next);
		p->next = q;
		q->pre = p;
	}
	list->head.val--;
	return true;
}

void orderedOutput(LinkList *list){
	if(list == NULL) return;
	puts("Ordered output:");
	printf("LinkList(%d): head-> ", list->head.val);
	for(ListNode *p = list->head.next; p != &(list->head); p = p->next){
		printf("%d-> ", p->val);
	}
	puts("head\n");
	return;
}

void reverseOutput(LinkList *list){
	if(list == NULL) return;
	puts("Reverse output:");
	printf("LinkList(%d): head<- ", list->head.val);
	for(ListNode *p = list->head.pre; p != &(list->head); p = p->pre){
		printf("%d<- ", p->val);
	}
	puts("head\n");
	return;
}
int main(){
	#define MAX_N 1010    //可以在这里修改测试的数据量
	srand(time(0));
	LinkList *list = initLinkList();
	for(int i = 0; i < MAX_N; i++){
		int op = rand() % 6, val = rand() * rand() % 10000000, ind = rand() % (list->head.val + 1);
		switch(op){
			case 0:
				if(erase(list, ind)) printf("Erase elem at %d from the list\n", ind);
				else puts("Failed to erase elem from the list");
				break;
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
				if(insert(list, ind, val)) printf("Insert %d at %d to the list\n", val, ind);
				else puts("Failed to insert elem to the list");
		}
		orderedOutput(list);
		reverseOutput(list);
	}
	clearLinkList(list);
	printf("%d", list->head.val);    //RE操作(逃
	return 0;
}

φ * 1
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
实现单向链表（假头）和双向链表（假头和假尾）
qq_39227541的博客
03-01 510
看清合法与不合法的要求！！！！ 单向链表（别忘了节点类） //创建链表的节点 public class ListNode { int val; ListNode next; ListNode(int val){ this.val=val; } } //链表的尺寸和“假”头结点 class MyLinkedList { int size; ListNode head; public MyLinked
【数据结构】双向链表
睿的博客
03-19 1029
双链表你真的掌握了吗？快来学学吧！
带头结点双链表（循环）基本操作实现解析
weixin_42224065的博客
10-18 833
双链表，双循环链表，带头双循环链表，不带头双循环链表，带头初始化方式，外部结点
带有头节点的双链表
weixin_47511190的博客
08-12 121
#include<bits/stdc++.h> using namespace std; //带有头节点的双链表 struct LNode{ int data; LNode *next; LNode *prior; }; //初始化链表 void InitList(LNode * &L){ L=(LNode *)malloc(sizeof(LNode)); L->next=NULL; L->prior=NULL; } //判断链表是否为空 boo
链表-虚拟头结点
sueong的博客
03-29 2319
链表基础 C/C++的定义链表节点方式 // 单链表 struct ListNode { int val; // 节点上存储的元素 ListNode *next; // 指向下一个节点的指针 ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数 }; C++默认生成一个构造函数。 通过自己定义构造函数初始化节点： ListNode* head = new ListNode(5); 使用默认构造函数初始化节点： ListNo
复习题纲要_任务指导书1
08-08
8. **双向循环链表的插入**：在双向循环链表中插入节点需要修改当前节点前一个节点的 next 指针，当前节点的 prev 指针，以及新节点的 prev 和 next 指针，总共4个指针域。 9. **链表删除操作**：删除链表中的节点 ...
电子科技大学计算机考研820专业课考点 (3).docx
11-18
2. 线性表的顺序存储和链式存储，包括循环链表、双向链表和带头结点的链表。 3. 栈和队列的定义、存储结构和应用，如循环队列的判满和判空方法。 4. 二叉树的性质、存储结构、遍历方式，如线索二叉树的构造方法。 5....
基础数据结构----刘汝佳
05-22
带头结点的双链表增加了一个虚拟头结点，使得对链表的操作更加统一和简化。 #### 队列 队列是一种先进先出（FIFO）的数据结构，主要支持在队尾添加元素（入队）和在队首删除元素（出队）。书中提到了循环队列和Open...
820计算机专业基础考纲.pdf
10-11
2. 线性表的定义、基本操作以及顺序存储和链式存储的实现，包括循环链表、双向链表和带头结点链表。 3. 栈和队列的基本概念、存储结构和应用，如循环队列的判满、判空方法。 4. 广义表的基本概念和操作。 5. 树和...
电子科技大学820考研大纲.pdf
11-18
2. 线性表：定义、顺序存储与链式存储的实现、循环链表、双向链表、带头结点链表的操作，递归的实现方法，栈和队列的性质、存储结构及其应用，循环队列的判满和判空，特殊矩阵的压缩存储。 3. 广义表的概念、存储...
学习记录day19——数据结构 查找算法
weixin_64918301的博客
07-25 386
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 229
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
java算法原理
jylee的博客
07-25 819
正确回答通过率：40.0%[ 详情 ] 推荐指数： ★★★★ 试题难度： 高难 试题类型： 编程题 ▸ 写笔记试题回答参考思路： >>
c语言（7.23）
fhgfyrsg的博客
07-23 687
【代码】c语言（7.23）
EXT4 数据结构
最新发布
弥川的博客
07-25 357
结构 ext4_inode 实际使用的超出最初 128 字节 ext2 inode 的字节数记录在每个 inode 的 i_extra_isize 字段中，这使得结构 ext4_inode 可以在新内核中增长，而无需升级所有磁盘上的 inode。ext4 开始，flex_bg 中几个块组被捆绑在一起作为一个 逻辑块组，bitmap 空间和 inode Table 空间 flex_bg 的第一个块组被扩展为包括位图以及 flex_bg 中所有其他块组的 inode 表。没有 inode 0。
数据结构（3）（顺序栈）
qq_54094530的博客
07-25 547
栈是限定仅在栈顶进行插入和删除操作的线性表，在操作的时候，只允许栈顶改变不允许栈底改变，具有后进先出的特征。
数据结构前言
weixin_67466860的博客
07-25 1060
主要了解学习数据结构之前所需要了解的知识
算法 - 查找算法（顺序、折半、红黑树、AVL树、B+树、散列）
暴力扬
07-21 983
本文一共讲解了以下查找算法： 1. 顺序查找 2. 折半查找（二分查找） 3. 分块查找 4. 二叉排序树查找 5. 平衡二叉树（AVL树）查找 6. 红黑树查找 7. B树查找 8. B+树查找 9. 散列查找 每种查找算法都包括了其查找原理、实现步骤、代码实现思路、C语言代码以及代码解释。
数据结构--二叉树详解
2302_81705247的博客
07-24 800
二叉树的分类、二叉树的遍历。一棵树的节点个数，求叶子节点的个数，获取k层节点的个数，树的高度，找到某个节点，检查两棵树是否相同，第二棵树是否是第一棵树的子树，翻转二叉树，判断一棵二叉树是否是平衡二叉树，对称二叉树
带头结点的双向循环链表操作集
04-30
双向循环链表是一种特殊的链表，它的最后一个节点的 next 指针指向第一个节点，第一个节点的 prev 指针指向最后一个节点，因此可以实现循环遍历。带头结点的双向循环链表是在双向循环链表的基础上增加了一个头结点，可以方便地进行插入、删除等操作。以下是带头结点的双向循环链表的常见操作： ```c++ // 双向循环链表节点结构体 template <typename T> struct Node { T data; Node<T>* prev; Node<T>* next; Node() : data(T()), prev(nullptr), next(nullptr) {} Node(T _data, Node<T>* _prev = nullptr, Node<T>* _next = nullptr) : data(_data), prev(_prev), next(_next) {} }; // 带头结点的双向循环链表类 template <typename T> class DoubleLinkedList { public: DoubleLinkedList() : head(new Node<T>()), size(0) { head->prev = head->next = head; } ~DoubleLinkedList() { clear(); delete head; } // 在 index 处插入元素 void insert(int index, const T& value) { if (index < 0 || index > size) { throw std::out_of_range("Index out of range."); } Node<T>* cur = head; for (int i = 0; i < index; ++i) { cur = cur->next; } Node<T>* node = new Node<T>(value, cur, cur->next); cur->next->prev = node; cur->next = node; ++size; } // 删除 index 处的元素 void remove(int index) { if (index < 0 || index >= size) { throw std::out_of_range("Index out of range."); } Node<T>* cur = head->next; for (int i = 0; i < index; ++i) { cur = cur->next; } cur->prev->next = cur->next; cur->next->prev = cur->prev; delete cur; --size; } // 清空链表 void clear() { while (size > 0) { remove(0); } } // 获取第 index 个元素 T& get(int index) const { if (index < 0 || index >= size) { throw std::out_of_range("Index out of range."); } Node<T>* cur = head->next; for (int i = 0; i < index; ++i) { cur = cur->next; } return cur->data; } // 获取链表长度 int getSize() const { return size; } // 判断链表是否为空 bool isEmpty() const { return size == 0; } private: Node<T>* head; // 头结点 int size; // 链表长度 }; ``` 以上是带头结点的双向循环链表的常见操作，可以根据实际需求进行调整和扩展。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值