C语言双向循环链表

已于 2023-09-11 19:25:44 修改
阅读量4.5k 收藏 47
点赞数 2
分类专栏： 数据结构 C语言 文章标签： 链表 数据结构 算法
于 2021-08-07 21:05:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45911878/article/details/119491874
版权

首先说明，部分代码由AI编写，使用的是国内基于ChatGPT3.5的一款AI软件，速度有点慢但是免费，地址是：点击这里

一、介绍

在C语言中，链表分为单向链表和双向链表，单向链表只能朝一个方向遍历，中间的一个节点只能由上一个节点推出，只能往前推，无法往后推，关于单向链表的介绍可以点击单向链表介绍。
这次介绍双向链表，既然叫双向就说明可以往两个方向进行遍历，可以利用中间的一个节点推出下一个节点和上一个节点，所以在定义一个双向链表节点的时候，除了要保存数据和下一个节点的地址，还得保存上一个节点的地址，定义如下：

typedef struct NODE{
	int data;//要保存的数据
	struct NODE *next;//下一节点地址
	struct NODE *prev;//上一节点地址
}*NODE;

在此基础上，如果让头结点的prev指向尾结点，让尾结点的next指向头结点，那么就构成了双向循环链表，如图示：
在这里插入图片描述

二、创建双向循环链表

思路：先创建一个节点，并且让该节点的next和prev都指向自己，让他自己跟自己循环，再依次加入新节时，这时只需改变头结点的prev和尾结点的next以及新节点的next和prev即可。
如图示：
在这里插入图片描述

示例代码：

    NODE node = GetNewNode();//获取新节点
	//先让他自己循环
	node->next = node;
	node->prev = node;
	int data;
	scanf("%d",&data);
	getchar();
	node->data = data;
	while(1){
		if(scanf("%d",&data)==1){
			getchar();
			NODE new = GetNewNode();
			new->data = data;
			InsertNode(node,new);
			ShowNode(node);
		}
		else
			break;
	}

注：在这里定义的规则是输入非数字就停止创建新节点。
给出GetNewNode函数代码：

NODE GetNewNode(){
	NODE new = malloc(sizeof(struct NODE));
	if(new==NULL){
		perror("获取内存失败！");
		exit(1);
	}else
	return new;
}

给出InsertNode函数代码：

//正向插入节点
void InsertNode(NODE node,NODE new){
	NODE temp = node;
	while(node->next != temp){//判断是否到达尾结点
		node = node->next;
	}
	node->next = new;
	new->prev = node;
	new->next = temp;
	temp->prev = new;
}

给出ShowNode函数代码：

void ShowNode(NODE node){
	NODE temp = node;
	printf("正向遍历双向循环链表：");
	while(node->next!=temp){//判断是否到达尾结点
		printf("%d\t",node->data);
		node = node->next;
	}
	printf("%d\t\n",node->data);//输出尾结点数据
}

三、排序插入

排序插入即按从小到大排列链表，创建新链表后寻找合适位置再插入，使得链表始终是按从小到大排列的。实现原理和单向链表排序插入类似，只是要多改变两个指针的指向，我的实现方法中把情况分为三类：
①插入的是第二个节点，直接插在头结点后面，如果头结点比新节点大，那么两个节点交换数据；
②中间节点，遍历链表找到两个连续节点一个节点比新节点小另一个节点比新节点大，插在中间；
③找不到比新节点大的节点，那么是最后一个节点，直接插在末尾。
如图示：
在这里插入图片描述
示例代码：

//按从小到大顺序插入
int SortInsertNode(NODE node,NODE new){
	NODE temp = node;
	if(node->next == node){//代表只有一个节点,就插到第一个节点后面
		node->next = new;
		new->prev = node;
		node->prev = new;
		new->next = node;
		if(new->data<=node->data){//如果新节点小于旧节点，则两个交换值
			int data = node->data;
			node->data = new->data;
			new->data = data;
		}
		return 1;//结束函数运行
	}else{//如果不是第一个节点
		while(node->next != temp){//开始遍历
			if(node->data<=new->data&&node->next->data>new->data){//判断某个节点是否小于新节点且该节点的下一个节点大于新节点
				//插在中间
				new->next = node->next;
				node->next->prev = new;
				node->next = new;
				new->prev = node;
				return 1;//结束运行
			}
		   node = node->next;
	    }
	}
	//能运行到这里说明新节点是最大的节点，直接插到最后
	node->next = new;
	new->prev = node;
	new->next = temp;
	temp->prev = new;
	return 1;
}

注：return无实际用途，仅仅为了结束函数运行。

四、应用

看到一道题目：
创建一个空的双向循环链表。将自然数作为链表节点里面的数据，并将若干个自然数插入链表。比如依次插入从1到10个自然数: 1，2，3，4，5，6，7、8，9，10然后通过某些操作，将其重新排列成1，3，5，7，9，10，8，6，4，2，即奇数升序偶数降序，并在屏幕上打印出来。
从中可以发现规律：奇数顺序不变，越小的偶数越扔后面，所以思路就来了：
从后往前遍历，如果遇到奇数则不变，如果遇到偶数，将节点断开插到链表末尾。
如图示：
在这里插入图片描述
示例代码：
注释较多，不再做解释。

NODE DropNode(NODE node){
	NODE first = node;//指向链表最前
	NODE q = node->prev,p;//指向链表最后，q是主指针，p是次指针
	NODE last = node->prev;//一直指向链表最后
	NODE temp = first;//最后使用
	while(q!=node){//遍历直到到达第一个节点
		if(q->data%2==0&&q!=last){//判断是否是偶数和最后一个节点，因为最后一个节点不管怎么样没必要移
			p = q;//赋值给p，不能影响主指针
			q = q->prev;//主指针向前移
			//从中断开
			p->prev->next = p->next;
			p->next->prev = p->prev;
			last->next = p;//插到最后
			p->prev = last;
			p->next = first;
			first->prev = p;
			last = p;//新插的节点成为最后的节点
		}
		else
		    q = q->prev;//主指针向前移
	}
	//判断第一个节点是否为偶数，如果是直接让第二个节点成为头结点
	if(first->data%2==0){
		temp = first->next;
	}
	return temp;//返回头结点
}

五、完整代码

//双向循环链表
#include<stdio.h>
#include<stdlib.h>
typedef struct NODE{
	int data;//要保存的数据
	struct NODE *next;//下一节点地址
	struct NODE *prev;//上一节点地址
}*NODE;
//获取新节点
NODE GetNewNode(){
	NODE new = malloc(sizeof(struct NODE));
	if(new==NULL){
		perror("获取内存失败！");
		exit(1);
	}else
	return new;
}
//正向插入节点
void InsertNode(NODE node,NODE new){
	NODE temp = node;
	while(node->next != temp){
		node = node->next;
	}
	node->next = new;
	new->prev = node;
	new->next = temp;
	temp->prev = new;
}
//按从小到大顺序插入
int SortInsertNode(NODE node,NODE new){
	NODE temp = node;
	if(node->next == node){//代表只有一个节点,就插到第一个节点后面
		node->next = new;
		new->prev = node;
		node->prev = new;
		new->next = node;
		if(new->data<=node->data){//如果新节点小于旧节点，则两个交换值
			int data = node->data;
			node->data = new->data;
			new->data = data;
		}
		return 1;//结束函数运行
	}else{//如果不是第一个节点
		while(node->next != temp){//开始遍历
			if(node->data<=new->data&&node->next->data>new->data){//判断某个节点是否小于新节点且该节点的下一个节点大于新节点
				//插在中间
				new->next = node->next;
				node->next->prev = new;
				node->next = new;
				new->prev = node;
				return 1;//结束运行
			}
		   node = node->next;
	    }
	}
	//能运行到这里说明新节点是最大的节点，直接插到最后
	node->next = new;
	new->prev = node;
	new->next = temp;
	temp->prev = new;
	return 1;
}
void ShowNode(NODE node){
	NODE temp = node;
	printf("正向遍历双向循环链表：");
	while(node->next!=temp){
		printf("%d\t",node->data);
		node = node->next;
	}
	printf("%d\t\n",node->data);
}
void ReverseShowNode(NODE node){
	NODE temp = node;
	printf("反向遍历双向循环链表：");
	while(node->prev!=temp){
		printf("%d\t",node->data);
		node = node->prev;
	}
	printf("%d\t\n",node->data);
}
NODE DropNode(NODE node){
	NODE first = node;//指向链表最前
	NODE q = node->prev,p;//指向链表最后，q是主指针，p是次指针
	NODE last = node->prev;//一直指向链表最后
	NODE temp = first;//最后使用
	while(q!=node){//遍历直到到达第一个节点
		if(q->data%2==0&&q!=last){//判断是否是偶数和最后一个节点，因为最后一个节点不管怎么样没必要移
			p = q;//赋值给p，不能影响主指针
			q = q->prev;//主指针向前移
			//从中断开
			p->prev->next = p->next;
			p->next->prev = p->prev;
			last->next = p;//插到最后
			p->prev = last;
			p->next = first;
			first->prev = p;
			last = p;//新插的节点成为最后的节点
		}
		else
		    q = q->prev;//主指针向前移
	}
	//判断第一个节点是否为偶数，如果是直接让第二个节点成为头结点
	if(first->data%2==0){
		temp = first->next;
	}
	return temp;//返回头结点
}
int main(){
	NODE node = GetNewNode();//获取新节点
	//先让他自己循环
	node->next = node;
	node->prev = node;
	int data;
	scanf("%d",&data);
	getchar();
	node->data = data;
	while(1){
		if(scanf("%d",&data)==1){
			getchar();
			NODE new = GetNewNode();
			new->data = data;
			InsertNode(node,new);//正向插入
			ShowNode(node);//输出
			ReverseShowNode(node);//反向输出
		}
		else
			break;
	}
	node = DropNode(node);//改变节点位置
	ShowNode(node);
	return 0;
}

到此结束！

徐曙fia
关注
专栏目录
双向链表的C语言实现与基本操作（二）
TECH_PRO的博客
04-19 823
本文的主要内容目录： 一、链表结点元素的添加 二、链表结点元素的删除 三、链表结点元素的更改 四、链表结点元素的查询 在上一篇博文中已经对双向链表的实现做了比较详细地阐述，在一篇文章来说一说双向链表的四个基本操作：增、删、改、查。在讲基本操作之前，再来看看链表结点元素的结构体的实现，它是整个数据结构的核心。 /* 定义一个表示链表的结构体指针 */ struct list {
双向链表(C语言)
weixin_43405004的博客
10-17 297
双向链表就是链表方向是双方向的，也就是双向链表中的每一个节点有两个指针，一个指针用来指向上一个节点（前驱），另一个指针用指向下一个节点（后继）。 本文主要是对双向链表的基本操作，主要包括双向链表的创建，插入节点，删除节点，还有输出节点的数据等。 结点的构造 typedef struct node { ​ int data; ​ struct node *prev; ​ struct node *next; }Node，*pNode; 基本操作 双向链表的创建 双向链表的创建同样像单链表一样
C语言_双向循环链表的基本操作
A__B__C__的博客
09-11 1818
目录： 1、初始化 2、头部插入 3、头部删除 4、尾部插入 5、尾部删除 6、打印链表 7、任意位置插入 8、查找值为data的节点 9、指定位置删除 10、销毁链表 1、初始化： 创建一个节点，给节点赋值为0；因为是循环链表，所以让它的_pNext指针域和_pPre 指针域都指向自己 void DCListInit ...
【C语言数据结构】之循环链表
weixin_61276540的博客
09-18 951
本文主要讲解数据结构的循环链表。主打一个手搓代码，能把代码写出来才是最重要的事情。
c语言双向循环链表
weixin_33694172的博客
06-07 95
双向循环链表,先来说说双向链表,双向链表也叫双链表,是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点.而循环链表之前也有说过,单链表中就是让最后一个结点的指针指向第一个结点就能构成一个循环链表,这里其实也是一样的,只不过多了一步,让第一个结点的前驱指向最后一个结点就行了,(这里介绍的是带头结点的...
c语言_数据结构_双向循环链表
SahPah的专栏
08-13 2046
双向循环链表与单向循环链表的区别在于，每个节点的指针域中除了有指向下一结点的next指针外，还有指向前一结点的prev指针：   在链表中，中间部分结点的next指针指向其直接后继结点，prev指针指向其直接前继结点。与单向循环链表相同，末结点的next指针不再指向NULL,而是指向头结点Head，而头结点的prev则指向末结点。 将新结点new插入到p所指向的结点之后：
C语言实现双向循环链表
weixin_46401837的博客
10-26 635
双向链表一、为什么引入双向循环链表二、双向循环链表的实现三、代码部分1、结构的声明2、方法声明3、方法的实现总结 一、为什么引入双向循环链表 1、循环链表的特点： 循环链表建立在单项链表的基础之上，它的最后一个结点指向了头结点，形成了一个环，因此，从循环链表中的任意结点出发都能找到任何其他的结点。但是，如果寻找它的前驱结点，就必须从该结点重新遍历，时间复杂度为O(n)。 2、双向链表的特点： 双向链表可以轻松的找到一个结点的前驱和后继。首结点的 prior域 和 尾结点的 next域 为NULL。​双向链
C语言 双向循环链表
08-14
在C语言中，创建双向循环链表需要定义一个结构体来表示链表节点。例如： ```c typedef struct Node { int data; struct Node* next; struct Node* prev; } Node; ``` 这里的`Node`结构体包含一个整型数据`data`...
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
写一个C语言双向循环链表
02-22
C语言双向循环链表的实现方法如下： 1. 定义一个双向循环链表节点结构：struct node{ int data; struct node *prev; struct node *next; }; 2. 定义一个头节点：struct node *head; 3. 初始化头节点：head->data = 0...
C语言使用双向循环链表实现通讯录
weixin_45050042的博客
10-11 3162
使用双向链表实现通信录，实现添加功能、删除功能、查询功能、修改功能、显示功能。 #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct linkman { char name[10]; char Tel[20]; struct linkman *prev; struc...
[C语言数据结构]双向循环链表
本科在读，致力于Linux/C++方向的学习，同时涉及数据结构与算法，操作系统，数据库mysql等等
11-10 1858
上次我们学习了单链表的实现，相对于双向循环链表来说，单链表的各中操作，比如说增删查改等都显得非常麻烦。所以接下来来学习一下双向循环链表吧！
【C语言】双向循环链表
m0_47329175的博客
06-15 1395
引言 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 双向链表 双向链表节点 typedef int CycleList_Data; typedef struct Cycle_Node { CycleList_Data data; struct Cycle_Node* front; struct Cycle_Node* next; }Cycl
C语言双向链表
anyi365416的专栏
01-17 109
　　今天写了点双向链表的各种操作，写插入的时候费了点时间，不过，现在看来还是值得耗费那点时间去写的，这种小东西应该能信手拈来才行啊。 1 /*双向链表*/ 2 #include <stdio.h> 3 #include <string.h> /*strcmp(const char *,const char *) return 0 is ...
【数据结构-C语言】双向循环链表
sakura0908的博客
03-02 1733
对链表而言，双向均可遍历是最方便的，另外首尾相连循环遍历也可打打增加链表操作的便捷性。因此，双向循环链表，是在实际运用中最常见的链表形态。
双向循环链表C语言
qq_18431031的博客
03-01 170
#include <stdio.h> #include <stdlib.h> struct doubleList { int data; struct doubleList* front; struct doubleList* rear; }; struct doubleList* createList() { struct doubleList* headNode...
C语言-双向循环链表
背着行囊去远方的博客
03-18 193
功能：实现双向循环链表做数据插入，删除使用 #include <stdio.h> #include <stdlib.h> #include <string.h> #define RET_OK 1 #define RET_ERROR 0 #define UDPLEN 1024 //链表的类型 typedef struct LNode { char ...
创建双向循环链表C语言
最新发布
10-13
创建双向循环链表在C语言中涉及到结构体、指针以及链表的基本操作。首先，我们需要定义一个节点结构体，包含前驱和后继指针： ```c typedef struct Node { int data; // 节点存储的数据 struct Node* prev; // 指向前一个节点 struct Node* next; // 指向下一个节点 } Node; ``` 接下来，我们可以定义函数来创建链表头结点、添加新节点到链表尾部并保持循环： ```c // 初始化一个空的双向循环链表 Node* createDoublyCircularList() { Node* head = (Node*)malloc(sizeof(Node)); if (head) { head->data = 0; head->prev = head; head->next = head; } return head; } // 添加新节点到链表尾部 void addNodeToTail(Node** head, int value) { Node* newNode = (Node*)malloc(sizeof(Node)); if (newNode) { newNode->data = value; newNode->prev = (*head)->prev; newNode->next = (*head); (*head)->prev->next = newNode; (*head)->prev = newNode; } else { printf("Memory allocation failed.\n"); } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值