C语言: 链表 -- （环形双链表）

最新推荐文章于 2024-05-12 23:23:13 发布
最新推荐文章于 2024-05-12 23:23:13 发布
阅读量395 收藏
点赞数
分类专栏： C语言基础资料 文章标签： C 语言 环形双链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41049188/article/details/103837378
版权

环形双链表示意图：

Dome:

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


/*节点数据结构*/
typedef struct node
{
	int data;//值
	struct node* pPer;//上一节点
	struct node* pNext;//下一节点
}NODE,*PNODE;

/*双链表数结构*/
typedef struct List
{
	NODE* pHead;//链表头指针
	NODE* pTail;//链表尾指针
}LIST;

//初始化
void init(LIST* vPtr);

//尾部添加节点数据
void add_data_back(LIST* vPtr, int data);

//头部插入数据
void add_data_head(LIST* vPtr, int data);

//查找数据
PNODE find(LIST* vPtr, int data);

//修改数据
void modification(LIST* vPtr, int old_data, int new_Data);

//根据查找数据位置插入新数据
void insert_data(LIST* vPtr, int find_data, int new_Data);

//删除数据
void delete_Data(LIST* vPtr, int data);


//显示所有数据
void show_all(LIST* vPtr);

#include"list.h"

//初始化
void init(LIST* vPtr)
{
	vPtr->pHead = vPtr->pTail = NULL;
}

//尾部添加节点数据
void add_data_back(LIST* vPtr, int data)
{
	if (vPtr == NULL)
	{
		return;
	}
	PNODE vPtrNew = malloc(sizeof(NODE));
	if (vPtrNew != NULL)
	{
		vPtrNew->data = data;
		vPtrNew->pNext = NULL;
		vPtrNew->pPer = NULL;

		if (vPtr->pHead == NULL && vPtr->pTail == NULL)//没有节点
		{
			vPtr->pHead = vPtr->pTail = vPtrNew;
			vPtrNew->pNext = vPtrNew->pPer = vPtrNew;
		}
		else if(vPtr->pHead==vPtr->pTail)//单个节点
		{
			vPtr->pHead->pNext = vPtr->pHead->pPer = vPtrNew; //头节点前驱和后驱都等于新节点
			vPtrNew->pNext = vPtrNew->pPer = vPtr->pHead;//新节点的前驱和后驱都等于头节点
			vPtr->pTail = vPtrNew;//尾部指向新节点
		}
		else//多个节点
		{
			//新节点的前驱和后驱分别指向 链表结构的 尾部节点 和头部 节点
			vPtrNew->pPer = vPtr->pTail;
			vPtrNew->pNext = vPtr->pHead;


			vPtr->pTail->pNext = vPtrNew;//链表结构的 尾部后驱直指向新节点
			vPtr->pHead->pPer = vPtrNew;//链表结构的 头部前驱直指向新节点


			vPtr->pTail = vPtrNew;//尾部指向新节点
		}
	}
}

//显示所有数据
void show_all(LIST* vPtr)
{
	if (vPtr->pHead == NULL && vPtr->pTail == NULL)//没有节点
	{
		return;
	}
	else if (vPtr->pHead == vPtr->pTail)//单个节点
	{
		printf("值：【%d】；前驱指针：【%p】；后驱指针：【%p】；节点：【%p】；头指针：【%p】；尾指针：【%p】\n", vPtr->pHead->data, vPtr->pHead->pNext, vPtr->pHead->pPer,vPtr, vPtr->pHead, vPtr->pTail);
	}
	else//多个节点
	{
		PNODE pnd = vPtr->pHead;
		for (; pnd->pNext != vPtr->pHead; pnd = pnd->pNext)
		{
			printf("值：【%d】；前驱指针：【%p】；后驱指针：【%p】；节点：【%p】；头指针：【%p】；尾指针：【%p】\n", pnd->data, pnd->pNext, pnd->pPer, pnd,vPtr->pHead, vPtr->pTail);
			printf("\n");
		}
		printf("值：【%d】；前驱指针：【%p】；后驱指针：【%p】；节点：【%p】；头指针：【%p】；尾指针：【%p】\n", pnd->data, pnd->pNext, pnd->pPer, pnd,vPtr->pHead, vPtr->pTail);
	}
}

//头部插入数据
void add_data_head(LIST* vPtr, int data)
{
	if (vPtr == NULL)
	{
		return;
	}
	PNODE vPtrNew = malloc(sizeof(NODE));
	if (vPtrNew != NULL)
	{
		vPtrNew->data = data;
		vPtrNew->pNext = NULL;
		vPtrNew->pPer = NULL;

		if (vPtr->pHead == NULL && vPtr->pTail == NULL)//没有节点
		{
			vPtr->pHead = vPtr->pTail = vPtrNew;
			vPtrNew->pNext = vPtrNew->pPer = vPtrNew;
		}
		else if (vPtr->pHead == vPtr->pTail)//单个节点
		{
			vPtr->pHead->pNext = vPtr->pHead->pPer = vPtrNew;//原头节点的前驱和后驱直向新节点
			vPtrNew->pNext = vPtrNew->pPer = vPtr->pHead;//新节点的前驱和后驱指向原头节点

			vPtr->pHead = vPtrNew;//头节点指向新节点
		}
		else//多个节点
		{
			vPtrNew->pNext = vPtr->pHead;//新节点的后驱指向原头节点
			vPtrNew->pPer = vPtr->pTail;//新节点的前驱指向原尾节点

			vPtr->pHead->pPer = vPtrNew;//原 头节点的前驱 指向 新节点
			vPtr->pTail->pNext = vPtrNew;//原 尾节点的后驱 指向 新节点

			vPtr->pHead = vPtrNew;//头节点指向新节点
		}
	}
}

//查找数据
PNODE find(LIST* vPtr, int data)
{
	if (vPtr->pHead == NULL && vPtr->pTail == NULL)//没有节点
	{
		return NULL;
	}
	else if (vPtr->pHead == vPtr->pTail)//单个节点
	{
		PNODE pnd = vPtr->pHead;
		if (pnd->data == data)
		{
			return pnd;
		}
		else
		{
			return NULL;
		}
	}
	else//多个节点
	{
		PNODE pnd = vPtr->pHead;
		for (; pnd->pNext != vPtr->pHead; pnd = pnd->pNext)
		{
			if (pnd->data == data)
			{
				return pnd;
			}
		}
		if (pnd->data == data)
		{
			return pnd;
		}
		else
		{
			return NULL;
		}
		
	}
}

//修改数据
void modification(LIST* vPtr, int old_data, int new_Data)
{
	if (vPtr->pHead == NULL && vPtr->pTail == NULL)//没有节点
	{
		return;
	}
	else if (vPtr->pHead == vPtr->pTail)//单个节点
	{
		PNODE pnd = vPtr->pHead;
		if (pnd->data == old_data)
		{
			pnd->data = new_Data;
		}
	}
	else//多个节点
	{
		PNODE pnd = vPtr->pHead;
		for (; pnd->pNext != vPtr->pHead; pnd = pnd->pNext)
		{
			if (pnd->data == old_data)
			{
				pnd->data = new_Data;
			}
		}
		if (pnd->data == old_data)
		{
			pnd->data = new_Data;
		}
	}
}

//根据查找数据位置的前面插入新数据
void insert_data(LIST* vPtr, int find_data, int new_Data)
{
	if (vPtr == NULL)
	{
		return;
	}
	else
	{
		PNODE pnd = NULL;
		pnd = vPtr->pHead;
		while (pnd->pNext != vPtr->pHead)
		{
			if (pnd->data == find_data)
			{
				break;
			}
			else
			{
				pnd = pnd->pNext;
			}
		}
		if (pnd->data != find_data)//没有找到数据
		{
			return;
		}
		else
		{
			PNODE vPtrNew = malloc(sizeof(NODE));
			if (vPtrNew != NULL)
			{
				vPtrNew->data = new_Data;
				vPtrNew->pNext = NULL;
				vPtrNew->pPer = NULL;
				if (vPtr->pHead == pnd && vPtr->pTail == pnd)//链表只有单个节点
				{
					vPtr->pHead->pNext = vPtr->pHead->pPer = vPtrNew;//原头节点的前驱和后驱直向新节点
					vPtrNew->pNext = vPtrNew->pPer = vPtr->pHead;//新节点的前驱和后驱指向原头节点 [vPtr->pHead = pnd]

					vPtr->pHead = vPtrNew;//头节点指向新节点
				}
				else if (vPtr->pHead == pnd && vPtr->pTail != pnd)//头部节点
				{
					pnd->pPer = vPtrNew; // [vPtr->pHead = pnd]
					vPtr->pTail->pNext = vPtrNew;
					vPtrNew->pNext = pnd;
					vPtrNew->pPer = vPtr->pTail;
					
					vPtr->pHead = vPtrNew;
				}
				else//中间节点
				{
					vPtrNew->pPer = pnd->pPer;
					vPtrNew->pNext = pnd;
					//下面两部不要颠倒，
					pnd->pPer->pNext = vPtrNew;
					pnd->pPer = vPtrNew;
					
				}
			}
		}
	}
}

//删除数据
void delete_Data(LIST* vPtr, int data)
{
	if (vPtr == NULL)
	{
		return;
	}
	else
	{
		PNODE pnd = NULL;
		pnd = vPtr->pHead;
		while (pnd->pNext!=vPtr->pHead)
		{
			if (pnd->data == data)
			{
				break;
			}
			else
			{
				pnd = pnd->pNext;
			}
		}
		if (pnd->data != data)//没有找到数据
		{
			return;
		}
		else
		{
			if (vPtr->pHead == pnd && vPtr->pTail == pnd)//链表只有单个节点
			{
				free(vPtr->pHead);
				vPtr->pHead = NULL;
				vPtr->pTail = NULL;
			}
			else if(vPtr->pHead == pnd && vPtr->pTail != pnd)//多节点删除头部节点
			{
				pnd->pNext->pPer = vPtr->pTail;//第二节点的前驱指向原链表尾部指针
				pnd->pPer->pNext = pnd->pNext;//尾节点的后驱指向 第二节点
				//vPtr->pTail->pNext = vPtr->pHead->pNext;
				//vPtr->pHead->pPer->pNext= vPtr->pHead->pNext;

				vPtr->pHead = pnd->pNext; //头节点指向第二节点
				free(pnd);
				

			}
			else if (vPtr->pHead != pnd && vPtr->pTail == pnd)//多节点删除尾部节点
			{
				pnd->pNext->pPer = pnd->pPer;//头部节点的前驱 指向倒数第二节点
				pnd->pPer->pNext = vPtr->pHead;//倒数第二节点 的后驱指向 头节点
				vPtr->pTail = pnd->pPer;//尾部节点 指向倒数第二节点

				free(pnd);
			}
			else//多节点删除中间节点
			{
				pnd->pPer->pNext = pnd->pNext;//指定节点的 前面节点的后驱 指向 指定节点的 后面节点 （跳过指定节点）
				pnd->pNext->pPer = pnd->pPer;//指定节点的 后面节点的前驱 指向 指定节点的 前面节点 （跳过指定节点）

				free(pnd);
			}
		}
	}
}

调用示例：


#include"list.h"



void main()
{
	LIST list;
	init(&list);
	for (size_t i = 0; i < 10; i++)
	{
		add_data_back(&list, i);
	}
	printf("\n 显示所有数据 ：\n");
	show_all(&list);

	printf("\n 插入指定位置数据 ：\n");

	for (size_t i = 0; i < 4; i++)
	{
		insert_data(&list, i,i+100);
	}

	show_all(&list);

	printf("\n 修改指定数据 ：\n");
	modification(&list, 9, 999);
	modification(&list, 8, 888);
	show_all(&list);

	printf("\n删除 节点节点数据 5 和节点数据 7 ：\n");
	delete_Data(&list, 5);


	delete_Data(&list, 7);

	
	show_all(&list);



	system("pause");
}

 

 

 

haixin-561
关注
专栏目录
双指针算法-快慢指针-环形链表 II
shadowgully的博客
02-11 206
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置**（索引从 0 开始）**。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。 不允许修改 链表。 142. 环形链表 II - 力扣（LeetCode） (leetcode-cn.c
循环链表C语言实现
02-03
代码包含以下功能，经过产品验证，代码运行可靠。 1.创建链表 2.销毁链表 3.获取链表长度 4.清空链表 5.获取第pos个元素操作 6.插入元素到位置pos 7.删除位置pos处的元素 8.获取当前游标指向的数据元素； 9.将游标重置指向链表中的第一个数据元素； 10.将游标移动指向到链表中的下一个数据元素； 11.直接指定删除链表中的某个数据元素。
Leetcode腾讯精选练习32 环形链表
qq_43208608的博客
09-26 240
原题Leetcode 146 点击跳转 给定一个链表，判断链表中是否有环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 示例1： 输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。 示例2： 输入：head = [1,2]...
C语言双向环形链表
weixin_43069875的博客
11-14 215
#include<stdio.h> #include<stdlib.h> struct list { struct list *pr; int data; struct list *next; }; struct list* Create() { struct list *head,*pnew,*pre; int i; int number = 5; h...
环形链表专题（C语言）
Butayarou的博客
02-14 788
文章目录初阶版进阶版 初阶版 【题目描述】 给你一个链表的头节点 head ，判断链表中是否有环。 如果链表中存在环 ，则返回 true 。 否则，返回 false 。 注：环指的是链表尾连接到链表中形成的结构。 题目来源（力扣）：环形链表 【基本思路】 快慢指针法：慢指针一次走一步，快指针一次走两步。 若存在环，则快慢指针一直在环里循环直到相遇为止（由于慢指针一次走一步，快指针一次走两步，故必能相遇）。 若不存在环，则快指针先到达链表末尾。 【代码实现】 bool hasCycle(struct Li
链表的c语言实现（六）
leton2008的专栏
04-30 1541
循环链表及双向链表的c语言实现一、循环链表循环链表是与单链表一样，是一种链式的存储结构，所不同的是，循环链表的最后一个结点的指针是指向该循环链表的第一个结点或者表头结点，从而构成一个环形的链。循环链表的运算与单链表的运算基本一致。所不同的有以下几点：1、在建立一个循环链表时，必须使其最后一个结点的指针指向表头结点，而不是象单链表那样置为NULL。此种情况还使用于在最后一个结点后插入一个新的结点。
c语言基础-c语言编程基础之链表操作示例-环形链表.zip
03-17
链表分为单链表、双链表等类型，而环形链表是其中的一种特殊形式，它的最后一个节点的指针不为NULL，而是指向链表的第一个节点，形成一个循环。 在C语言中，创建链表需要定义结构体来表示链表节点，通常包含数据域...
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
09-20
链表的首尾节点通过指针相互连接，形成一个环形结构。这种设计使得在链表的末尾添加或删除节点时，操作更为高效，无需像单链表那样检查是否到达链表末尾。 在航空信息查询系统中，每个节点可能代表一架飞机、一次...
C语言双向链表.pdf
10-06
在C语言中，双向链表是一种比单链表更灵活的数据结构，因为它允许从两个方向遍历链表。本文将详细讲解循环链表和双向链表的概念、特点以及它们的基本操作。 首先，**循环链表**是单链表的一种变体，其特征在于最后...
c语言实现简单环形链表,C语言实现环形链表
weixin_39928768的博客
05-21 489
虽然现在开发多用Java了，闲着没事拿指针来练练手还是挺有意思的。约瑟夫的问题的解决方案有很多，可以用一个循环10不到解决，但要推导出一个公式；用一维数组加两个循环也可以，这种删除一个数据，后面元素的下标都要跟着变，不太可取。#include#includetypedef struct Linknode{int data;struct Linknode *pNext;}node,*PNODE;//...
leetcode[141]：环形链表 C语言解法
Deep_l_zh的博客
03-24 883
给定一个链表，判断链表中是否有环。 为了表示给定链表中的环，我们使用整数pos来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果pos是-1，则在该链表中没有环。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。 示例2： 输入：head = [1,2], pos =...
链表的C语言实现之循环链表及双向链表
zy122的专栏
01-15 1113
　　一、循环链表 　　循环链表是与单链表一样，是一种链式的存储结构，所不同的是，循环链表的最后一个结点的指针是指向该循环链表的第一个结点或者表头结点，从而构成一个环形的链。 　　循环链表的运算与单链表的运算基本一致。所不同的有以下几点： 　　1、在建立一个循环链表时，必须使其最后一个结点的指针指向表头结点，而不是象单链表那样置为NULL。此种情况还使用于在最后一个结点后插入一个新的结点。 　　2、
C语言——环形链表详解
最新发布
super_coders的博客
05-12 890
在一个单链表中，链表中存在环形结构。在链表中的某个节点，可以连续通过next指针再次到达，则链表中存在环。无论slow走几步，fast走几步，追击问题关系的不是走几步，而是速度差，因为他们最终都会进环。我们回到原来的问题，fast和slow到底会不会错过。当fast走三步，slow走一步时为例：如果同时存在N是奇数且C是偶数，那么将永远追不上。但是，有没有一个可能，这种情况不存在。我们使用数学来证明一下。假设slow进环时fast跟slow的距离为Nslow走的距离为L。
C语言：环形链表
2302_80892233的博客
05-05 964
copy节点的下一个节点指向cur的下一个节点，而cur节点的下一个节点更改为copy节点，即 copy->next = cur->next：cur->next =copy;思路：先在每一个节点后面开辟一个拷贝节点copy，拷贝节点的next指针就是cur的next指针，cur的next指针指向拷贝节点，原链表的random指向的下一个节点就是拷贝节点copy的random指向的节点，然后将拷贝节点尾插在一个新链表中，需要注意在尾插在新链表前先将原链表的cur指针重新指向head节点。
C语言——环形链表
qq_62476499的博客
01-09 1070
leetcode上的题目：环形链表入口
LeetCode 环形链表 C语言
qq_43874157的博客
07-12 364
思路 之前学习过快慢指针法，可用于判断循环或求中位数，于是用在这里 快指针每次走两步，慢指针每次走一步，若不存在环，则不会相遇，若存在必定会相遇 贴上代码，此版本执行时间较短 /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; ...
力扣--环形链表--C语言
weixin_47754029的博客
01-21 372
需要注意：环形链表不是循环链表，但循环链表是一种环形链表。（百度和字节喜欢考） /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ bool hasCycle(struct ListNode *head) { struct ListNode* slow=head,*fast=head; while(f..
C语言实现：普通与循环双向链表操作详解
"这篇文档介绍了C语言中双向链表的操作，包括普通双向链表和循环双向链表。主要内容包括链表的基本概念、操作原理、不同类型链表的区别以及具体的操作函数，如创建节点、插入节点、查找节点等。" 在C语言中，双向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值