C语言双向循环链表

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

双向链表 循环链表 排序插入 节点重排 C语言
关键词由CSDN通过智能技术生成

首先说明，部分代码由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
关注
  • 2
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现双向循环链表
DFGOMC的博客
08-05 281
C语言实现双向循环链表 本篇是关于双向循环链表的简单实现，有错漏的地方请在评论区评价。 ​ 双向链表是在单链表的每个结点中，再设置一个指向其前驱结点的指针域。所以在双向链表中的结点都有两个指针域，一个指向直接后继，另一个指向直接前驱。 结构体 /* 线性表的双向链表存储结构 */ typedef struct DulNode{ ElemType data; //数据域 struct DulNode *prior; //直接前驱指针 struct DulNode *next; //
c语言_数据结构_双向循环链表
SahPah的专栏
08-13 1996
双向循环链表与单向循环链表的区别在于，每个节点的指针域中除了有指向下一结点的next指针外，还有指向前一结点的prev指针：   在链表中，中间部分结点的next指针指向其直接后继结点，prev指针指向其直接前继结点。与单向循环链表相同，末结点的next指针不再指向NULL,而是指向头结点Head，而头结点的prev则指向末结点。 将新结点new插入到p所指向的结点之后：
C语言中双向链表和双向循环链表详解
08-30
主要介绍了C语言中双向链表和双向循环链表详解的相关资料,需要的朋友可以参考下
数据结构—C语言实现双向链表
Mike的博客
05-01 1261
双向带头循环链表
C语言实现双向链表
最新发布
CSQCSQCC的博客
07-04 603
通过名字可以看出，双向链表实际上是带头双向循环链表。相对于之前的单链表来说，带头的意思是存在一个“哨兵位”，故双向链表需要初始化，初始化就是创建一个“哨兵位节点”，双向的意思表示这个链表既能从前往后也能从后往前，所以在双向链表的结构里面应该也含有一个向前指向的指针prev，为了实现循环的效果，在每次创建新的节点是，该节点的next指针和prev指针都应该指向自己。
c语言双向循环链表
weixin_33694172的博客
06-07 84
双向循环链表,先来说说双向链表,双向链表也叫双链表,是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点.而循环链表之前也有说过,单链表中就是让最后一个结点的指针指向第一个结点就能构成一个循环链表,这里其实也是一样的,只不过多了一步,让第一个结点的前驱指向最后一个结点就行了,(这里介绍的是带头结点的...
[C语言数据结构]双向循环链表
本科在读，致力于Linux/C++方向的学习，同时涉及数据结构与算法，操作系统，数据库mysql等等
11-10 1590
上次我们学习了单链表的实现，相对于双向循环链表来说，单链表的各中操作，比如说增删查改等都显得非常麻烦。所以接下来来学习一下双向循环链表吧！
双向循环链表（c语言）
qq_68377379的博客
07-26 114
双向循环链表与循环单链表类似，主要多了一个指针。这次我就叙述一下主要的算法。
链表-双向循环链表【C语言】
weixin_45423515的博客
05-15 2023
双向循环链表是最优链表，能补齐单链表的缺点，是个结构复杂，操作简单的链表。其插入和删除节点的时间复杂度是O(1)。 双向链表： 和单链表不同的是双向链表有两个指针，一个指向下一个节点，一个指向上一个节点 typedef int LTDataType; typedef struct ListNode { LTDataType _data; struct ListNode* _next; struct ListNode* _prev; }ListNode; ...
C语言 双向循环链表
08-14
在C语言中，创建双向循环链表需要定义一个结构体来表示链表节点。例如： ```c typedef struct Node { int data; struct Node* next; struct Node* prev; } Node; ``` 这里的`Node`结构体包含一个整型数据`data`...
C语言数据结构之双向循环链表的实例
08-30
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语言】双向循环链表
m0_47329175的博客
06-15 1363
引言 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 双向链表 双向链表节点 typedef int CycleList_Data; typedef struct Cycle_Node { CycleList_Data data; struct Cycle_Node* front; struct Cycle_Node* next; }Cycl
C语言双向链表
anyi365416的专栏
01-17 92
　　今天写了点双向链表的各种操作，写插入的时候费了点时间，不过，现在看来还是值得耗费那点时间去写的，这种小东西应该能信手拈来才行啊。 1 /*双向链表*/ 2 #include <stdio.h> 3 #include <string.h> /*strcmp(const char *,const char *) return 0 is ...
双向循环链表
weixin_34367257的博客
09-03 128
2019独角兽企业重金招聘Python工程师标准>>> ...
【数据结构-C语言】双向循环链表
sakura0908的博客
03-02 1304
对链表而言，双向均可遍历是最方便的，另外首尾相连循环遍历也可打打增加链表操作的便捷性。因此，双向循环链表，是在实际运用中最常见的链表形态。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值