什么能完美解决单链表的各种限制问题？？？

已于 2022-08-24 15:17:39 修改
阅读量138 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2022-08-20 16:23:39 首次发布
DEXTER
本文链接：https://blog.csdn.net/DEXTERFUTIAN/article/details/126395498
版权

带头双向循环链表

什么是带头双向循环链表？

在这里插入图片描述

有一个哨兵位的头节点做链表的头，数据与数据之间相互链接，使得数据之间的增删查改操作更加方便

带头双向循环链表实现—Leading bidirectional circular linked list

链表的定义

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

我们用next指向链接的下一个节点，用prev指向链接的上一个节点

链表接口定义

// 创建返回链表的头节点
BCL* ListCreate();

// 双向链表销毁
void ListDestory(BCL* phead);

// 双向链表打印
void ListPrint(BCL* phead);

//申请一个节点
BCL* BuyListNode(LTDataType x);

//判断链表是否为空
bool ListEmpty(BCL* phead);

// 双向链表尾插
void ListPushBack(BCL* phead, LTDataType x);

// 双向链表尾删
void ListPopBack(BCL* phead);

// 双向链表头插
void ListPushFront(BCL* phead, LTDataType x);

// 双向链表头删
void ListPopFront(BCL* phead);

// 双向链表查找
BCL* ListFind(BCL* phead, LTDataType x);

// 双向链表在pos的前面进行插入
void ListInsert(BCL* pos, LTDataType x);

// 双向链表删除pos位置的节点
void ListErase(BCL* pos);

链表增加与删除

哨兵节点

我们首先先申请一块空间用来存放哨兵位的头节点，这个哨兵节点不存储数据
在没有存储数据之前，将哨兵节点指向自己这样构成循环

// 创建返回链表的头节点
BCL* ListCreate()
{
	BCL* guard = (BCL*)malloc(sizeof(BCL));
	if (guard == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	guard->next = guard;
	guard->prev = guard;
	return guard;
}

申请新节点

//申请一个节点
BCL* BuyListNode(LTDataType x)
{
	BCL* newnode = (BCL*)malloc(sizeof(BCL));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->data = x;
	return newnode;
}

头插头删

// 双向链表头插
void ListPushFront(BCL* phead, LTDataType x)
{
	assert(phead);
	BCL* newnode = BuyListNode(x);
	BCL* first = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = first;
	first->prev = newnode;
}

// 双向链表头删
void ListPopFront(BCL* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));
	BCL* first = phead->next;
	phead->next = first->next;
	first->next->prev = phead;
	free(first);
	first = NULL;
}

尾插尾删

// 双向链表尾插
void ListPushBack(BCL * phead, LTDataType x)
{
	assert(phead);
	BCL* newnode = BuyListNode(x);
	BCL* Tail = phead->prev;
	Tail->next = newnode;
	newnode->prev = Tail;
	newnode->next = phead;
	phead->prev = newnode;
}

// 双向链表尾删
void ListPopBack(BCL* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));
	BCL* tail = phead->prev;
	BCL* prev = tail->prev;
	prev->next = phead;
	phead->prev = prev;
	free(tail);
	tail = NULL;
}

链表查找

// 双向链表查找
BCL* ListFind(BCL* phead, LTDataType x)
{
	assert(phead);
	BCL* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

链表更改

POS之前插入节点

// 双向链表在pos的前面进行插入
void ListInsert(BCL* pos, LTDataType x)
{
	assert(pos);
	BCL* newnode = BuyListNode(x);
	BCL* cur = pos->prev;
	cur->next = newnode;
	newnode->prev = cur;
	newnode->next = pos;
	pos->prev = newnode;
}

删除POS位置节点

// 双向链表删除pos位置的节点
void ListErase(BCL* pos)
{
	assert(pos);
	BCL* prev = pos->prev;
	prev->next = pos->next;
	pos->next->prev = prev;
	free(pos);
	pos = NULL;
}

头文件代码

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

// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}BCL;

// 创建返回链表的头节点
BCL* ListCreate();

// 双向链表销毁
void ListDestory(BCL* phead);

// 双向链表打印
void ListPrint(BCL* phead);

//申请一个节点
BCL* BuyListNode(LTDataType x);

//判断链表是否为空
bool ListEmpty(BCL* phead);

// 双向链表尾插
void ListPushBack(BCL* phead, LTDataType x);

// 双向链表尾删
void ListPopBack(BCL* phead);

// 双向链表头插
void ListPushFront(BCL* phead, LTDataType x);

// 双向链表头删
void ListPopFront(BCL* phead);

// 双向链表查找
BCL* ListFind(BCL* phead, LTDataType x);

// 双向链表在pos的前面进行插入
void ListInsert(BCL* pos, LTDataType x);

// 双向链表删除pos位置的节点
void ListErase(BCL* pos);

接口实现代码

#include "List.h"
// 创建返回链表的头节点
BCL* ListCreate()
{
	BCL* guard = (BCL*)malloc(sizeof(BCL));
	if (guard == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	guard->next = guard;
	guard->prev = guard;
	return guard;
}

// 双向链表销毁
void ListDestory(BCL* phead)
{
	assert(phead);
	BCL* cur = phead->next;
	while (cur != phead)
	{
		BCL* next = cur->next;
		free(cur);
		cur = NULL;
		cur = next;
	}
	free(phead);
	//phead是形参，形参改变外面的实参无变化，要么使用二级指针要么在外面再置NULL
	//phead=NULL  这样做没有效果
}

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

//申请一个节点
BCL* BuyListNode(LTDataType x)
{
	BCL* newnode = (BCL*)malloc(sizeof(BCL));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->data = x;
	return newnode;
}

//判断链表是否为空
bool ListEmpty(BCL* phead)
{
	assert(phead);
	return phead->next == phead;
}

// 双向链表尾插
void ListPushBack(BCL * phead, LTDataType x)
{
	//第一种方法
	//assert(phead);
	//BCL* newnode = BuyListNode(x);
	//BCL* Tail = phead->prev;
	//Tail->next = newnode;
	//newnode->prev = Tail;
	//newnode->next = phead;
	//phead->prev = newnode;

	//第二种方法
	ListInsert(phead, x);
}

// 双向链表尾删
void ListPopBack(BCL* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));
	//1.
	//BCL* Tail = phead->prev;
	//Tail->prev->next = phead;
	//phead->prev = Tail->prev;
	//free(Tail);
	//Tail = NULL;
	//2.
	//BCL* tail = phead->prev;
	//BCL* prev = tail->prev;
	//prev->next = phead;
	//phead->prev = prev;
	//free(tail);
	//tail = NULL;
	//3.
	ListErase(phead->prev);
}

// 双向链表头插
void ListPushFront(BCL* phead, LTDataType x)
{
	//1.
	//assert(phead);
	//BCL* newnode = BuyListNode(x);
	//BCL* first = phead->next;
	//phead->next = newnode;
	//newnode->prev = phead;
	//newnode->next = first;
	//first->prev = newnode;

	//2.
	ListInsert(phead->next, x);
}

// 双向链表头删
void ListPopFront(BCL* phead)
{
	//1.
	//assert(phead);
	//assert(!ListEmpty(phead));
	//BCL* first = phead->next;
	//phead->next = first->next;
	//first->next->prev = phead;
	//free(first);
	//first = NULL;

	//2.
	ListErase(phead->next);
}

// 双向链表查找
BCL* ListFind(BCL* phead, LTDataType x)
{
	assert(phead);
	BCL* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

// 双向链表在pos的前面进行插入
void ListInsert(BCL* pos, LTDataType x)
{
	assert(pos);
	BCL* newnode = BuyListNode(x);
	BCL* cur = pos->prev;
	cur->next = newnode;
	newnode->prev = cur;
	newnode->next = pos;
	pos->prev = newnode;
}

// 双向链表删除pos位置的节点
void ListErase(BCL* pos)
{
	assert(pos);
	BCL* prev = pos->prev;
	prev->next = pos->next;
	pos->next->prev = prev;
	free(pos);
	pos = NULL;
}

结果演示

void TestList()
{
	BCL* phead = ListCreate();
	ListPushBack(phead, 1);		//尾插
	ListPushBack(phead, 2);		//尾插
	ListPushBack(phead, 3);		//尾插
	ListPushBack(phead, 4);		//尾插
	ListPrint(phead);			//打印
	ListPopBack(phead);			//尾删
	ListPrint(phead);			//打印
	ListPushFront(phead, 10);   //头插
	ListPrint(phead);			//打印
	ListPopFront(phead);		//头删
	ListPrint(phead);			//打印
}
int main()
{
	TestList();
	return 0;
}

在这里插入图片描述

第二个

void TestList()
{
	BCL* phead = ListCreate();
	ListPushBack(phead, 1);			//尾插
	ListPushBack(phead, 2);			//尾插
	ListPushBack(phead, 3);			//尾插
	ListPushBack(phead, 4);			//尾插
	ListPrint(phead);
	BCL* ret = ListFind(phead, 2);  //找数据2
	printf("%d\n", ret->data);
	ListInsert(phead->next, 10);    //pos之前插入 (相当与头插)
	ListPrint(phead);
	ListInsert(phead, 20);			//pos之前插入 (相当于尾插)
	ListPrint(phead);
	ListErase(phead->next);			// 删除pos位置
	ListPrint(phead);
}
int main()
{
	TestList();
	return 0;
}

在这里插入图片描述

如果发现错误欢迎大佬们指出😸😸

侠客cheems
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
用单链表解决约瑟夫问题
08-04
构建结构体，初始化循环单链表，单链表插入操作（尾插法），遍历，出局函数。
python购物车代码_Python代码之购物车
weixin_29146477的博客
02-11 216
# -*- coding:utf-8 -*-#Author:Mr Gan不足之处：输入商品编号时必须是整型，其他类型会报错import sysbalance = int(input("your money:"))shopping_bag = [] #创建购物包shopping_list = [["iphone",5800],["watch",2600],["book",56],["computer...
用循环单链表解决josephus问题的算法.rar_循环单链表
09-23
此问题可以通过数据结构和算法来解决，循环单链表是其中一种高效的方法。 循环单链表是一种线性数据结构，其特点是每个节点包含数据和指向下一个节点的指针。在循环单链表中，最后一个节点的指针会指向链表的第一个...
用单链表解决约瑟夫问题 C语言实现
06-20
用单链表解决约瑟夫问题 C语言实现 用单链表解决约瑟夫问题 C语言实现
python环形单链表的约瑟夫问题详解
12-24
这个问题就是著名的约瑟夫问题。 代码： 首先给出环形单链表的数据结构： class Node(object): def __init__(self, value, next=0): self.value = value self.next = next # 指针 class RingLinkedList(object...
用C语言实现单链表的各种操作(二)
01-20
用C语言实现单链表的各种操作(一)>主要是单链表的一些最基本的操作，下面，主要是一些其他的典型的算法和测试程序。 代码如下:/* 对单链表进行排序处理*/struct LNode *sort(struct LNode *head){ LinkList *p; ...
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1063
可以参考以下视频。
数据结构day3
qq_55245263的博客
07-18 283
顺序表实现学生管理系统
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 245
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
数据结构初阶·排序算法(内排序)
2301_79697943的博客
07-18 917
目前常见的排序算法有9种，冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，计数排序，基数排序，桶排序。实际生活中排序的应用也是有限的，今天我们介绍其中7个，基数排序和桶排序不介绍。介绍常用的即可。顺带一嘴，本文里面所有的排序都是内排序，也就是在内存里面进行排序的，还有一种排序叫做外排序，即是在磁盘里面进行排序的，这种排序具有记忆性，外排序用到的就是归并排序，因为归并排序有一个特点就是空间复杂度为O(N)。好了正文开始。
数据结构第32节 无锁编程
hummhumm的专栏
07-17 875
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
数据结构第35节 性能优化 算法的选择
hummhumm的专栏
07-18 730
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1103
如有错误，欢迎指出~
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1099
24暑假刷题day15打卡 二叉树进阶
数据结构之细说链表
m0_73634434的博客
07-17 1078
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
数据结构 day2
没有百宝袋的哆啦A梦的博客
07-17 1174
由相同数据类型或不同数据类型构成的集合，但是，该集合中的成员共享同一块内存空间union 结构体名称成员类型1 成员变量1;成员类型2 成员变量2；。。。成员类型n 成员变量n;当程序员写程序时，可能会因为数据类型的问题，在定义变量时，导致该程序比较晦涩难懂，例如：unsigned long int ,struct Stu为了提高代码的简洁性，以及为了更加方便理解使得代码更加优雅，我们可以将这些类型重新起一个简洁好记的名字。引入了关键字 typedef。
创建空数据结构：列表、元组、字典和集合
2202_75569688的博客
07-17 185
在 Python 编程中，数据结构是存储和管理数据的基本单元。常用的数据结构包括列表、元组、字典和集合。在实际编程中，时常需要初始化这些数据结构为空。本文将详细介绍如何创建空列表、空元组、空字典和空集合。
02 数据结构 ——链表（静态/循环/双向/LINUX内核链表）
weixin_65029285的博客
07-17 424
Linux内核链表是一种通用的双向循环链表，面对通用的问题，Linux内核链表的节点干脆不存储任何数据域，只有指针域，节点只负责串联起每个节点，不负责存储数据。目的：根据结构体中某个成员的地址，能够计算出所在结构体的首地址，从而用户在设计Linux内核链表的节点时，不需要一定放在在数据的首位成员，增加可用性。在双向链表的基础上，让最后一个节点的next指向头节点，让头节点的prev指向最后一个节点，构成了双向循环链表。静态链表的节点存储在一段连续内存中，通过节点中称为游标的一个正整数来访问后继节点。
单链表＜数据结构 C版＞
最新发布
hukang的博客
07-19 1646
单链表是一种在物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接顺序实现的。
逆序创建单链表有什么好处？
04-03
逆序创建单链表的好处是可以避免在插入新节点时需要遍历整个链表，从而提高插入节点的效率。当需要在单链表的头部插入节点时，如果采用正序创建单链表的方式，每次插入节点都需要将原先的头节点的指针指向新节点，而...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

侠客cheems

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值