【每天学习亿点点系列】——重温双向带头循环链表

最新推荐文章于 2025-02-28 00:15:00 发布
最新推荐文章于 2025-02-28 00:15:00 发布
阅读量925 收藏 1
点赞数 10
分类专栏： 每天学习亿点点系列 数据结构 文章标签： 链表 指针 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/IamGreeHand/article/details/119765851
版权
本文详细介绍了如何实现双向带头循环链表，包括初始化、创建节点、插入、删除、查找、打印等基本操作。特别强调了使用哨兵节点解决插入问题，以及在操作链表时注意的细节，如赋值顺序、删除节点时的内存释放等。此外，还提供了完整的头文件和测试文件，便于读者理解和实践。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

💥【每天学习亿点点系列】——重温双向带头循环链表

头文件以及测试文件的实现

List.h

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
#include<stdbool.h>

typedef int ListDataType;
typedef struct List
{
	struct List* pre;
	struct List* next;
	ListDataType x;
}List;

void Listinit(List** pphead);//为了让双向链表自己指向自己
void ListBackPush(List** pphead, ListDataType x);
void ListFrontPush(List** pphead, ListDataType x);
void ListPrint(List* pphead);
void ListBackPop(List** pphead);
void ListFrontPop(List** pphead);
List* ListFind(List* pphead,ListDataType x);
void ListPushAfter(List** pphead, ListDataType x, List* pos);
void ListPushBefore(List** pphead, ListDataType x, List* pos);
void ListPopAfter(List** pphead, List* pos);
void ListPopBefore(List** pphead, List* pos);
void ListPop(List** pphead, List* pos);
int ListSize(List* pphead);
bool ListEmpty(List* pphead);
void ListDestory(List** pphead);

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"
void test()
{
	List* phead;
	Listinit(&phead);
	ListBackPush(&phead, 1);
	ListBackPush(&phead, 2);
	ListFrontPush(&phead, 3);
	ListBackPop(&phead);
	ListFrontPop(&phead);
	List* pos=ListFind(phead,1);
	ListPushAfter(&phead, 2, pos); //复用，相当于尾插
	ListPushBefore(&phead, 3, pos);//复用，相当于头插
	ListPopAfter(&phead, pos);//复用，相当于尾删
	//ListPopBefore(&phead, pos);//复用，相当于头删
	/*ListBackPop(&phead);*/
	/*printf("%d\n", ListEmpty(phead));*/
	/*ListPopBefore(&phead, pos);*/ //检验156行的断言
	ListPop(&phead, pos);
	ListPrint(phead);
}
int main()
{
	test();
	return 0;
}

各个接口的实现

1.初始化

void Listinit(List** pphead)
{
	assert(pphead);
	assert(*pphead);
	List* head = (List*)malloc(sizeof(List));
	if (head == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	else
	{
		*pphead = head;
	}
	(*pphead)->next = *pphead;
	(*pphead)->pre = *pphead;
}

2.创建节点

//创建节点
List* BuyNode(ListDataType x)
{
	List* newnode = (List*)malloc(sizeof(List));
	newnode->x = x;
	return newnode;
}

3.尾插

//尾插
void ListBackPush(List** pphead, ListDataType x)    //这边不能用二级指针，因为你else里面那种情况会改变头节点，而你不希望它改变，但是你if里面的情况希望改变，故用这种写法写不出来
{
	assert(pphead); 
	//由于初始化的原因，此时双向链表里面已经有一个节点了, 迫于没有办法，用带哨兵位的写法,用哨兵位可以解决上面的问题，因为这时我不需要分情况来说
	List* newnode = BuyNode(x);   
	newnode->pre = (*pphead)->pre;
	(*pphead)->pre->next = newnode;
	newnode->next = (*pphead);
	(*pphead)->pre = newnode;
}

4.头插

//头插
void ListFrontPush(List** pphead, ListDataType x)
{
	assert(pphead);
	List* newnode = BuyNode(x);
	newnode->next = (*pphead)->next;
	(*pphead)->next->pre = newnode;
	(*pphead)->next = newnode;
	newnode->pre = (*pphead);
}

5.尾删

//尾删
void ListBackPop(List** pphead)
{
	assert(pphead);
	assert(*pphead);
	(*pphead)->pre->pre->next = (*pphead);  //这儿要注意写的时候的先后顺序
	(*pphead)->pre = (*pphead)->pre->pre;
}

6.头删

//头删
void ListFrontPop(List** pphead)
{
	assert(pphead);
	assert(*pphead);
	(*pphead)->next->next->pre = (*pphead);   //同样也要注意顺序
	(*pphead)->next = (*pphead)->next->next;
}

7.打印

//打印
void ListPrint(List* pphead)
{
	assert(pphead);
	List* cur = pphead->next;
	while (cur != pphead)
	{
		printf("%d ", cur->x);
		cur = cur->next;
	}
}

8.查找

List* ListFind(List* pphead,ListDataType x)
{
	assert(pphead);
	List* cur = pphead->next;
	while (cur != pphead)
	{
		if (cur->x == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
}

9在任意位置之后插入

//在任意位置之后插入
void ListPushAfter(List** pphead, ListDataType x, List* pos)
{
	assert(pphead);
	assert(*pphead);
	List* newnode = BuyNode(x);
	newnode->next = pos->next;
	pos->next->pre = newnode;
	pos->next = newnode;
	newnode->pre = pos;
}

10.在任意位置之前插入

//在任意位置之前插入
void ListPushBefore(List** pphead, ListDataType x, List* pos)
{
	assert(pphead);
	assert(*pphead);
	List* newnode = BuyNode(x);
	pos->pre->next = newnode;
	newnode->pre = pos->pre;
	newnode->next = pos;
	pos->pre = newnode;
}

11.记录节点个数


//记录节点个数
int ListSize(List* pphead)
{
	List* cur = pphead->next;
	int n = 0;
	while (cur != pphead)
	{
		n++;
		cur = cur->next;
	}
	return n;
}

12.在任意位置之后删除

//在任意位置之后删除
void ListPopAfter(List** pphead, List* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(ListSize(*pphead) != 1);
	pos->next->next->pre = pos;         //同上注意顺序
	/*pos->next = pos->next->next;*/
	List*temp = pos->next->next;      //注意删除时这儿的写法，要先创建一个临时变量保存一下，因为你free掉了pos->next,如果你下面再将pos->next->next赋值给pos->next的话
	                                  //肯定时会出问题的。
	free(pos->next);
	pos->next = temp;
}

13.在任意位置之前删除

//在任意位置之前删除
void ListPopBefore(List** pphead, List* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(ListSize(*pphead) != 1);
	pos->pre->pre->next = pos;          //同上注意顺序
	/*pos->pre = pos->pre->pre;*/
	List*temp = pos->pre->pre;          //同上面注意点一样
	free(pos->pre);
	pos->pre = temp;
}

14.删除当前位置

//删除当前位置
void ListPop(List** pphead, List* pos)
{
	assert(pphead);
	assert(*pphead);
	pos->pre->next = pos->next;
	pos->next->pre = pos->pre;
	free(pos);
	pos = NULL;
}

15.判空

//判空
bool ListEmpty(List* pphead)
{
	/*return pphead == NULL;*/  //因为是有哨兵位的，所以不能这么判断
	return pphead->next == pphead;
}

16.销毁

//销毁
void ListDestory(List** pphead)
{
	assert(pphead);
	//free(*pphead);  //链表不想顺序表那样，在物理上是连续的，所以不能这样释放，那是顺序表的释放方法
	//*pphead = NULL;
	List* cur = (*pphead)->next;
	while (cur != *pphead)
	{
		List* next = cur->next;
		free(cur);
		cur = next;
	}
	free(*pphead);
}

注意点

1.双向链表要初始化这个接口的，不同与单链表

初始化为了让双向链表自己指向自己，形成环形

2.带个哨兵位，解决插入的问题

//尾插
void ListBackPush(List** pphead, ListDataType x)    //这边不能用二级指针，因为你else里面那种情况会改变头节点，而你不希望它改变，但是你if里面的情况希望改变，故用这种写法写不出来
{
	assert(pphead); 
	//由于初始化的原因，此时双向链表里面已经有一个节点了, 迫于没有办法，用带哨兵位的写法,用哨兵位可以解决上面的问题，因为这时我不需要分情况来说
	List* newnode = BuyNode(x);   
	newnode->pre = (*pphead)->pre;
	(*pphead)->pre->next = newnode;
	newnode->next = (*pphead);
	(*pphead)->pre = newnode;
}

在这里，你刚刚初始话的那个节点就当做哨兵位，之后删除什么的都不需要包括它，它只是为了方便我们插入而已，同时也解决了注释中所说的问题。

3.注意赋值时的先后顺序

在这里插入图片描述
在这里插入图片描述

像这些因为交换顺序会影响赋值的，都要十分注意。

4.删除时要把节点free掉，同时要注意写法

在这里插入图片描述

这儿要free掉你要删除的节点，如果不删除，只改变链接的关系，那只是表面删除，并没有彻底的把那个节点弄掉，某种意义上说也时可以的，但是不好，而且在free掉后给指针赋值时也要注意，如果有你free掉的成分，那么就要提前将它保存到一个变量中，就像上图一样，下面两个接口也是要注意同样的情况。
在这里插入图片描述

5.判空与以往不同，因为有哨兵位

在这里插入图片描述

6.不要像释放顺序表一样释放，因为空间物理上不连续

在这里插入图片描述

Python多重继承中的钻石继承
NoerrorCode的博客
09-25 192
在Python中，多重继承是一种强大的特性，允许一个类从多个父类中继承属性和方法。然而，当多个父类存在同一个共同的父类时，就会出现钻石继承（diamond inheritance）问题，也称为菱形继承。这种情况下，子类继承了两个相同的父类，可能会导致方法冲突和意想不到的行为。MRO算法定义了多重继承中方法搜索的顺序，确保方法按照预期的顺序被调用。在钻石继承结构中，搜索顺序是从子类开始向上搜索父类，再返回到子类的另一个父类，最后到达最顶层的父类。通过了解方法解析顺序，我们可以明确地选择要调用的父类方法。
python 钻石继承_Python类继承及super()函数
weixin_42138545的博客
03-01 374
文章目录Python中单类继承普通类方法继承初始化函数继承Python中多类继承Python中单类继承Python是一门面向对象的编程语言，支持类继承。新的类称为子类(Subclass)，被继承的类称为父类、基类或者超类。子类继承父类后，就拥有父类的所有特性。类继承的简单例子：普通类方法继承class Fruit():def color(self):print("colorful")class A...
python棱形继承（钻石继承）
weixin_33709609的博客
01-04 390
class A(object): def func(self): print('A') class B(A): def func(self): super().func() print('B') class C(A): def func(self): super().func() print('C') class D(...
深入了解 Python 中的 MRO（方法解析顺序）
最新发布
XMYX-0
02-28 1016
在 Python 中，MRO（方法解析顺序）是多重继承的核心机制。它决定了当一个类继承多个父类时，Python 如何解析并决定调用父类的方法。通过 MRO，Python 确保了在多重继承情况下方法不会发生冲突，且每个父类的方法都能按照预定的顺序正确调用。Python 使用一种称为C3 线性化的算法来计算 MRO，这一算法确保了在多继承中父类方法调用的顺序是明确且无歧义的。对于开发者而言，理解 MRO 有助于写出更清晰、易于维护的面向对象代码。
python钻石继承
杨佳佳的博客
05-20 4760
如果子类继承自两个单独的超类，而那两个超类又继承自同一个公共基类，那么就构成了钻石继承体系。这种继承体系很像竖立的菱形，也称作菱形继承。class Base: def __init__(self, value): self.value = value class One(Base): def __init__(self, value): Base...
python----钻石继承
writ的博客
06-29 641
当调用d.method()时，会按照方法解析顺序（Method Resolution Order, MRO）依次调用D、B、C和A的method方法。因此，在使用钻石继承时，需要注意继承关系和方法调用的顺序，以避免产生意外的结果。钻石继承是指在Python中，存在一种继承关系，其中一个子类继承自两个不同的父类，而这两个父类又共同继承自同一个父类。在这个示例中，类A是顶级父类，类B和类C都继承自A。最后，类D继承自B和C，形成了钻石继承的结构。
Python super()函数使用及多重继承
09-16
### Python `super()` 函数与多重继承详解 #### 一、`super()` 函数简介 在面向对象编程中，继承是一种常见的设计模式，它允许一个类（子类）继承另一个类（父类）的属性和方法。在 Python 中，`super()` 函数是一...
python继承及super()函数
hinewcc的博客
08-19 893
python继承及super() 函数介绍
解决python super()调用多重继承函数的问题
09-19
### 解决Python `super()` 调用多重继承函数的问题 在Python中，`super()` 函数被广泛用于实现多重继承。它可以帮助我们避免代码重复，并使得类的继承结构更加清晰。然而，在处理复杂的多重继承关系时，如何正确地...
Python多继承以及MRO顺序的使用
09-18
当我们通过`super()`函数调用方法时，Python会按照MRO顺序查找并执行方法。 以下是一些关于Python多继承和MRO顺序的关键点： 1. **单独调用父类的方法**： 在多继承中，可以通过直接指定父类名称和方法名来调用...
python 的钻石继承问题
Jibert的博客
04-18 598
如果子类继承自两个单独的超类，而那两个超类又继承自同一个公共基类，那么就构成了钻石继承体系。这种继承体系很像竖立的菱形，也称作菱形继承。 class Base: def __init__(self, value): print("This is Base __init__") self.value = value class One(Base): ...
super()函数
weixin_38170829的博客
08-30 456
1.简单的使用 在类的继承中，如果重定义某个方法，该方法会覆盖父类的同名方法，但有时，我们希望能同时实现父类的功能，这时，我们就需要调用父类的方法了，可通过使用super来实现，比如： 在上面，Animal 是父类，Dog 是子类，我们在 Dog 类重定义了greet方法，为了能同时实现父类的功能，我们又调用了父类的方法，看下面的使用： super的一个最常见用法...
python 钻石继承_python3--object类，继承与派生，super方法，钻石继承问题
weixin_28875235的博客
03-01 344
python3--object类，继承与派生，super方法，钻石继承问题发布时间：2018-04-13 20:38:05编辑：Run阅读(1914)昨天内容复习组合：什么有什么的关系(例:老师有生日)classBirthday:def__init__(self,year,month,day):self.year=yearself.month=monthself.day=da...
super函数
qq_42413204的博客
06-08 1033
super(type, obj) #返回绑定超类的实例(要求obj必须为type类型的实例)super() #返回绑定的超类的实例，等同于(class,实例方法的第一个参数),此方法需要用在方法内部。作用:返回绑定超类的实例，用超类的实例来调用其自身方法class A(object): def hello(self): print("A类的hello(self)") c...
python 多继承与super使用详解_Python高级编程之继承问题详解(super与mro)
weixin_39855869的博客
02-03 305
本文实例讲述了Python高级编程之继承问题。分享给大家供大家参考，具体如下：多继承问题1.单独调用父类：一个子类同时继承自多个父类，又称菱形继承、钻石继承。使用父类名.init(self)方式调用父类时：例：class Parent(object):def __init__(self, name):self.name = nameprint('parent的init结束被调用')class So...
Python面向对象中super用法与MRO机制
chb4715的博客
12-03 251
1. 引言 　　最近在研究django rest_framework的源码，老是遇到super，搞得一团蒙，多番查看各路大神博客，总算明白了一点，今天做一点总结。 2. 为什么要用super 1)让代码维护更加简单 　　Python是一门面向对象的语言，定义类时经常用到继承的概念，既然用到继承就少不得要在子类中引用父类的属性，我们可以通过“父类名.属性名”的方式来调用，代码如下： cl...
super() 函数
qq_43636375的博客
04-10 582
描述 super() 函数是用于调用父类(超类)的一个方法。 super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。 MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。 语法 以下是 super() 方法的语法: super(type[, object-or-type]...
python 钻石继承_【Python求助】关于带参数的钻石继承问题
weixin_31209173的博客
02-03 209
[Python] 纯文本查看 复制代码class A:def __init__(self, a, *args, **kwargs):print('进入A')self.a = aprint("A message:", self.a)print('离开A')class B(A):def __init__(self, b, *args, **kwargs):print('进入B')super(B, se...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一个数学不怎么好的程序员

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

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

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

打赏作者

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

抵扣说明：

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

余额充值