当前位置： 首页 > article >正文

拿捏循环链表

article 2024/11/20 1:37:34

目录：

一：单链表（不带头单向不循环）与循环链表（带头双向循环）区别

二：循环链表初始化

三：循环链表头插

四：循环链表尾插

五：循环链表头删

六：循环链表尾删

七：循环链表查找

八：循环链表指定pos  位置的删除

九：循环链表指定pos  位置之前的插入

十：循环链表销毁

十一：结语

1：单链表（不带头单向不循环）与循环链表（带头双向循环）区别
1)结构上

循环链表多了给 前驱指针 pre 

2)链表增删查改

有了pre这个指针，效率大大提升

2：循环链表初始化

讲到初始化，这里主要就是对哨兵位 （暂时称为：phead）进行设置

注意：哨兵位只是占一个位置，并不存储任何有效的数据

循环链表初始状态是空的：phead 自己成环

 

 对应代码：

phead -> next = phead ;

phead -> pre  = phead ;

那么问题就来了，在设计这个初始化函数的时候用一级指针还是二级指针

想必，前期看过我的单链表的博客，自然会说二级指针呀：

 因为是对phead 这个指针进行改变所以是传二级指针。没毛病！不知道大家在做OJ题的时候，我们也涉及到对一级指针的改变，但是我们也可以返回这个一级指针，即可实现

ListNode* ListNodeInit()
{
	/*
	哨兵位：val 没有实际意义（自行赋值）
	初始化的目的就是对哨兵位进行设置
	因为整个接口都是用一级指针，若是初始化用二级指针有点不顺眼
	此函数返回哨兵位地址即可实现对哨兵位的初始化
	*/
	ListNode* phead = NULL;
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	phead = newnode;
	phead->val = -1;
	phead->pre = phead->next = phead;//够成环
	return phead;
}
3：循环链表头插

头插：即在哨兵位的后面进行头插（若是链表为空，此时的头插也即是尾插）

头插分析：显然我们只需改变指针走向即可

注意指针先后问题

 各位老铁康康这样的代码是否之正确：

phead-> next = newnode;

newnode-> next = phead-> next;

newnode-> pre = phead;

newnode->next-> pre = newnode;

 

此代码结合画图，来看， 显然这样是不对的，因为newnode-> next = phead-> next;这句代码让newnode 这个节点自己成环了，所以又怎么可能头插进去呢？

实质性原因是：当我们头插进来newnode 时，应该先执行

newnode-> next = phead->next;   //注意指针先后问题

phead->next->pre = newnode; //让原来头结点的 pre 指向newndoe

newnode-> pre = phead;

phead-> next = newnode;

	ListNode* newnode = BuyNode(x);
	newnode->next = phead->next;
	newnode->pre = phead;
	phead->next->pre = newnode;//原来第一个节点pre与新的头结点连接
	phead->next = newnode;//新的头结点

对于以上问题还可以这样解决：定义一个 next指针来保留一下原来的头结点

4：循环链表尾插

尾差之前我们需要先思考一个问题：对于单链表（不循环，不带头，单向）而言，每次尾插之前都需要遍历链表，来找尾结点

但是对于循环链表而言我们就不需要：找尾结点直接一步到位  phead-> pre

真的是没有对比就没有伤害，所以在这块，咱循环链表还是比较好搞滴

尾插分析：

 这里只需改变指针走向即可

代码：

void ListNodePushBack(ListNode* phead,DataType x)
{
	assert(phead);
	/*
	1:找尾结点 phead->pre
	2:指针连接 
	*/
	ListNode* newnode = BuyNode(x);
	newnode->next = phead;
	newnode->pre = phead->pre;
	phead->pre->next = newnode;//原来尾结点与newnode进行连接
	phead->pre = newnode;//新的尾结点
	
}
5：循环链表头删

依然如此，按照“国际惯例”：找头结点  phead -> next 

删除之前先保留一下 第二个节点  

当把链表所以节点删除后（除哨兵位），会自动保存一个循环链表

 代码见下：

void ListNodePopFront(ListNode* phead)
{
	assert(phead->next != phead);//不相等说明不为空
	ListNode* newFirst = phead->next->next;
	newFirst->pre = phead;

	phead->next = newFirst;//成为新的头结点
	//以下写法也对，但可读性差
	phead->next = phead->next->next;
	phead->next->pre = phead;


}
6：循环链表尾删

 既然谈到尾删，咱这里不得不提一嘴，单链表的尾删

单链表尾删逻辑：

1：链表不为空

2：只有一个节点：传二级指针

3：多个节点：传一级指针

4：找尾结点： 条件 tail -> next != NULL;

 咱就是说，是不是事很多。

相比较之下，循环链表就比较友好：找啥尾结点，直接一步到位  phead-> pre

直接改变指针走向即可。

老问题：保留一下尾结点的前一个节点 tailPre

void ListNodePopBack(ListNode* phead)
{
	assert(phead);
	/*
	空链表： 
	1:找尾结点 phead->pre
	2:成环：  改变新的尾结点与phead 直接的链接
	*/
	assert(phead->next != phead);//不相等说明链表不为空，为空不能删除

	ListNode* tail = phead->pre;
	ListNode* tailPre = tail->pre;
	phead->pre = tailPre;//新的尾结点
    tailPre->next = phead;
    free(tail);
}
7：循环链表查找

此函数可以实现2个功能：一个是查找；另一个是修改

逻辑：按值查找，若是存在，直接返回当前节点，否则返回 NULL

注意是从 第一个节点开始 而不是从哨兵位 开始

ListNode* Find(ListNode* phead, DataType x) //指定数据查找
{
	/*
	从第一个节点开始查找： phead->next
	依次遍历，若是存在返回节点
	否则返回NULL
	*/
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead )  //phead 是哨兵位
	{
		if (x == cur->val)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;//没有找到
}
8：循环链表指定pos  位置的删除

这个接口的逻辑其实说白了与尾删没啥不同

注意：pos 这个节点是查找函数返回的

void ListNodeErase(ListNode* pos)//指定位置删除  pos是查找函数返回的
{
	assert(pos);
	ListNode* posPre = pos->pre;
	ListNode* posNext = pos->next;
	posPre->next = posNext;
	posNext->pre = posPre;
	free(pos);
}
9：循环链表指定pos  位置之前的插入

void ListNodeInsert(ListNode* pos, DataType x)//指定位置之前插入
{
	/*
	1:找到pos 前一个节点  pos->pre
	2:注意避免节点找不到
	3:改变指针连接： posPre,newnode,pos
	*/
	assert(pos);//为空直接不玩了
	ListNode* newnode = BuyNode(x);
	ListNode* posPre = pos->pre;
	posPre->next = newnode;
	newnode->pre = posPre;
	newnode->next = pos;
	pos->pre = newnode;

}
10：循环链表销毁

这里的销毁就是一个节点一个节点进行删除

注意：包括哨兵位在内

void ListNodeDestroy(ListNode* phead)
{
	/*
	注意哨兵位也需要删除
	一个节点一个节点删除
	*/
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}

 各位老铁们，别走开，接下来的问题你值得一看，或许哪天自己面试会遇到类似问题呢？

 前段时间看到过样一个问题：

有个求职者去面试：在他的简历上写着自己是比较熟练数据结构这个模块的。

面试官问了这样一个问题：你能否在10分钟之内，搞一个链表出来？

听到这，求职者心里多多少少是有点担忧“搞，是没有问题，但是这个时间能否在宽裕点……”

进过这种协商，时间定在15分钟

对于这个问题的答卷：很显然，这个求职者没有拿到100分

屏幕前的各位铁子们，假设你是那个求职者，你又会如何回答好这份答卷？

是的，要是我，我一定会用循环链表来搞呀（因为面试官有没有指定具体是8中链表的哪一种）

你仔细想想：循环链表效率多高呀

对于一个链表的基本操作无非不就是：

头删头插

尾删，尾插

任意位置的插入和删除

不知道你是否考虑过这样问题：

循环链表的尾插，头插其实就是任意位置插入的一个特例

尾删，头删其实就是任意位置的删除的一个特例

 完整代码如下：
DList.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"
void ListNodePrint(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	printf("guard<==>");
	while (cur != phead)
	{
		printf("%d<==>", cur->val);
		cur = cur->next;
	}
	printf("\n");
}
ListNode* ListNodeInit()
{
	/*
	哨兵位：val 没有实际意义（自行赋值）
	初始化的目的就是对哨兵位进行设置
	因为整个接口都是用一级指针，若是初始化用二级指针有点不顺眼
	此函数返回哨兵位地址即可实现对哨兵位的初始化
	*/
	ListNode* phead = NULL;
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	phead = newnode;
	phead->val = -1;
	phead->pre = phead->next = phead;//够成环
	return phead;
}

ListNode* BuyNode(DataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->val = x;
	newnode->next = NULL;
	newnode->pre = NULL;
	return newnode;
}
void ListNodePushBack(ListNode* phead,DataType x)
{
	assert(phead);
	/*
	1:找尾结点 phead->pre
	2:指针连接 
	*/
	//ListNode* newnode = BuyNode(x);
	//newnode->next = phead;
	//newnode->pre = phead->pre;
	//phead->pre->next = newnode;//原来尾结点与newnode进行连接
	//phead->pre = newnode;//新的尾结点
	ListNodeInsert(phead, x);//注意ListNodeInsert  这个函数功能是在pos 之前插入，所以要想实现尾插，需要传phead ，而不是phead->pre 

}
void ListNodePushFront(ListNode* phead, DataType x)
{
	/*
	注意phead不是头结点（第一个节点），phead 只是一个哨兵位，只占位置
	第一个节点：phead->next
	考虑指针先后问题，避免找不到第一个节点（链表不为空）
	*/
	assert(phead);
	//ListNode* newnode = BuyNode(x);
	//newnode->next = phead->next;
	//newnode->pre = phead;

	//phead->next = newnode;//新的头结点
	以上代码不对
	//ListNode* newnode = BuyNode(x);
	//newnode->next = phead->next;
	//newnode->pre = phead;
	//phead->next->pre = newnode;//原来第一个节点pre与新的头结点连接
	//phead->next = newnode;//新的头结点
	ListNodeInsert(phead->next, x);

}

void ListNodePopBack(ListNode* phead)
{
	assert(phead);
	/*
	空链表： 
	1:找尾结点 phead->pre
	2:成环：  改变新的尾结点与phead 直接的链接
	*/
	assert(phead->next != phead);//不相等说明链表不为空，为空不能删除
	ListNodeErase(phead->pre);

	//ListNode* tail = phead->pre;
	//ListNode* tailPre = tail->pre;
	//phead->pre = tailPre;//新的尾结点
 //   tailPre->next = phead;
	//free(tail);
}
void ListNodePopFront(ListNode* phead)
{
	assert(phead->next != phead);//不相等说明不为空
	ListNodeErase(phead->next);
	//ListNode* newFirst = phead->next->next;
	//newFirst->pre = phead;

	//phead->next = newFirst;//成为新的头结点
	以下写法也对，但可读性差
	//phead->next = phead->next->next;
	//phead->next->pre = phead;


}
ListNode* Find(ListNode* phead, DataType x) //指定数据查找
{
	/*
	从第一个节点开始查找： phead->next
	依次遍历，若是存在返回节点
	否则返回NULL
	*/
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead )  //phead 是哨兵位
	{
		if (x == cur->val)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;//没有找到
}

void ListNodeInsert(ListNode* pos, DataType x)//指定位置之前插入
{
	/*
	1:找到pos 前一个节点  pos->pre
	2:注意避免节点找不到
	3:改变指针连接： posPre,newnode,pos
	*/
	assert(pos);//为空直接不玩了
	ListNode* newnode = BuyNode(x);
	ListNode* posPre = pos->pre;
	posPre->next = newnode;
	newnode->pre = posPre;
	newnode->next = pos;
	pos->pre = newnode;

}

void ListNodeErase(ListNode* pos)//指定位置删除  pos是查找函数返回的
{
	assert(pos);
	ListNode* posPre = pos->pre;
	ListNode* posNext = pos->next;
	posPre->next = posNext;
	posNext->pre = posPre;
	free(pos);
}
void ListNodeDestroy(ListNode* phead)
{
	/*
	注意哨兵位也需要删除
	一个节点一个节点删除
	*/
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}
DList.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int DataType;
typedef struct DListNode 
{
	DataType val;
	struct DListNode* next;
	struct DListNode* pre;//前驱指针

}ListNode;
void  ListNodePrint(ListNode*phead);
ListNode* ListNodeInit();

void ListNodePushBack(ListNode* phead,DataType x);
void ListNodePushFront(ListNode* phead, DataType x);

void ListNodePopBack(ListNode* phead);
void ListNodePopFront(ListNode* phead);

ListNode* Find(ListNode* phead,DataType x); //指定数据查找（此函数可以实现2个功能：查找 + 修改）

void ListNodeInsert(ListNode* pos, DataType x);//指定位置之前插入,pos是查找函数返回的

void ListNodeErase(ListNode* pos);//指定位置删除

void ListNodeDestroy(ListNode* phead);
/*
面试题目： 10分钟之内写一个链表
注意：头删，尾删 都只是 ListNodeErase 这个函数一个特例
头插，尾插，同理，是ListNodeInsert 一个特例
所以 可以借用
*/
test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"

void TestPush()
{
	ListNode* plist = ListNodeInit();
	
	//ListNodeInit(&plist);
	//ListNodePushBack(plist, 1);
	//ListNodePushBack(plist, 2);
	//ListNodePushBack(plist, 3);
	ListNodePushFront(plist, 1);
	ListNodePushFront(plist, 2);
	ListNodePushFront(plist, 3);
	ListNodePushFront(plist, 4);
	ListNodePushFront(plist, 5);
	ListNodePushFront(plist, 6);
	ListNodePushFront(plist, 7);
	ListNodePrint(plist);


	ListNodePushBack(plist, 0);
	ListNodePrint(plist);
	ListNodeDestroy(plist);


}
void TestPop()
{
	//ListNode* plist = (ListNode*)malloc(sizeof(ListNode));
	//if (plist == NULL)
	//	return;
	//plist->val = -1;
	//plist->next = plist;
	//plist->pre = plist;
	//等价于以下代码
	ListNode* plist = ListNodeInit();

	ListNodePushBack(plist, 1);
	ListNodePushBack(plist, 2);
	ListNodePushBack(plist, 3);
	ListNodePrint(plist);

	//ListNodePopFront(plist);
	//ListNodePrint(plist);

	//ListNodePopFront(plist);
	//ListNodePrint(plist);

	//ListNodePopFront(plist);
	//ListNodePrint(plist);

	ListNodePopBack(plist);
	ListNodePrint(plist);

	ListNodePopBack(plist);
	ListNodePrint(plist);

	ListNodePopBack(plist);
	ListNodePrint(plist);
	ListNodeDestroy(plist);

}
void Test()
{
	ListNode* plist = ListNodeInit();

	ListNodePushBack(plist, 1);
	ListNodePushBack(plist, 2);
	ListNodePushBack(plist, 3);
	ListNode* pos = Find(plist, 3);
	if (pos != NULL)
	{
		ListNodeInsert(pos, 10);
		ListNodePrint(plist);
	}
	else
	{
		printf("操作失败\n");
	}
	ListNodeDestroy(plist);

}

void Test1()
{
	ListNode* plist = ListNodeInit();

	ListNodePushBack(plist, 1);
	ListNodePushBack(plist, 2);
	ListNodePushBack(plist, 3);
	ListNode* pos = Find(plist, 3);
	if (pos != NULL)
	{
		ListNodeErase(pos);
		ListNodePrint(plist);
	}
	else
	{
		printf("操作失败\n");
	}
	ListNodeDestroy(plist);

}

int main()
{
	TestPush();
	//TestPop();
	//Test();
	//Test1();
	return 0;
}
11：结语

以上就是我今日要为大家share的内容。其实说白了，循环链表的结构看似复杂，实际操作起来，非常简单。（就是多了一个 pre这样的一个前驱指针）。希望各位老铁们能够从这篇博客中学到一些知识，同时欢迎大家随时指正，那咱话不多说，你懂滴！


http://www.kler.cn/a/231552.html

相关文章：

  • Qt中实现旋转动画效果
  • STM32 创建一个工程文件（寄存器、标准库）
  • Linux Kernel Programming 2
  • 在 CentOS 7 上安装 MinIO 的步骤
  • 深度学习基础练习：代码复现transformer重难点
  • 微知-DOCA ARGP参数模块的相关接口和用法（config单元、params单元，argp pipe line，回调）
  • 【状态管理一】概览：状态使用、状态分类、状态具体使用
  • 项目部署小问题记录
  • python实现飞书群机器人消息通知（消息卡片）
  • 建设一个私有知识库问答网站
  • spring boot和spring cloud项目中配置文件application和bootstrap加载顺序
  • vue 实现一个持续时间定时器组件
  • uniapp中配置开发环境和生产环境
  • 深入解析 Spring 事务机制
  • ChatGPT论文指南|ChatGPT论文写作过程中6个润色与查重提示词
  • 机器学习--K-近邻算法常见的几种距离算法详解
  • 【算法题】96. 不同的二叉搜索树
  • Fink CDC数据同步（二）MySQL数据同步
  • Debian系统中挂载一个数据盘
  • 单片机向PC发送数据
  • C++之多线程（multi-thread）
  • Springboot项目报文加密（AES、RSA、Filter动态加密）
  • MySQL视图和索引
  • 【Lazy ORM】insert 使用
  • [大厂实践] Netflix容器平台内核panic可观察性实践
  • Qt 常用算法及正则表达式