数据结构(C语言)中双向链表的定义及基本操作

最新推荐文章于 2024-07-25 23:03:21 发布
最新推荐文章于 2024-07-25 23:03:21 发布
阅读量1.1k 收藏 19
点赞数 2
分类专栏： 数据结构 文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Winda_shi/article/details/127772189
版权

一、双向链表的定义及基本操作
 单链表中的结点只有一个指向其后继的指针，使得单链表要访问某个结点的前驱结点时，只能从头开始遍历，而双向链表的话 可以直接访问结点的后继结点和前驱结点。
双链表的结点中有两个指针prior和next，分别指向前驱结点和后继结点。

  1. 定义双向链表
 //定义双链表 
typedef struct DoubleLNode{
	Elem data;//数据域
	struct DoubleLNode *prior;//前驱指针 
	struct DoubleLNode *next;//后继指针 
}DLN;
  1. 初始化双向链表
 //初始化链表 
void InitLNode(DLN *&L){
	L=(DLN *)malloc(sizeof(DLN));//带头节点的链表
	L->prior=NULL;
	L->next=NULL;
}
  1. 创建双向链表
    创建链表：头插法和尾插法
//尾插法 	 
void CreateLNodeW(DLN *&L,Elem a[],int n){
	DLN *s,*p=L;
	for(int i=0;i<n;i++){
		s=(DLN *)malloc(sizeof(DLN));
		s->data=a[i];
		if(p->next==NULL){//头结点的后继结点为空的时侯 
			s->next = L;// s的后继结点为头结点H 
            s->prior = L;//s的前驱结点为头结点H 
            L->next = s;//头结点H的后继结点为s 
            L->prior=s;//头结点H的前驱结点为s 
		}
		else{//在最后插入 
			//最后一个结点为p->prior（头结点的前驱） 
			p->prior->next=s; // 
			s->prior=p->prior;
			s->next=p;
			p->prior=s;
		}
	}
}

//头插法
void CreateLNodeH(DLN *&L,Elem a[],int n){ 
	DLN *s;
	for(int i=0;i<n;i++){
		s=(DLN *)malloc(sizeof(DLN));
		s->data=a[i];
		if(L->next == NULL){//头结点的后继结点为空的时侯 
            s->next = L;//s的后继结点为头结点H 
            s->prior = L;//s的前驱结点为头结点H 
            L->next = s;//头结点H的后继结点为s 
            L->prior=s;//头结点H的前驱结点为s 
        }else{
            s->next =L->next;
            L->next->prior = s;
            s->prior = L;
            L->next = s;
        }
	}
}
  1. 判空（判断双向链表是否为空）
	//判空        
bool EmpyLNod(DLN *L){
	if(L->next==NULL || L->prior==NULL) return 1;
	return 0;
}
  1. 插入操作
    插入操作分为：结点之前和结点之后插入。
    结点之后插入：
//在p结点之后插入s结点 
bool InsertDNodeH(DLN *&L,Elem a,Elem b){// a是要插入的前一个结点,b 是我们想插入的值 。插入在 p之后 
	DLN *s,*p=L->next;
	s=(DLN *)malloc(sizeof(DLN));
	while(p->next!=L){//先找到a值的 结点，才好插入b值 
		if(p->data==a){
			break;//此时p指向所插入结点的前一个结点 
		}
		p=p->next;
	}
	if(p->next==L) return 0;//表示删除元素不在链表当中，返回 0 (false) 
	//break 之后：此时p指向所删除的结点 
	s->data=b;	//   s结点 为插入的结点 
	s->next=p->next;	// s后继结点 为 p->next(p的后继结点)。
	p->next->prior=s;	//p的后继结点 的前驱为 s 结点 
	s->prior=p;	//s结点的前驱为p结点 
	p->next=s;	//p的后继结点为s 
	return 1;
}

结点之前插入：

//在p结点之前插入s结点
bool InsertDNodeQ(DLN *&L,Elem a,Elem b){// a是要插入的前一个结点,b 是我们想插入结点的值 。插入在 p之前 
	DLN *s,*p=L->next;
	s=(DLN *)malloc(sizeof(DLN));
	while(p->next!=L){	//先找到a值的 结点，才好插入b值 
		if(p->data==a){
			break;	//此时p指向所插入结点的后一个结点 
		}
		p=p->next;
	}
	if(p->next==L) return 0;	//表示删除元素不在链表当中，返回 0 (false) 
	//break 之后：此时p指向所插入结点的前一个结点 
	s->data=b;	//   s结点 为插入的结点 
	p->prior->next=s;	//p->prior(p结点的前驱结点) 的后继结点为 s 结点 
	s->prior=p->prior;	//s的前驱为 p->prior 
	s->next=p;	// s后继结点 为 p结点
	p->prior=s;// p的前驱为s 
	return 1;
}
  1. 删除操作
    删除成功返回true，删除失败返回flase。
 //删除p结点
bool DelDNode(DLN *&L,Elem a){// a 是我们想删除的值 
	DLN *p=L->next;
	if(L->next==NULL || L->prior==NULL) return 0;
	while(p->next!=L){
		if(p->data==a){
			break;//此时p指向所删除的结点 
		}
		p=p->next;
	}
	if(p->next==L) return 0;//表示删除元素不在链表当中，返回 0 (false) 
	//break 之后：此时p指向所删除的结点 
	p->prior->next=p->next;
	free(p);  
	return 1;
 }
  1. 输出链表所有元素
 //输出链表所有的元素 
void DispLNode(DLN *L){//输出链表所有的元素 
	DLN *p=L->next;
	while(p->next!=L){
		printf("%c ",p->data);
		p=p->next;
	}
	printf("%c ",p->data);
	printf("\n");	
}

全部代码（包含主函数main() ）:


```c
#include<stdio.h>
#include<malloc.h> 
typedef char Elem;
//定义双链表 
typedef struct DoubleLNode{
	Elem data;//数据域
	struct DoubleLNode *prior;//前驱指针 
	struct DoubleLNode *next;//后继指针 
}DLN;
//初始化链表 
void InitLNode(DLN *&L){
	L=(DLN *)malloc(sizeof(DLN));//带头节点的链表
	L->prior=NULL;
	L->next=NULL;
}
//创建链表 
void CreateLNodeW(DLN *&L,Elem a[],int n){//尾插法 
	DLN *s,*p=L;
	for(int i=0;i<n;i++){
		s=(DLN *)malloc(sizeof(DLN));
		s->data=a[i];
		if(p->next==NULL){//头结点的后继结点为空的时侯 
			s->next = L;// s的后继结点为头结点H 
            s->prior = L;//s的前驱结点为头结点H 
            L->next = s;//头结点H的后继结点为s 
            L->prior=s;//头结点H的前驱结点为s 
		}
		else{//在最后插入 
			//最后一个结点为p->prior（头结点的前驱） 
			p->prior->next=s; // 
			s->prior=p->prior;
			s->next=p;
			p->prior=s;
		}
	}
}
void CreateLNodeH(DLN *&L,Elem a[],int n){//头插法 
	DLN *s;
	for(int i=0;i<n;i++){
		s=(DLN *)malloc(sizeof(DLN));
		s->data=a[i];
		if(L->next == NULL){//头结点的后继结点为空的时侯 
            s->next = L;//s的后继结点为头结点H 
            s->prior = L;//s的前驱结点为头结点H 
            L->next = s;//头结点H的后继结点为s 
            L->prior=s;//头结点H的前驱结点为s 
        }else{
            s->next =L->next;
            L->next->prior = s;
            s->prior = L;
            L->next = s;
        }
	}
}
//判空        
bool EmpyLNod(DLN *L){
	if(L->next==NULL || L->prior==NULL) return 1;
	return 0;
}
//输出链表所有的元素 
void DispLNode(DLN *L){//输出链表所有的元素 
	DLN *p=L->next;
	while(p->next!=L){
		printf("%c ",p->data);
		p=p->next;
	}
	printf("%c ",p->data);
	printf("\n");	
}
//删除p结点
bool DelDNode(DLN *&L,Elem a){// a 是我们想删除的值 
	DLN *p=L->next;
	if(L->next==NULL || L->prior==NULL) return 0;
	while(p->next!=L){
		if(p->data==a){
			break;//此时p指向所删除的结点 
		}
		p=p->next;
	}
	if(p->next==L) return 0;//表示删除元素不在链表当中，返回 0 (false) 
	//break 之后：此时p指向所删除的结点 
	p->prior->next=p->next;
	free(p);  
	return 1;
 } 
//在p结点之后插入s结点 
bool InsertDNodeH(DLN *&L,Elem a,Elem b){// a是要插入的前一个结点,b 是我们想插入的值 。插入在 p之后 
	DLN *s,*p=L->next;
	s=(DLN *)malloc(sizeof(DLN));
	while(p->next!=L){//先找到a值的 结点，才好插入b值 
		if(p->data==a){
			break;//此时p指向所插入结点的前一个结点 
		}
		p=p->next;
	}
	if(p->next==L) return 0;//表示删除元素不在链表当中，返回 0 (false) 
	//break 之后：此时p指向所删除的结点 
	s->data=b;	//   s结点 为插入的结点 
	s->next=p->next;	// s后继结点 为 p->next(p的后继结点)。
	p->next->prior=s;	//p的后继结点 的前驱为 s 结点 
	s->prior=p;	//s结点的前驱为p结点 
	p->next=s;	//p的后继结点为s 
	return 1;
}
//在p结点之前插入s结点 
bool InsertDNodeQ(DLN *&L,Elem a,Elem b){// a是要插入的前一个结点,b 是我们想插入结点的值 。插入在 p之前 
	DLN *s,*p=L->next;
	s=(DLN *)malloc(sizeof(DLN));
	while(p->next!=L){	//先找到a值的 结点，才好插入b值 
		if(p->data==a){
			break;	//此时p指向所插入结点的后一个结点 
		}
		p=p->next;
	}
	if(p->next==L) return 0;	//表示删除元素不在链表当中，返回 0 (false) 
	//break 之后：此时p指向所插入结点的前一个结点 
	s->data=b;	//   s结点 为插入的结点 
	p->prior->next=s;	//p->prior(p结点的前驱结点) 的后继结点为 s 结点 
	s->prior=p->prior;	//s的前驱为 p->prior 
	s->next=p;	// s后继结点 为 p结点
	p->prior=s;// p的前驱为s 
	return 1;
}
int main(){
	DLN *L;
	InitLNode(L);
	Elem a[]={'a','b','c','d'};
	CreateLNodeW(L,a,4); DispLNode(L);
	DelDNode(L,'a'); DispLNode(L);
	printf("输出1 表示插入成功 输出0 表示插入失败：%d\n",InsertDNodeH(L,'b','e'));  DispLNode(L);
	printf("输出1 表示插入成功 输出0 表示插入失败：%d\n",InsertDNodeH(L,'b','f'));  DispLNode(L);
	return 0;
}

二、总结反思：

双链表与单链表在某些操作上大同小异

Big-Winda
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构-双向链表的基本操作 （c语言实现）
weixin_59799963的博客
10-19 3590
1.创造一个节点,函数实现 DListNode* BuyListNode(Datetype x) { DListNode*node = (DListNode*)malloc(sizeof(DListNode)); node->date = x; node->next = NULL; node->prev = NULL; return node; } 2. 初始化 DListNode* DListInit() { DListNode*plist = BuyListNod
C语言 数据结构双向链表简单实例
08-31
本文主要介绍了C语言数据结构双向链表简单实例的相关知识点，包括双向链表的基本操作、删除元素、插入元素、判断对称性、排序等。 一、双向链表的基本操作 双向链表是一种数据结构，它可以在链表的任意位置插入或...
C语言详解双向链表的基本操作
qq_61386381的博客
05-17 3246
双链表的定义与接口函数 定义双链表 接口函数 详解接口函数的实现 创建新节点（BuyLTNode） 初始化双链表（ListInit） 双向链表打印（ListPrint） 双链表查找（ListFind） 双链表销毁（ListDestory） 1、双链表pos位置之前插入（ListInsert） 2、双链表删除pos位置（ListEarse） 3、双向链表尾插（ListPushBack） 4、双向链表头插（ListPushFront） 5、双链表头删（ListPopF.......
数据结构 --- c语言实现双向链表
weixin_60569662的博客
07-07 2617
双向链表主要分为三部分前项指针后项指针数据域一般情况下，创建单一个体，前项指针和后项指针都赋值为空一般采用记录头节点和记录尾节点，再封装的方式写双向链表 再定义一个结构体(链表) 通过记录头节点和尾节点的方式去描述链表 创建节点 把用户的数据变成一个结构体变量 创建链表 描述链表最初的状态 头插法 ①新节点的后项指针指向原来链表的头节点②原来链表的头节点的前项指针指向新节点③把原来的头节点移到新节点的位置 打印链表 可以通过前项指针去做打印，也可以通过后项
数据结构-双向链表（C语言）
usiehheu的博客
05-03 1726
文章目录1、双向链表的定义2、双向链表的初始化3、双向链表的打印4、双向链表的插入5、双向链表的删除6、双向链表的元素定位7、链表清空8、测试二、完整代码 1、双向链表的定义 双向链表是链表的一种，与单链表不同的shi，它的每个数据结点中都有两个指针，分别指向直接前驱和直接后继。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。下图为双向链表的结构图。 typedef struct DoubleLinkNode { char data; struct DoubleLink
双向链表--C语言实现数据结构
2201_76062618的博客
05-13 5002
本文详细介绍带头双向循环链表，内容较为丰富
C语言数据结构之双向链表
Qurry的博客
09-21 1294
前面介绍了单链表，由于单链表遍历查找是单向性的，故引出了双向链表的概念，也叫双链表，既可以向前查找，也可以向后遍历。
【数据结构】 双链表的基本操作 （C语言版）
weixin_56814370的博客
01-21 973
【数据结构】 双链表的基本操作 （C语言版）
【数据结构】C语言实现双链表的基本操作
蒙奇D索大的博客
12-29 1756
【数据结构】第二章——线性表（7） 详细介绍了通过C语言实现双链表及其基本操作……
数据结构初阶 --- 双向链表的C语言实现
m0_71722065的博客
09-12 2519
带头双向循环链表
C语言数据结构 双向链表的建立与基本操作
01-01
C语言数据结构 双向链表的建立与基本操作 双向链表比单链表有更好的灵活性，其大部分操作与线性表相同。下面总结双向链表与单链表之间的不同之处及我在实现过程中所遇到的问题。 1.双向链表的建立 双向链表在初始...
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
学习和掌握链表操作，尤其是双向循环链表，对于理解和编写复杂的数据结构和算法至关重要，这对于软件开发人员来说是必不可少的技能。在实际应用中，链表常用于实现如队列、栈、哈希表等高级数据结构，以及解决各种...
C语言数据结构之双向循环链表的实例
08-30
本实例展示了C语言中双向循环链表的实现，包括链表的定义、链表的基本操作、链表的遍历和搜索等。通过本实例，我们可以了解C语言中链表的实现和应用。 KNOWLEDGE POINTS: 1.C语言中链表的定义和实现 2.双向循环...
C语言中双向链表和双向循环链表详解
08-30
在C语言中，双向链表是一种数据结构，具有前驱结点和后驱结点两个指针，分别指向前一个结点和后一个结点。双向循环链表则是双向链表的一种特殊形式，其中最后一个结点的next指向头结点，头结点的prior指向最后一个...
【数据结构】单链表的增删改查
2302_78914800的博客
07-25 757
链表是有序的列表，但是它在内存中是如下存储的：①链表以节点的方式进行存储，是链式存储的②每个节点包含 data 域、next 域：指向下一节点③链表的各个节点不一定是连续存放的④链表分为有头节点的链表和没有头节点的链表head节点1.不存放具体数据2.作用就是表示单链表头。
c语言（7.23）
fhgfyrsg的博客
07-23 636
【代码】c语言（7.23）
Linux嵌入式学习——数据结构——线性表的链式结构
m0_71703182的博客
07-24 773
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
《Java初阶数据结构》----7.＜优先级队列PriorityQueue＞
最新发布
m0_73456341的博客
07-25 833
本篇博客主要讲解Java基础语法中的 优先级队列、PriorityQueue的特性、常用方法介绍、编程题练习
C语言中的链表结构体定义及应用
"这篇资源主要介绍了C语言中的结构体及其在链表定义中的应用。" 在C语言中，结构体是一种非常重要的构造数据类型，它允许我们将不同类型的数据组合在一起，形成一个逻辑上相关的数据单元。这在处理复杂数据时特别...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Big-Winda

感谢支持

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

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

打赏作者

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

抵扣说明：

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

余额充值