数据结构：线性表链式存储结构（双向链表） C语言版

最新推荐文章于 2024-05-01 16:12:25 发布
最新推荐文章于 2024-05-01 16:12:25 发布
阅读量585 收藏 1
点赞数
分类专栏： 算法 文章标签： 数据结构 双向链表 Linux 内核链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41049188/article/details/107304346
版权

双向链表：

在单链表中，有了 next 指针，这使得查找下一结点的时间复杂度为 O ( 1 ) O(1) O(1) ，可是如果我们查找上一结点的话，那最坏的时间复杂度就是 O ( n ) O(n) O(n) 了，因为每次都要从头开始遍历查找。
双向链表就克服了这一缺陷。双向链表 ( Double Linked List ) 是在单链表的每个结点中，再设置一个指向其前驱结点的指针域。 所以，在双向链表中的结点都有两个指针域，一个指向直接后继，了另一个指向直接前驱。

typedef struct _Tag_D_LinkList_Node
{
	struct _Tag_D_LinkList_Node* next; //后继
	struct _Tag_D_LinkList_Node* prec; //前驱
}DLTNode;							   //双向链表节点

既然单链表有循环链表，双向链表也可以有循环双向链表。
包含头节点的双向循环空链表，其结构如下图：
在这里插入图片描述
非空的双向循环链表带头结点的结构如下图：
在这里插入图片描述

双向链表的代码设置与实现：

在这里插入图片描述

基于 liunx 内核链表模型

1：头文件 ，定义数据结构和操作函数

#ifndef  _D_LINK_LIST_H_
#define  _D_LINK_LIST_H_


#define  DLINK_LIST_ERR_POS   (DLINK_LIST_ERROR-2)    //位置下标超出范围 
#define  DLINK_LIST_ERR_NULL  (DLINK_LIST_ERROR-1)    //数据或参数为空
#define  DLINK_LIST_ERROR     (-1)                    //错误
#define  DLINK_LIST_VALID     (DLINK_LIST_ERROR+1)    //正确



typedef void DLinkList;

typedef struct _Tag_D_LinkList_Node
{
	struct _Tag_D_LinkList_Node* next; //后继
	struct _Tag_D_LinkList_Node* prec; //前驱
}DLTNode;							   //双向链表节点

//创建链表
DLinkList* DLinkList_Create();

//释放链表指针空间
void DLinkList_Destroy(DLinkList* list);

//清空链表
void DLinkList_Clear(DLinkList* list);

//获取链表元素个数
int DLinkList_Length(DLinkList* list);

//根据给定位置下标插入元素
int DLinkList_Insert(DLinkList* list, DLTNode* node, int pos);

//根据给定位置获取元素节点
DLTNode* DLinkList_Get(DLinkList* list, int pos);

//根据给定位置删除元素节点
DLTNode* DLinkList_Delete(DLinkList* list, int pos);

//删除指定的元素节点
DLTNode* DLinkList_DeleteNode(DLinkList* list, DLTNode* node);

//重置链表
DLTNode* DLinkList_Reset(DLinkList* list);

//获取当前链表游标指向元素
DLTNode* DLinkList_Current(DLinkList* list);

//获取当前链表游标指向元素的下一个元素
DLTNode* DLinkList_Next(DLinkList* list);

//获取当前链表游标指向元素的上一个元素
DLTNode* DLinkList_Pre(DLinkList* list);

#endif //_D_LINK_LIST_H_

2：函数实现：

#include "DLinkList.h"
#include <stdlib.h>
#include<memory.h>

typedef struct _Tag_DLink_List
{
	DLTNode 	pHeader;     //链表头指针
	DLTNode*	slider;      //链表游标
	int			length;      //链表数据长度
}TDList;					 //链表内部数据结构	


//创建链表
DLinkList* DLinkList_Create()
{
	TDList* pdList = (TDList*)malloc(sizeof(TDList));
	if (pdList!=NULL)
	{
		memset(pdList, 0x00, sizeof(TDList));
		pdList->length = 0;
		pdList->pHeader.next = NULL;
		pdList->pHeader.prec = NULL;
		pdList->slider = NULL;
	}
	return pdList;
}

//释放链表指针空间
void DLinkList_Destroy(DLinkList* list)
{
	if (list!=NULL)
	{
		free(list);
	}
}

//清空链表
void DLinkList_Clear(DLinkList* list)
{
	TDList* pdList = (TDList*)list;
	if (pdList!=NULL)
	{
		pdList->length = 0;
		pdList->slider = NULL;
		pdList->pHeader.next = NULL;
		pdList->pHeader.prec = NULL;
	}
	return ;
}

//获取链表元素个数
int DLinkList_Length(DLinkList* list)
{
	TDList* pdList = (TDList*)list;
	if (pdList==NULL)
	{
		return DLINK_LIST_ERROR;
	}
	return pdList->length;
}

//根据给定位置下标插入元素
int DLinkList_Insert(DLinkList* list, DLTNode* node, int pos)
{
	int		i = 0;
	TDList* pdList = (TDList*)list;
	if (pdList == NULL || node == NULL)
	{
		return DLINK_LIST_ERR_NULL;
	}
	if (pos < 0)
	{
		return DLINK_LIST_ERR_POS;
	}

	//声明辅助指针变量
	DLTNode* currNode = (DLTNode*)pdList; //指针指向链表头部
	DLTNode* nextNode = NULL;
	{
		
		for (i = 0; i < pos && (currNode->next != NULL); i++)
		{
			currNode = currNode->next;//指针移动到指定位置
		}
		nextNode = currNode->next;//当前位置的元素
		//交换位置
		currNode->next = node;//插入当前节点
		node->next = nextNode;//要插入的元素节点的后继指针指向原来位置的节点 

		//nextNode==NULL表示当前链表插入第一个元素 要特殊处理,如果不是则让后续元素的前驱指针指向当前插入元素
		if (nextNode !=NULL)
		{
			nextNode->prec = node;//前驱指向要插入的元素
		}

		if (pdList->length == 0)
		{
			pdList->slider = node;
		}

		if (currNode == (DLTNode*)pdList)//当前在0号位置插入元素
		{
			node->prec = NULL;
		}
		else
		{
			node->prec = currNode;
		}
		pdList->length++;
	}
	return DLINK_LIST_VALID;
}

//根据给定下标位置获取元素节点
DLTNode* DLinkList_Get(DLinkList* list, int pos)
{
	TDList* pdList = (TDList*)list;
	DLTNode* ret = NULL;
	int i = 0;
	if (pdList != NULL && 0 <= pos&&pos < pdList->length);
	{
		DLTNode* currTmp = (DLTNode*)pdList;
		for (i = 0; i < pos;i++)
		{
			currTmp = currTmp->next;
		}
		ret = currTmp->next;
	}
	return ret;
}

//根据给定位置删除元素节点
DLTNode* DLinkList_Delete(DLinkList* list, int pos)
{
	TDList  *pdList = (TDList*)list;
	DLTNode *ret = NULL, *next = NULL;
	int i = 0;
	if (pdList==NULL||pos<0)
	{
		return NULL;
	}

	DLTNode* currTmp = (DLTNode*)pdList;
	for (i = 0; i < pos;i++)
	{
		currTmp = currTmp->next;
	}
	ret = currTmp->next;//要删除的节点
	next = ret->next;//删除节点的下一节点

	currTmp->next = next;//1：跳过删除的节点，后驱指针进行链表连接
	if (next!=NULL)//2:前驱指针进行连接
	{
		next->prec = currTmp;
		if (currTmp == (DLTNode*)pdList)//如果是头节点，前驱指针指向NULL
		{
			next->prec = NULL;
		}
	}

	if (pdList->slider==ret)
	{
		pdList->slider = next;
	}
	pdList->length--;

	return ret;
}

//删除指定的元素节点
DLTNode* DLinkList_DeleteNode(DLinkList* list, DLTNode* node)
{
	TDList* pdList = (TDList*)list;
	DLTNode* ret = NULL;
	int i = 0;
	if (pdList!=NULL&&node!=NULL)
	{
		DLTNode *currTmp = (DLTNode*)pdList;
		for (i = 0; i < pdList->length; i++)
		{
			if (currTmp->next=node)
			{
				ret = currTmp->next;
				break;
			}
			currTmp = currTmp->next;
		}
		if (ret!=NULL)
		{
			DLinkList_Delete(pdList, i);
		}
	}

	return ret;
}

//重置链表游标
DLTNode* DLinkList_Reset(DLinkList* list)
{
	TDList* pdList = (TDList*)list;
	DLTNode* ret = NULL;
	if (pdList!=NULL)
	{
		pdList->slider = pdList->pHeader.next;
		ret = pdList->slider;
	}
	return ret;
}

//获取当前链表游标指向元素
DLTNode* DLinkList_Current(DLinkList* list)
{
	TDList* pdList = (TDList*)list;
	DLTNode* ret = NULL;
	if (pdList!=NULL)
	{
		ret = pdList->slider;
	}
	return ret;
}

//获取当前链表游标指向的元素并且游标下移指向下一个元素
DLTNode* DLinkList_Next(DLinkList* list)
{
	TDList* pdList = (TDList*)list;
	DLTNode* ret = NULL;
	if (pdList != NULL&&pdList->slider!=NULL)
	{
		ret = pdList->slider;
		pdList->slider = ret->next;
	}
	return ret;
}

//获取当前链表游标指向的元素并且游标上移指向上一个元素
DLTNode* DLinkList_Pre(DLinkList* list)
{
	TDList* pdList = (TDList*)list;
	DLTNode* ret = NULL;
	if (pdList != NULL&&pdList->slider != NULL)
	{
		ret = pdList->slider;
		pdList->slider = ret->prec;
	}
	return ret;
}

函数重点操作：
插入操作：

在这里插入图片描述
删除操作：

在这里插入图片描述
3：调用示例：

#define  _CRT_SECURE_NO_WARNINGS
#include "DLinkList.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct _User_info
{
	DLTNode node;
	int age;
	char name[16];
}User;

int main(int argc, char *argv[])
{
	int i = 0;
	User *tmp = NULL;
	DLinkList* list = DLinkList_Create();

	User u1, u2, u3, u4, u5, u6;
	{
		u1.age = 11;
		u2.age = 12;
		u3.age = 13;
		u4.age = 14;
		u5.age = 15;
		u6.age = 16;
		strcpy(u1.name, "AAAA");
		strcpy(u2.name, "BBBB");
		strcpy(u3.name, "CCCC");
		strcpy(u4.name, "DDDD");
		strcpy(u5.name, "EEEE");
		strcpy(u6.name, "FFFF");
	}

	//插入数据
	DLinkList_Insert(list, (DLTNode*)&u1, DLinkList_Length(list));
	DLinkList_Insert(list, (DLTNode*)&u2, DLinkList_Length(list));
	DLinkList_Insert(list, (DLTNode*)&u3, DLinkList_Length(list));
	DLinkList_Insert(list, (DLTNode*)&u4, DLinkList_Length(list));
	DLinkList_Insert(list, (DLTNode*)&u5, DLinkList_Length(list));
	DLinkList_Insert(list, (DLTNode*)&u6, DLinkList_Length(list));

	for (i = 0; i < DLinkList_Length(list); i++)
	{
		tmp = (User *)DLinkList_Get(list, i);
		if (tmp==NULL)
		{
			printf("获取元素失败\n");
			break;
		}
		printf("age=%d ; name=%s \n", tmp->age, tmp->name);
	}

	DLinkList_Reset(list); //重置链表游标
	DLinkList_Next(list);//链表游标下移

	tmp =(User*) DLinkList_Current(list);
	printf("age=%d ; name=%s \n", tmp->age, tmp->name);

	DLinkList_Pre(list); //链表游标上移
	tmp = (User*)DLinkList_Current(list);
	printf("age=%d ; name=%s \n", tmp->age, tmp->name);

	printf("list count=%d \n", DLinkList_Length(list));

	DLinkList_Destroy(list);

	system("pause");
}

输出：
在这里插入图片描述

haixin-561
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法(C语言)------双向链表
weixin_44912879的博客
03-24 177
双向链表 一、定义 二、代码 #ifndef __DULINKEDLIST_H #define __DULINKEDLIST_H #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_SIZE 30 #define OK 1 #define ERROR 0 typedef int states; typedef struct { int id; char name[
【C语言数据结构】双链表详解（带头双向循环链表）
dhgiuyawhiudwqha的博客
04-05 2210
我们把要存放的数据类型重命名，接着定义一个含有三个参数的结构体，分别用于存放数据，指向下一节点与指向上一节点。}ListNode;我们在进行插入操作以及建立头节点的时候都需要进行申请节点的操作，因此我们可以把它分装成一个函数。不管是进行插入还是删除操作，我们都需要传入哨兵位头节点，我们可以把哨兵位头节点的创立也分装成一个函数。然后剩下的的就是链表的通用功能：增删查改，pos位置的插入与删除以及链表的销毁。//双链表申请一个新节点// 创建返回链表的头结点// 双向链表打印。
数据结构—C语言实现双向链表
最新发布
Mike的博客
05-01 1108
双向带头循环链表
c语言数据结构（双向链表）
weixin_39270987的博客
09-14 460
一、双向链表概述 双向链表和单向链表的区别之处在于，双向链表的不仅可以从头部向尾部遍历，也可以从尾部向头部遍历，它的基本结构如下： 双向链表的每一个元素都包含两个指针，其中一个指针指向链表的上一个节点，另外一个指针指向链表的下一个节点； 二、双向链表的基本操作 2.1、从链表尾部的插入节点 第一步：Node-C的指向下一个节点的指针指向Node-D； 第二步：Node-D的指向上一个节点的指针指向Node-C; 第三步：Node-D指向下一个节点的指针指向NULL，这点很重要，因为NULL
数据结构之双链表（c语言附完整代码)
m0_62795460的博客
11-04 2177
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。声明双链表typedef struct DNode //定义双链表结点类型 {//数据域 struct DNode * prior;//指向前驱结点 struct DNode * next;//指向后继结点 } DLinkNode;注意：本文章讨论的双链表是带头结点的双链表。
C语言---双向链表（详解）---数据结构
weixin_57535054的博客
02-07 7021
双向链表所需要头文件 首先重定义类型名 意义我前几篇讲过几次了，这里就不在赘述了，（顺序表，单链表的开头都有说明） 然后我们需要一个结构体 结构体包含 ： 存储数据的 a 指向一个节点的指针 next 指向上一个节点的指针 prve 双向链表实现的函数功能有 ：1.申请动态内存空间 2.初始化 3.双向链表的头，尾的插入与删除，在合法的任意位置进行插入和删除 4.释放链表，5.打印链表 1.申请动态内存空间 因为进行插入和初始化需要用到此函数 所以我们要先实现此功能 1.先申.
双向线性表链式存储.zip
08-06
在002--线性表链式存储这个文件中，可能包含了详细的代码示例，涵盖了上述各种操作的实现细节，这对于我们理解和掌握双向链表的链式存储非常有帮助。 双向链表在很多实际应用中都有广泛的应用，比如在文件系统、...
线性表链式存储--链表
10-09
在提供的压缩包文件"线性表链式存储"中，很可能包含了实现链表操作的C语言代码，如初始化链表、插入节点、删除节点、遍历链表等函数。 链表有多种变体，如单链表、双链表、循环链表等。单链表只包含一个指针域，而...
线性表链式存储
09-29
线性表是计算机科学中一种基础的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。在实际应用中，线性表的数据元素可以是整型、字符型或其他复杂的数据类型。线性表的链式存储是线性表的一种存储方式，与...
线性表链式存储.zip
03-27
线性表链式存储的操作包括： 1. 创建链表：初始化头节点，然后根据需要添加元素。 2. 插入元素：在指定位置插入新节点，需要更新前一个节点和后一个节点的指针。 3. 删除元素：找到待删除节点，修改其前一个节点的...
【数据结构】——链式存储结构之双向链表
维欣~fighting✔
04-12 2879
文章目录一、双向链表存储结构1、了解2、定义3、结构二、双链表的结构设计三、初始化四、插入操作1、开辟新结点pnewnode2、分析3、头插:将元素插入头结点之后3、尾插：将元素插入整个链表的尾部4、获取当前的链表长度：判断位置是否合理5、按位置插入（pos为插入位置）四、删除操作1、判空2、头删：删除头结点的下一个结点3、尾删：删除尾部结点4、按位置删除五、查询单链表 一、双向链表存储结构 1、...
DoubleLinkedListDemo.java
06-11
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。
线性表的链式存储结构：循环链表、双向链表
weixin_63210321的博客
05-12 547
循环链表 将单链表中终端结点的指针端由空指针改为指向头结点，就使整个单链表形成一个环，这种头尾相接的单链表成为单循环链表，简称循环链表。 这样的话，链表就相当于变成一个环，循环链表可以从任何一个结点出发，到链表的全部结点。 事实上，循环链表和单链表的主要差异就在于循环的判断条件上，原来是判断p->next是否为空，现在则是p->next 不等于头结点，则循环未结束。 双向链表 双向链表是在单链表的每个结点中，再设置一个指向其前驱结点的指针域。 所以在双向链表的中的结点都有两个指针
C语言实现双向链表（双向带头循环）
2301_76269963的博客
03-21 1098
C语言实现双链表(双向带头循环)
C语言数据结构之双向链表
Qurry的博客
09-21 1271
前面介绍了单链表，由于单链表遍历查找是单向性的，故引出了双向链表的概念，也叫双链表，既可以向前查找，也可以向后遍历。
[ 数据结构_C实现 ] 双向循环带头链表的简单实现
CSDN博客
03-22 3408
目录 1.双向循环带头链表的介绍。 2.双向循环带头链表的接口。 3.接口实现。 3.1创建新节点 3.2创建返回链表的头结点 3.3打印链表 3.4双向链表查找 3.5双向链表在pos的前面进行插入 3.5.1 头插 3.5.2 尾插 3.6双向链表删除pos位置的节点 3.6.1 尾删 3.6.2 头删 4.菜单 5.完整代码： 6.功能测试： 1.双向循环带头链表的介绍。 所谓双向循环带头链表可以分为以下3类来进行理解： 首先是双向：双向表示后一个节点可以找到
06.线性表(五)链式存储结构.循环链表与双向链表
嵌入式Developer_小J的天空
12-28 739
循环链表与双向链表 一、循环链表 1.循环链表：将单链表中终端结点的指针域由空指针改为指向头结点，就使整个单链表形成一个环，这种头尾相接的单链表称为单循环链表，简称循环链表。 升华笔记：如何判断循环链表和单链表？    循环链表和单链表的主要差异就在于循环的判断条件上，即p->next是否为空。如果最后一个结点的指指针域p->next为空则说明该链表为单链表;如果p->next等于
数据结构之双向链表C语言版
Cukor丘克的博客
10-06 167
数据结构之双向链表C语言版 文章目录数据结构之双向链表C语言版双向链表长什么样？双向链表的节点的结构体双向链表的链表再封装包含的头文件各个子函数的实现创建节点创建链表表头法插入数据表尾法插入数据指定位置插入数据顺序打印链表数据逆序打印链表数据表头法删除数据表尾法删除数据指定位置删除数据主函数测试 数据结构就是用来存放数据的，有很多种数据结构，这篇文章写的是双向链表，用C语言实现。学习数据结构的时候直接复制粘贴源代码是没什么用的。不知道数据结构内部的实现，等于没学。 双向链表长什么样？ 在了解一个数据结构之前
Java数据结构之线性结构-线性表-双向链式存储（双向链表）
jiu_yu的博客
08-08 151
双向链表结构 添加节点 删除节点 删除节点要注意判断待删除节点的下一个节点是否为空，因为他最终要指向待删除节点的前一个结点。尤其要注意数组空指针异常。 源代码 package linearSturcture; /** * 线性结构-线性表-双向链式存储（双向链表） * @author cx998 * */ public class BidirectionalLinkedStorage { private BidirectionalNode root;//根节点 private int .
算法与数据结构：3-线性表2.pdf
06-29
算法与数据结构：3-线性表2.pdf

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值