线性表-双向链表-C语言

最新推荐文章于 2024-09-16 14:17:58 发布
最新推荐文章于 2024-09-16 14:17:58 发布
阅读量102 收藏
点赞数
分类专栏： 数据结构-C语言实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46708000/article/details/117442055
版权

线性表-双向链表-C语言

基本概念

单链表的结点都只有一个指向下一个结点的指针
单链表的数据元素无法直接访问其前驱元素
逆序访问单链表中的元素是极其耗时的操作！

len = LinkList_Length(list);
for (i=len-1; len>=0; i++) //O(n)
{
LinkListNode *p = LinkList_Get(list, i); //O(n)
//访问数据元素p中的元素
//
}

双向链表的定义
在单链表的结点中增加一个指向其前驱的pre指针
在这里插入图片描述
双向链表拥有单链表的所有操作
创建链表
销毁链表
获取链表长度
清空链表
获取第pos个元素操作
插入元素到位置pos
删除位置pos处的元素

设计与实现

循环链表插入结点技术场景

插入操作异常处理
插入第一个元素异常处理 在0号位置处插入元素
在这里插入图片描述
在这里插入图片描述

循环链表删除结点技术场景

在这里插入图片描述

删除操作
异常处理（代码）
在这里插入图片描述

双向链表的新操作
获取当前游标指向的数据元素
将游标重置指向链表中的第一个数据元素
将游标移动指向到链表中的下一个数据元素
将游标移动指向到链表中的上一个数据元素
直接指定删除链表中的某个数据元素

DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node);
DLinkListNode* DLinkList_Reset(DLinkList* list);
DLinkListNode* DLinkList_Current(DLinkList* list);
DLinkListNode* DLinkList_Next(DLinkList* list);
DLinkListNode* DLinkList_Pre(DLinkList* list);

优点和缺点

优点：双向链表在单链表的基础上增加了指向前驱的指针
功能上双向链表可以完全取代单链表的使用
双向链表的Next，Pre和Current操作可以高效的遍历链表中的所有元素
缺点：代码复杂

#include <stdio.h>
#include <stdlib.h>
#include "dlinklist.h"

struct Value
{
	DLinkListNode node;
	int v;
};

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

	struct Value v1;
	struct Value v2;
	struct Value v3;
	struct Value v4;
	struct Value v5;
	v1.v = 1;
	v2.v = 2;
	v3.v = 3;
	v4.v = 4;
	v5.v = 5;

	DLinkList_Insert(list, (DLinkListNode*)&v1, 0);
	DLinkList_Insert(list, (DLinkListNode*)&v2, 0);
	DLinkList_Insert(list, (DLinkListNode*)&v3, 0);
	DLinkList_Insert(list, (DLinkListNode*)&v4, 0);
	DLinkList_Insert(list, (DLinkListNode*)&v5, 0);

	for (i = 0; i < DLinkList_Length(list); i++) {
		pv = (struct Value*)DLinkList_Get(list, i);
		printf("%d\n", pv->v);
	}

	printf("\n");

	DLinkList_Delete(list, DLinkList_Length(list) - 1);
	DLinkList_Delete(list, 0);

	for (i = 0; i < DLinkList_Length(list); i++) {
		pv = (struct Value*)DLinkList_Get(list, i);
		printf("%d\n", pv->v);
	}

	printf("\n");

	DLinkList_Reset(list);
	DLinkList_Next(list);

	pv = (struct Value*)DLinkList_Current(list);
	printf("%d\n", pv->v);

	printf("\n");

	DLinkList_DeleteNode(list, (DLinkListNode*)pv);

	pv = (struct Value*)DLinkList_Current(list);
	printf("%d\n", pv->v);

	printf("\n");

	DLinkList_Pre(list);

	pv = (struct Value*)DLinkList_Current(list);
	printf("%d\n", pv->v);

	printf("Length: %d\n", DLinkList_Length(list));

	DLinkList_Destroy(list);

	return 0;
}

//dlinklist.h
#ifndef _DLINKLIST_H_
#define _DLINKLIST_H_

typedef void DLinkList;
typedef struct _tag_DLinkListNode
{
	struct _tag_DLinkListNode* next;
	struct _tag_DLinkListNode* pre;
}DLinkListNode;

DLinkList* DLinkList_Create();

void DLinkList_Destroy(DLinkList* list);

void DLinkList_Clear(DLinkList* list);

int DLinkList_Length(DLinkList* list);

int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos);

DLinkListNode* DLinkList_Get(DLinkList* list, int pos);

DLinkListNode* DLinkList_Delete(DLinkList* list, int pos);

DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node);

DLinkListNode* DLinkList_Reset(DLinkList* list);

DLinkListNode* DLinkList_Current(DLinkList* list);

DLinkListNode* DLinkList_Next(DLinkList* list);

DLinkListNode* DLinkList_Pre(DLinkList* list);

#endif

#include <stdio.h>
#include <stdlib.h>
#include "dlinklist.h"

typedef struct _tag_DLinkList
{
	DLinkListNode header;
	DLinkList* slider;
	int length;
}TDLinkList;

DLinkList* DLinkList_Create()
{
	TDLinkList* ret = (TDLinkList *)malloc(sizeof(TDLinkList));
	if (ret != NULL) {
		ret->header.next = NULL;
		ret->header.pre = NULL;
		ret->length = 0;
		ret->slider = NULL;
	}

	return ret;
}

void DLinkList_Destroy(DLinkList* list)
{
	if (list == NULL) {
		free(list);
	}

}

void DLinkList_Clear(DLinkList* list)
{
	TDLinkList* slist = (TDLinkList*)list;

	if (slist != NULL) {
		slist->header.next = NULL;
		slist->header.pre = NULL;
		slist->length = 0;
		slist->slider = NULL;
	}
}

int DLinkList_Length(DLinkList* list)
{
	TDLinkList* slist = (TDLinkList*)list;
	int ret = -1;
	if (slist != NULL) {
		ret = slist->length;
	}
	return ret;
}

int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos)
{
	int ret = 0; 
	int i = 0;
	TDLinkList* slist = (TDLinkList*)list;

	if (list == NULL || node == NULL || pos < 0) {
		return -1;
	}

	DLinkListNode* current = (DLinkListNode*)slist;
	DLinkListNode* next = NULL; //需要增加next指针

	for (i = 0; (i < pos) && (current->next != NULL); i++) {
		current = current->next;
	}

	next = current->next;

	current->next = node;
	node->next = next;

	if (next != NULL) {
		next->pre = node;
	}
	node->pre = current;

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

	if (current == (DLinkListNode*)slist) {
		node->pre = NULL;
	}

	slist->length++;

	return ret;
}

DLinkListNode* DLinkList_Get(DLinkList* list, int pos)
{
	TDLinkList* slist = (TDLinkList*)list;
	int i = 0;
	DLinkListNode* ret = NULL;

	if ((slist != NULL) && (pos >= 0) && (pos < slist->length)) {
		DLinkListNode* current = (DLinkListNode*)slist;
		for (i = 0; (i < pos) && (current->next != NULL); i++) {
			current = current->next;
		}
		ret = current->next;
	}

	return ret;
}

DLinkListNode* DLinkList_Delete(DLinkList* list, int pos)
{
	TDLinkList* sList = (TDLinkList*)list;
	DLinkListNode* ret = NULL;
	int i = 0;
	if (sList == NULL || pos < 0)
	{
		return NULL;
	}

	DLinkListNode* current = (DLinkListNode*)sList;
	DLinkListNode* next = NULL; //需要增加next指针

	for (i = 0; i < pos; i++)
	{
		current = current->next;
	}

	ret = current->next;
	next = ret->next;

	current->next = next;

	if (next != NULL) {
		next->pre = current;

		if (current == (DLinkListNode*)sList) {
			next->pre = NULL;
		}
	}

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

	sList->length--;

	return ret;
}

DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node)
{
	TDLinkList* sList = (TDLinkList*)list;
	DLinkListNode* ret = NULL;
	int i = 0;

	if (sList != NULL) {
		DLinkListNode *current = (DLinkListNode *)sList;

		for (i = 0; i < sList->length; i++) {
			if (current->next == node) {
				ret = current->next;
				break;
			}

			current = current->next;
		}

		if (ret != NULL) {
			DLinkList_Delete(sList, i);
		}
	}

	return ret;
}

DLinkListNode* DLinkList_Reset(DLinkList* list)
{
	TDLinkList* sList = (TDLinkList*)list;
	DLinkListNode* ret = NULL;

	if (sList != NULL)
	{
		sList->slider = sList->header.next;
		ret = sList->slider;
	}

	return ret;
}

//获取当前游标指向的数据元素
DLinkListNode* DLinkList_Current(DLinkList* list)
{
	TDLinkList* sList = (TDLinkList*)list;
	DLinkListNode* ret = NULL;

	if (sList != NULL)
	{
		ret = sList->slider;
	}

	return ret;
}

//将游标移动指向到链表中的下一个数据元素
DLinkListNode* DLinkList_Next(DLinkList* list)
{
	TDLinkList* sList = (TDLinkList*)list;
	DLinkListNode* ret = NULL;

	if ((sList != NULL) && (sList->slider != NULL))
	{
		ret = sList->slider;
		sList->slider = ret->next;
	}

	return ret;
}

//将游标移动指向到链表中的上一个数据元素
DLinkListNode* DLinkList_Pre(DLinkList* list)
{
	TDLinkList* slist = (TDLinkList*)list;
	DLinkListNode* ret = NULL;

	if ((slist != NULL) && (slist->slider != NULL)) {
		ret = slist->slider;
		slist->slider = ret->pre;
	}

	return ret;
}
执手听落花
关注
专栏目录
数据结构（五） -- C语言版 -- 线性表的链式存储 - 双向链表、双向循环链表
青椒*^_^*凤爪爪的博客
03-13 8921
本文中没有涉及到很多的相关理论知识，也没有做深入的了解，所以，您如果是想要系统的学习、想要多学习关于理论的知识等，那么本文可能并不合适您。 本文中所有设计的代码均通过测试，并且在功能性方面均实现应有的功能。 设计的代码并非全部公开，部分无关紧要代码并没有贴出来。 如果你也对此感兴趣、也想测试源码的话，可以私聊我，非常欢迎一起探讨学习。 由于时间、水平、精力有限，文中难免会出现不准确、甚至错误的地方，也很欢迎大佬看见的话批评指正。 嘻嘻。。。。 。。。。。。。。收！
数据结构知识点总结04-(第二章.线性表)-双向链表定义、循环单链表、、循环双向链表、静态链表、顺序表与链表的比较
随风浪仔的专栏
02-26 468
数据结构知识点总结-线性表（3）-双向链表定义、循环单链表、、循环双向链表、静态链表、顺序表与链表的比较
C语言实现双向链表
Frank's CSDN Blog
02-12 5736
使用双向链表实现，双向链表具有的单向链表所不具备的优势，那就是可以双向遍历，这对增、删操作的效率都有显著的提高。而弊端则是造成空间效率的下降，即需要额外的指针来维持双向链表之间的连接关系。链表的实现中，我们默认采用了两个哨兵节点，该两节点标识了整个链表的头部和尾部，但其数据域不存储具体数据。
C 双向链表
weixin_33748818的博客
09-13 160
单链表的结点都只有一个指向下一个结点的指针 单链表的数据元素无法直接访问其前驱元素 逆序访问单链表中的元素是极其耗时的操作！ len = LinkList_Length(list); for (i=len-1; len&gt;=0; i++) //O(n) { LinkListNode *p = LinkList_Get(list, i); //O(n)...
C_双向链表
PepDokHa的博客
01-19 596
C语言—数据结构 实现带头双向循环链表
C语言双向链表
m0_55792911的博客
01-30 878
#include<stdio.h> #include<stdlib.h> #include<assert.h> //双向链表一般也是无头式数组链表，且采用再封装 typedef struct NODE{ //创建节点的结构的模板 int data; struct NODE *front; struct NODE *tail; }NODE ,*LPNODE; LPNODE createN.
C语言数据结构之双向链表
Qurry的博客
09-21 1382
前面介绍了单链表，由于单链表遍历查找是单向性的，故引出了双向链表的概念，也叫双链表，既可以向前查找，也可以向后遍历。
数据结构与算法基础课程 C语言C++程序语言设计教程 2_3线性表-链表 共43页.pptx
07-20
### 数据结构与算法基础课程——线性表-链表 #### 课程背景及目标 ...此外，链表的操作方法不仅限于单链表，还可以扩展到更复杂的链表类型，如双向链表和循环链表，从而满足更多样化的数据处理需求。
数据结构-线性表的链式存储--双向链表（初始化，尾插法创建，打印，插入，删除）
qq_62630363的博客
11-19 495
双向链表的相关操作
数据结构【线性表-链表】
huajian225的博客
06-06 744
链表的概念，初始化链表、插入、删除节点、合并链表、计算链表的长度
【C语言数据结构】之双向链表
最新发布
weixin_61276540的博客
09-16 1001
本文主要介绍C语言双向链表的增删改查。我们主要手搓代码，以及容易出现的问题的强调。最主要我们还是要敲代码，而不是看和听。
双向链表(数据结构)(C语言)
outdated_socks的博客
05-08 4872
双向链表的结构体定义、双向链表的初始化、关于无头单向非循环链表无需初始化函数，顺序表、带头双向循环链表需要的思考、双向链表在pos位置之前插入x、双向链表的打印 双链表删除pos位置的结点、双向链表的尾插、关于单链表的尾插需要用到二级指针，双向链表不需要用到二级指针的思考、双向链表的判空、双向链表的尾删、双向链表的头插、双向链表的头删、双向链表查找值为x的结点、双向链表的销毁、双向链表的修改、双向链表删除值为x的结点、双向链表计算结点总数(不计phead)、双向链表获取第
c：双向链表
weixin_44280367的博客
01-07 174
双向链表 时间限制: 1 Sec 内存限制: 128 MB 题目描述 构建一个双向链表并进行删除和插入操作，按要求输出。 输入 输入： 第一行输入元素个数M 第二行输入M个元素 第三行输入删除位置 第四行输入插入位置和插入元素 第五行输入输出时的起始位置 输出 按要求的起始位置输出链表 样例输入 Copy 8 1 2 3 4 5 6 7 8 6 6 6 5 样例输出 Copy 5 6 7 8 1...
C双向链表
This is bill的专属博客
07-12 1141
写了一个很简单的双向链表
C -- 双向链表
GuoningningPro的博客
12-12 248
C双向链表 第一步：建立抽象类型，定义接口 //实现双向链表 #ifndef _LIST_H #define _LIST_H #include <stdbool.h> #define SIZE 20 //抽象一个数据类型 typedef struct _item { char title[20]; double value; }Item; //定义节点，每个结点包括指向上一个和...
双向链表（C语言）
17的博客
10-07 839
双向链表
C语言-双向链表
woshizuopie的博客
06-16 3099
目录 双链表的结构： 创建双向链表： 双向链表查找节点： 双向链表更改节点： 双向链表删除节点： 遍历双链表，并打印元素数据： 双向链表插入节点： 使用双向链表对数据进行“增删查改”的完整操作代码： 双向链表及其创建、双向链表基本操作 可以看出，双向链表中各节点包括： ① 指针域：指向当前节点的直接前驱（前一个）节点； ② 数据域：存储数据元素； ③ 指针域：指向当前节点的直接后继（下一个）节点。 ...
双向链表（c语言）
艾恩凝
10-14 217
什么是链表？链表的分类？ 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表应该在学习数据结构中最简单的一种了吧，其实在linux内核中链表也随处可见，今天就来重新温习一下链表，该文以双向链表结构讲解。 链表分类 其实链表有好多种，对于初学者来说，被搞的乱七八糟。下面以图解的方式呈现给大家： ​ 看上面的图 2 × 2 × 2 可以得到8种链表，比如非循环带头单向链表就是最简单的，也是学数据结构最开始学习的链表结构。 双向链表 ..
C语言实现双向链表与线性表特性详解
双向链表是一种数据结构，它在C语言中有着重要的应用。在计算机科学中，线性表是一种基本的数据结构，它由一组具有相同特性的数据元素组成，这些元素按照特定的顺序排列。线性表有多种表示方法，其中链式表示是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值