图解双向链表

最新推荐文章于 2023-07-18 22:51:16 发布
最新推荐文章于 2023-07-18 22:51:16 发布
阅读量600 收藏 3
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WUZHU2017/article/details/108530324
版权

 插入

 

 

 

删除

 

 

 

#ifndef _MY_DLINKLIST_H
#define _MY_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);

//插入元素到pos位置
int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos);

//获取pos位置元素
DLinkListNode* DLinkList_Get(DLinkList* list, int pos);

//删除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 <string.h>

#include "knDebug.h"
#include "knDlinklist.h"

//定义带有头节点的双向链表
typedef struct _tag_DLinkList
{
	DLinkListNode header;	//头节点
	DLinkListNode *slider;	//游标
	int length;				//链表长度
}TDLinkList;


//创建双向链表
DLinkList* DLinkList_Create()
{
	TDLinkList *ret = (TDLinkList *)malloc(sizeof(TDLinkList));
	if (ret != NULL){
		ret->length = 0;
		ret->header.next = NULL;
		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->length = 0;
		sList->header.next = NULL;
		sList->header.pre = NULL;
		sList->slider = NULL;
	}
}

//获取双向链表长度
int DLinkList_Length(DLinkList* list)
{
	TDLinkList *sList = (TDLinkList *)list;
	int ret = -1;
	if (sList != NULL){
		ret = sList->length;
	}
	return ret;
}

//向pos位置插入元素到pos位置
int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos)
{
	int ret = 0, i = 0;
	TDLinkList *sList = (TDLinkList*)list;
	if (list == NULL || node == NULL || pos < 0){
		return -1;
	}
	//辅助指针变量
	DLinkListNode *current = (DLinkListNode*)sList;
	DLinkListNode *next = NULL;
	for (i = 0; i < pos; i++){
		current = current->next;
	}
	next = current->next;

	//步骤1-2
	node->next = next;      
	current->next = node;

	//步骤3-4
	if (next != NULL){	//尾部插入时,next为NULL
		next->pre = node;
	}
	node->pre = current;

	if (sList->length == 0){
		sList->slider = node;//在0位置插入时，游标始终指向第一个元素
	}
	//若在0位置插入,需要特殊处理 新来节点next前pre指向NULL
	if (current == (DLinkListNode*)sList); {
		node->pre = NULL; //头插法 node->pre为NULL
	}
	sList->length++;
	return ret;
}

//获取pos位置元素
DLinkListNode* DLinkList_Get(DLinkList* list, int pos)
{
	TDLinkList *sList = (TDLinkList*)list;
	DLinkListNode *ret = NULL;
	int i = 0;
	if ((sList != NULL) && (0 <= pos) && (pos < sList->length)){
		DLinkListNode* current = (DLinkListNode*)sList;
		for (i = 0; i < pos; i++){
			current = current->next;
		}
		ret = current->next;
	}
	return ret;	
}

//删除pos位置元素
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;
	for (i = 0; i < pos; i++){
		current = current->next;
	}
	ret = current->next;//辅助指针变量 缓存要删除的元素
	next = ret->next;   //辅助指针变量

	//步骤1
	current->next = next;
	//步骤2
	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;
}

 

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "knDlinklist.h"
#include "knDebug.h"

//业务节点

struct Value{
	DLinkListNode node;	//必须放在业务节点的首位置
	int v;				//业务数据
};

void  test()
{
	int i = 0;
	DLinkList *list = DLinkList_Create();
	struct Value *pv = NULL;
	struct Value v1, v2, v3, v4, v5;
	v1.v = 1;  v2.v = 2;  v3.v = 3;
	v4.v = 4;  v5.v = 5;

	// 第一次插入既是0位置插入也是尾部插入
	DLinkList_Insert(list, (DLinkListNode*)&v1, DLinkList_Length(list));
	DLinkList_Insert(list, (DLinkListNode*)&v2, DLinkList_Length(list));
	DLinkList_Insert(list, (DLinkListNode*)&v3, DLinkList_Length(list));
	DLinkList_Insert(list, (DLinkListNode*)&v4, DLinkList_Length(list));
	DLinkList_Insert(list, (DLinkListNode*)&v5, DLinkList_Length(list));

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

	pv = DLinkList_Delete(list, DLinkList_Length(list) - 1);
	printf("删除尾部元素：%d\n", pv->v);

	pv = DLinkList_Delete(list, 0);
	printf("删除首部元素：%d\n", pv->v);

	printf("------使用游标遍历------\n");
	for (i = 0; i < DLinkList_Length(list); i++){
		pv = (struct Value*)DLinkList_Next(list);
		printf("%d\n", pv->v);
	}
	printf("\n");

	pv = DLinkList_Reset(list);
	printf("重置游标：%d\n", pv->v);

	pv = DLinkList_Next(list);
	printf("游标下移前,游标指向元素: %d\n", pv->v);
	
	pv = (struct Value*)DLinkList_Current(list);
	printf("游标下移后,游标指向元素: %d\n", pv->v);

	pv = DLinkList_DeleteNode(list, (DLinkListNode*)pv);
	printf("删除游标指向元素,函数返回删除的元素:%d\n", pv->v);

	pv = DLinkList_Pre(list);
	printf("游标前移 前，游标指向元素: %d\n", pv->v);

	pv = (struct Value*)DLinkList_Current(list);
	printf("游标前移 后，游标指向元素: %d\n", pv->v);

	printf("链表长度Length: %d\n", DLinkList_Length(list));

	DLinkList_Destroy(list);
}

int main()
{
	test();
	system("pause");
}

 

 

 

 

 

 

 

 

吾竹清风
关注
专栏目录
图解链表 —— JAVA 中的双向链表
AlinaQ05的博客
05-22 5065
1. 双向链表 前面提到了单向链表，单链表的特点是只能从前向后遍历，但是如果我们已知一个节点在链表靠后的位置，这时如果使用单链表效率就会很低，因此引入了双向链表就可以快速的找到靠后的节点。双向链表与单向链表的区别就是它不仅有后继节点，还有前驱节点。这样就既存储了下一个节点的地址，也存储了前一个节点的地址。 2. 双向链表的定义 节点类： class DoubleNode { // 指向前驱节点 DoubleNode prev; // 具体存储的数据
数据结构《LinkeList 双向链表》
m0_66483195的博客
11-13 1143
LinkeList 的模拟和使用
双向链表详细分析（很有用）
04-09
详细分析双向链表 1、双向链表（Double Linked List） 2、双向链表的结点结构和形式描述
图文并茂用地址分析双向链表
nicehuai
09-23 534
图文并茂用地址分析双向链表 (2012-03-26 18:28:35) 转载▼ 标签： 双向链表 it 分类：unix和linux 网上很多对双向链表解释的文章都是用这个结构：   它们的连接情况是这样的：   相当的不直观，今天我要从详细的地址出发来解释双向链表的原理。   现定义一个结构体如下： structstude
数据结构 —— 双向链表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-08 6976
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。博主将会用代码结合大量图解，对数据结构进行深度剖析。
图解Java数据结构之双向链表
。。。
08-08 3648
上一篇文章说到了单链表，也通过案例具体实现了一下，但是单链表的缺点也显而易见。 单向链表查找的方向只能是一个方向 单向链表不能自我删除，需要靠辅助节点 而双向链表则能够很轻松地实现上面的功能。 何为双向链表 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 增删改查思路...
图解双向链表(含完整C代码)+剖析STL顺序容器List(C++)
weixin_54186646的博客
03-19 4216
双向链表动图解析，对比双向链表在STL中的操作，内含完整代码
【超详细图解】菜鸡如何理解双向链表的python代码实现
12-20
双向链表是一种基础的数据结构，尤其在理解和实现算法时至关重要。相比于单链表，双向链表的特点在于每个节点不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针，这使得在链表中的移动更加灵活，可以从...
双向链表API及C语言实现
03-29
所有API实现均为C语言版本，在我的文章《【数据结构】双向链表的API及C语言实现》中有所有API说明和异常分析的图解。另外还有线性表顺序存储、单链表、循环链表的C语言实现，文章及代码资源均已上传，可在专栏《数据...
LinkedList双向链表源码分析（附详细图解！！）
最新发布
A_diligent_man的博客
07-18 1193
本文章分析LinkedList源码。
双向链表的操作
10-02
双向链表的操作问题 Time Limit: 1000MS Memory Limit: 10000KB Submissions: 111 Accepted: 41 Description 建立一个长度为n的带头结点的双向链表，使得该链表中的数据元素递增有序排列。（必须使用双向链表完成，数据类型为整型。） Input 第一行：双向表的长度； 第二行：链表中的数据元素。 Output 输出双向链表中的数据元素的值。 Sample Input 10 2 4 6 3 5 8 10 21 12 9 Sample Output 2 3 4 5 6 8 9 10 12 21
数据结构图文解析之：数组、单链表、双链表介绍及C++模板实现
weixin_33713707的博客
02-01 409
0. 数据结构图文解析系列 数据结构系列文章 数据结构图文解析之：数组、单链表、双链表介绍及C++模板实现 数据结构图文解析之：栈的简介及C++模板实现 数据结构图文解析之：队列详解与C++模板实现 数据结构图文解析之：树的简介及二叉排序树C++模板实现. 数据结构图文解析之：AVL树详解及C++模板实现 数据结构图文解析之：二叉堆详解及C++模板实现 1....
链表图解（双向、循环链表+链表增删）
qq_52189899的博客
11-26 3071
补充介绍双向链表和循环链表，并用具体图像讲述了链表的增加和删除。
图解双向链表（Java）
qq_45964209的博客
07-24 561
这里写自定义目录标题前言基础要点基本结构添加节点删除节点 前言 双向链表中比较难懂的地方是节点间的引用关系。 本文主要分析双向链表添加和删除，使用图片来解释引用间的指向关系，希望能帮助各位理清思路。 基础要点 （1）双向链表既可从头找到尾，也可以从尾找到头。 （2）双向链表中每个节点自身存储有数据和俩个引用，一个指向前面的节点（prev），一个指向后面的节点（next）。 基本结构 （1）first和last分别作为链表的头部和尾部。 （2）通过对象引用找到对方。​ （3）Node类主要用来将数据包起来成
双向循环链表(图文讲解)
deroy
02-25 2616
文章目录双向循环链表结构体初始化函数添加数据头插删除数据显示函数示例程序一(简易版本)：运行结果：示例程序二 双向循环链表 结构体 typedef struct node { int data; struct node* pre; //指向前驱 struct node* next; //指向后继 }NODE; 双链表是链表的一种，由节点组成，每个数据结点中都有两个指针，分别指向直接后继和直接前驱。 初始化函数 NODE * Init() { NODE* head = (NODE*)mall
Java数据结构之图解双向链表
李思成的博客
06-07 784
双向链表（Doubly linked list） 什么是双向链表？ 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 双向链表与单向链表的主要区别： 查找方向： 单向链表的查找方向只能是一个方向，而双向链表可以向前或者向后查找。 删除：单向链表的删除需要借助辅助指针，先找到要删除节点的前驱，然后进行删除。 ...
C语言初阶数据结构（三）双向链表(保姆级别详细图解，轻松上手，通俗易懂)
qq_54469537的博客
04-19 2560
保姆级别C语言双向链表
双向链表示意图_图文详解双向链表原理
weixin_35719775的博客
01-14 1323
双向链表的主要优点是对于任意给的结点，都可以很轻易的获取其前结点和后结点，其主要缺点是每个结点需要保存next和prev两个属性，因此需要更多的空间开销，同时结点的插入与删除操作也将更加耗时，因为需要操作更多的指向操作。双向链表单个节点结构：双向链表节点双向链表的数据结构：双向链表数据结构双向链表的插入操作插入数据到链表尾部链表尾部插入数据插入数据到链表中间链表中部插入数据双向列表删除操作删除链表...
java 双向链表反转加图解
05-25
首先，让我们先了解一下什么是双向链表。在双向链表中，每个节点都有两个指针，一个指向前一个节点，一个指向后一个节点。这样，在链表中，我们可以从任何一个节点开始，向前或向后遍历整个链表。 接下来，我们来看...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值