双向链表实现简单的增删查改

最新推荐文章于 2023-12-14 20:37:52 发布
最新推荐文章于 2023-12-14 20:37:52 发布
阅读量1.6k 收藏 10
点赞数 12
分类专栏： 数据结构 文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_72868952/article/details/128423934
版权

前言：上次分享了单向链表的增删查改，这次要介绍双向链表的增删查改，其实双向链表也有多种，这次主要介绍结构最复杂但是实现起功能反而最简单的带头双向循环链表，希望我的分享对各位有些许帮助。学习这篇文章的内容最好有这篇文章的基础

目录

一：双向链表的简单介绍

(1) 概述

(2) 图示 (带头双向循环链表)

二：用带头双向循环链表实现简单的增删查改

(1) 大致框架

(2) 四大基本功能函数的实现

1. 创建哨兵位头节点

2. 创建新节点

3. 打印链表

4. 销毁链表

(3) 尾插尾删的实现

1. 尾插

2. 尾删

(3) 头插头删的实现

1. 头插

2. 头删

(4) 特定位置的插入与删除

1. 特定位置的寻找

2. 特定位置的插入

3. 特定位置的删除

三：完整代码及测试样例的展示

(1) Test.c

(2) List.h

(3) List.c

(4) 测试样例的展示

一：双向链表的简单介绍

(1) 概述

双向链表的种类有多种——不带头，带头，循环，非循环等等,这里我们主要介绍最复杂的带头双向循环链表：结构最复杂，有一个存储无效数据的哨兵位头节点，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向 循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们函数功能的实现可以很好地体现。

而双向链表与单向链表最本质的区别就是: 单向链表只有一个指针域,而双向链表有两个指针域,所以双向链表可以灵活的找到一个节点的左右节点,使得相对于单向链表而言有很大的优势。

(2) 图示 (带头双向循环链表)

二：用带头双向循环链表实现简单的增删查改

(1) 大致框架

 Test.c——用于测试接口函数的功能

#define _CRT_SECURE_NO_WARNINGS
#include "List.h"
void Test1()//测试尾插尾删
{

}
void Test2()//测试头插头删
{

}
void Test3()//测试特定位置的插入与删除
{

}
int main()
{
	Test1();//测试尾插尾删

	//Test2();//测试头插头删

	//Test3();//测试特定位置的插入与删除
	return 0;
}

List.h——用于各种定义

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//将int重定义为LTDataType,方便链表数据类型的更改(eg:int->double)
typedef int LTDataType;

//定义一个带头双向循环链表
typedef struct ListNode
{
	LTDataType data;//数据域
	struct ListNode* prev;//可以链接前一个节点的指针域
	struct ListNode* next;//可以链接后一个节点的指针域
} LTNode;

LTNode* ListInit();//创建哨兵位头节点
void ListPrint(LTNode* phead);//打印
LTNode* BuyListNode(LTDataType x);//创建新节点
void ListDestroy(LTNode* phead);//销毁链表

void ListPushBack(LTNode* phead, LTDataType x);//尾插
void ListPopBack(LTNode* phead);//尾删
void ListPushFront(LTNode* phead, LTDataType x);//头插
void ListPopFront(LTNode* phead);//头删

LTNode* ListNodeFind(LTNode* phead, LTDataType x);//找到链表中数据为x的第一个节点
void ListInsertNode(LTNode* pos, LTDataType x);//在pos节点前插入节点
void ListEraseNode(LTNode* pos);//删除pos节点

List.c——用于接口函数功能的实现

#define _CRT_SECURE_NO_WARNINGS
#include "List.h"

LTNode* ListInit()//创建哨兵位头节点
{

}

void ListPrint(LTNode* phead)//打印
{

}

LTNode* BuyListNode(LTDataType x)//创建新节点
{

}

void ListPushBack(LTNode* phead, LTDataType x)//尾插
{

}

void ListPopBack(LTNode* phead)//尾删
{

}

void ListPushFront(LTNode* phead, LTDataType x)//头插
{

}

void ListPopFront(LTNode* phead)//头删
{

}

LTNode* ListNodeFind(LTNode* phead, LTDataType x)//找到链表中数据为x的第一个节点
{

}

void ListInsertNode(LTNode* pos, LTDataType x)//在pos节点前插入节点
{

}

void ListEraseNode(LTNode* pos)//删除pos节点
{

}

void ListDestroy(LTNode* phead)//销毁链表
{

}

(2) 四大基本功能函数的实现

1. 创建哨兵位头节点

对于带头双向循环链表而言，哨兵位头节点起到了至关重要的作用，所以实现带头双向循环链表的第一步就是创建一个哨兵位头节点：

LTNode* ListInit()//创建哨兵位头节点
{
	LTNode* tmp = (LTNode*)malloc(sizeof(LTNode));
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	LTNode* phead = tmp;
	phead->next = phead;
	phead->prev = phead;
	return phead;//返回开辟的头节点
}

带头双向循环链表中头节点的实际结构：

2. 创建新节点

从之前分享的单链表增删查改的知识也可以很清楚的知道，在插入节点之前要先创建一个新节点,所以为了方便创建节点，直接分装在一个函数中实现即可：

LTNode* BuyListNode(LTDataType x)//创建新节点
{
	LTNode* tmp = (LTNode*)malloc(sizeof(LTNode));
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	LTNode* newnode = tmp;
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->data = x;//数据域为新节点的有效数据x
	return newnode;
}

3. 打印链表

跟单链表思路相似，遍历链表即可，不同的是二者的终止条件不同，由于这是循环链表，所以链表的终点不是NULL：

void ListPrint(LTNode* phead)//打印链表
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)//带头双向循环链表遍历一遍后会回到哨兵位头节点
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

4. 销毁链表

与打印的思路相同，遍历链表的过程中不断释放节点，回到头节点即可，这里需要特别注意的是：哨兵位头节点也是动态开辟出来的，所以也要进行释放并置空，而为了维持函数接口传递参数的一致性，该函数接口传递的是表示哨兵位头节点的一级指针，此时形参只是实参的一份临时拷贝，在函数内部改变无法引起其变化，所以哨兵位头节点的置空要在哨兵位头节点所在的作用域函数内实现。

void ListDestroy(LTNode* phead)//销毁链表————遍历即可
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur->next != phead)
	{
		LTNode* curNext = cur->next;
		free(cur);
		cur = curNext;
		phead->next = cur;
		cur->prev = phead;
	}
	free(phead);
}

(3) 尾插尾删的实现

1. 尾插

void ListPushBack(LTNode* phead, LTDataType x)//尾插
{
	assert(phead);
	//1.常规思路———利用结构的特殊，直接形成链接关系即可
	LTNode* newnode = BuyListNode(x);
	LTNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	phead->prev = newnode;
	newnode->next = phead;

	//2.调用函数ListInsertNode,简化尾插

}

2. 尾删

void ListPopBack(LTNode* phead)//尾删
{
	assert(phead);
	assert(phead->next != phead);
	//1.常规思路————记录尾节点的前一个节点，把前一个结点当作新的尾节点，释放旧的尾节点
	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;
	phead->prev = tailPrev;
	tailPrev->next = phead;
	free(tail);
	tail = NULL;

	//2.调用函数ListEraseNode,简化尾删

}

(3) 头插头删的实现

1. 头插

void ListPushFront(LTNode* phead,LTDataType x)//头插
{
	assert(phead);
	//1.常规思路————要知道链表真正的起点是哨兵位头节点的后一个节点
	LTNode* newnode = BuyListNode(x);
	LTNode* next = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = next;
	next->prev = newnode;

	//2.调用函数ListInsertNode,简化尾删

}

2. 头删

void ListPopFront(LTNode* phead)//头删
{
	assert(phead);
	assert(phead->next != phead);//删除前一定要判空,即不能删除哨兵位头节点
	//1.常规思路
	LTNode* cur = phead->next;
	LTNode* next = phead->next->next;
	free(cur);
	phead->next = next;
	next->prev = phead;

	//2.调用函数ListEraseNode,简化头删	
}

(4) 特定位置的插入与删除

1. 特定位置的寻找

LTNode* ListNodeFind(LTNode* phead, LTDataType x)//找到链表中数据为x的第一个节点并返回
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur->next != phead)//遍历寻找
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

2. 特定位置的插入

//在pos节点前插入节点,pos节点是调用ListNodeFind函数得到的
void ListInsertNode(LTNode* pos, LTDataType x)
{
	LTNode* newnode = BuyListNode(x);//得到一个新节点
    //简单的链接过程
	LTNode* posPrev = pos->prev;
	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

3. 特定位置的删除

void ListEraseNode(LTNode* pos)//删除pos节点
{
//删除pos节点需要知道pos节点的前一个节点与后一个节点，这样才能在删除后重新形成链接关系
	LTNode* posPrev = pos->prev;
	LTNode* posNext = pos->next;
	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}

注意：对于带头双向循环链表而言，这三个接口函数的实现很重要，其实只要掌握了这三个解控函数，就可以很快的构建起一个带头双向循环链表，因为插入与删除的相关接口函数直接调用这三个函数就能够实现：

//复用两个接口函数实现这些相关函数最重要的一点是真正理解带头双向循环链表的结构(上面那张图很重要)
void ListPushBack(LTNode* phead, LTDataType x)//尾插
{
	assert(phead);
	//1.常规思路
	
	//2.调用函数ListInsertNode,简化尾插
	ListInsertNode(phead, x);//在哨兵位头节点前面插入就可以实现尾插
}

void ListPopBack(LTNode* phead)//尾删
{
	assert(phead);
	assert(phead->next != phead);
	//1.常规思路
	
	//2.调用函数ListEraseNode,简化尾删
	ListEraseNode(phead->prev);//删除哨兵位头节点的前一个节点可以实现尾删
}

void ListPushFront(LTNode* phead, LTDataType x)//头插
{
	assert(phead);
	//1.常规思路
	
	//2.调用函数ListInsertNode,简化尾删
	ListInsertNode(phead->next, x);//在哨兵位头节点后面插入就可以实现头插
}

void ListPopFront(LTNode* phead)//头删
{
	assert(phead);
	assert(phead->next != phead);
	//1.常规思路
	
	//2.调用函数ListEraseNode,简化头删
	ListEraseNode(phead->next);//删除哨兵位头节点的后一个节点可以实现尾删
}

三：完整代码及测试样例的展示

(1) Test.c

#define _CRT_SECURE_NO_WARNINGS
#include "List.h"

void Test1()//测试尾插尾删
{
	LTNode* phead = ListInit();//哨兵位头节点

	ListPushBack(phead, 1);
	ListPushBack(phead, 2);
	ListPushBack(phead, 3);
	ListPushBack(phead, 4);
	ListPushBack(phead, 5);
	ListPrint(phead);

	ListPopBack(phead);
	ListPopBack(phead);
	ListPopBack(phead);
	ListPrint(phead);

	ListDestroy(phead);
	phead = NULL;
}

void Test2()//测试头插头删
{
	LTNode* phead = ListInit();//哨兵位头节点

	ListPushFront(phead, 1);
	ListPushFront(phead, 2);
	ListPushFront(phead, 3);
	ListPushFront(phead, 4);
	ListPushFront(phead, 5);
	ListPrint(phead);

	ListPopFront(phead);
	ListPopFront(phead);
	ListPopFront(phead);
	ListPrint(phead);

	ListDestroy(phead);
	phead = NULL;
}

void Test3()//测试特定位置的插入与删除
{
	LTNode* phead = ListInit();//哨兵位头节点
	ListPushBack(phead, 1);
	ListPushBack(phead, 2);
	ListPushFront(phead, 3);
	ListPushFront(phead, 4);
	ListPushFront(phead, 5);
	ListPrint(phead);

	LTNode* pos = ListNodeFind(phead, 1);
	if (pos)
	{
		ListInsertNode(pos, 6);
	}
	ListPrint(phead);
	pos = ListNodeFind(phead, 3);
	if (pos)
	{
		ListInsertNode(pos, 7);
	}
	ListPrint(phead);

	pos = ListNodeFind(phead, 5);
	if (pos)
	{
		ListEraseNode(pos);
	}
	ListPrint(phead);
	pos = ListNodeFind(phead, 4);
	if (pos)
	{
		ListEraseNode(pos);
	}
	ListPrint(phead);

	ListDestroy(phead);
	phead = NULL;
}

int main()
{
	//Test1();//测试尾插尾删

	//Test2();//测试头插头删

	Test3();//测试特定位置的插入与删除
	return 0;
}

(2) List.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//将int重定义为LTDataType,方便链表数据类型的更改(eg:int->double)
typedef int LTDataType;

//定义一个带头双向循环链表
typedef struct ListNode
{
	LTDataType data;//数据域
	struct ListNode* prev;//可以链接前一个节点的指针域
	struct ListNode* next;//可以链接后一个节点的指针域
} LTNode;

LTNode* ListInit();//创建哨兵位头节点
void ListPrint(LTNode* phead);//打印
LTNode* BuyListNode(LTDataType x);//创建新节点
void ListDestroy(LTNode* phead);//销毁链表

void ListPushBack(LTNode* phead, LTDataType x);//尾插
void ListPopBack(LTNode* phead);//尾删
void ListPushFront(LTNode* phead, LTDataType x);//头插
void ListPopFront(LTNode* phead);//头删

LTNode* ListNodeFind(LTNode* phead, LTDataType x);//找到链表中数据为x的第一个节点
void ListInsertNode(LTNode* pos, LTDataType x);//在pos节点前插入节点
void ListEraseNode(LTNode* pos);//删除pos节点

(3) List.c

#define _CRT_SECURE_NO_WARNINGS
#include "List.h"

LTNode* ListInit()//1.创建哨兵位头节点
{
	LTNode* tmp = (LTNode*)malloc(sizeof(LTNode));
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	LTNode* phead = tmp;
	phead->next = phead;
	phead->prev = phead;
	return phead;//返回开辟的头节点
}

LTNode* BuyListNode(LTDataType x)//2.创建新节点
{
	LTNode* tmp = (LTNode*)malloc(sizeof(LTNode));
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	LTNode* newnode = tmp;
	newnode->next = NULL;
	newnode->prev = NULL;
	newnode->data = x;//数据域为新节点的有效数据x
	return newnode;
}

void ListPrint(LTNode* phead)//3.打印链表
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)//带头双向循环链表遍历一遍后会回到哨兵位头节点
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

void ListPushBack(LTNode* phead, LTDataType x)//4.尾插
{
	assert(phead);
	//1.常规思路
	LTNode* newnode = BuyListNode(x);
	LTNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	phead->prev = newnode;
	newnode->next = phead;

	//2.调用函数ListInsertNode,简化尾插
	//ListInsertNode(phead, x);//在哨兵位头节点前面插入就可以实现尾插
}

void ListPopBack(LTNode* phead)//5.尾删
{
	assert(phead);
	assert(phead->next != phead);
	//1.常规思路
	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;
	phead->prev = tailPrev;
	tailPrev->next = phead;
	free(tail);
	tail = NULL;

	//2.调用函数ListEraseNode,简化尾删
	//ListEraseNode(phead->prev);
}

void ListPushFront(LTNode* phead,LTDataType x)//6.头插
{
	assert(phead);
	//1.常规思路
	LTNode* newnode = BuyListNode(x);
	LTNode* next = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = next;
	next->prev = newnode;
	//2.调用函数ListInsertNode,简化尾删
	//ListInsertNode(phead->next, x);
}

void ListPopFront(LTNode* phead)//7.头删
{
	assert(phead);
	assert(phead->next != phead);
	//1.常规思路
	LTNode* cur = phead->next;
	LTNode* next = phead->next->next;
	free(cur);
	phead->next = next;
	next->prev = phead;
	//2.调用函数ListEraseNode,简化头删
	//ListEraseNode(phead->next);
}

LTNode* ListNodeFind(LTNode* phead, LTDataType x)//8.找到链表中数据为x的第一个节点并返回
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur->next != phead)//遍历寻找
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

void ListInsertNode(LTNode* pos, LTDataType x)//9.在pos节点前插入节点,pos节点是调用ListNodeFind函数得到的
{
	LTNode* newnode = BuyListNode(x);
	LTNode* posPrev = pos->prev;
	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

void ListEraseNode(LTNode* pos)//10.删除pos节点
{
	LTNode* posPrev = pos->prev;
	LTNode* posNext = pos->next;
	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}

void ListDestroy(LTNode* phead)//11.销毁链表————遍历即可
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur->next != phead)
	{
		LTNode* curNext = cur->next;
		free(cur);
		cur = curNext;
		phead->next = cur;
		cur->prev = phead;
	}
	free(phead);
}

(4) 测试样例的展示

总结：

虽然带头双向循环链表的结构比单向链表复杂很多，但是它对功能实现的难易程度以及自身的价值都优于单链表，所以大家在掌握单链表的同时也要掌握好双向链表，再次提醒各位，结构十分重要，结构又可以在图示中很好的体现出来，所以各位在数据结构的学习过程中一定要重视画图以及理解所化的图。就这样，我又分享了一次自己在学习道路上的理解，希望对各位有所帮助，再见。

 

RED MOON LEGENDS
关注
  • 12
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
专栏目录
双向链表的插入和删除
scanf_ff的博客
09-25 173
双向链表的插入和删除
《数据结构C语言版》-双链表的增删查改,链表与顺序表的区别
最新发布
输出分享
04-08 861
《数据结构C语言版》-双链表的增删查改,链表与顺序表的区别，简单易懂，轻松掌握。
数据结构双向链表学习
fengjuju的博客
05-02 1239
目录 一.双链表 二.代码展示 1.双向链表的定义 2.双向链表的初始化 3.双向链表在指定位置插入新元素 4.双向链表删除指定元素 5.找到指定元素的位置 6.打印链表长度 7.双向链表的整表删除 8.返回指定结点的地址 9.完整代码 10.样例测试输出 三.总结 一.双链表 双链表对比于单链表添加了一个前驱指针域，优势是可以实现双向遍历，而单链表只能从头结点开始遍历。 学生作业，大佬路过有误请指正。 二.代码展示 1.双向链表的定义 /** * Do
双向链表的插入删除操作
m0_72623338的博客
12-14 425
双向链表结构具有对称性，即p->prior->next=p=p->next->prior。如果是非空表那么头节点prior为空，尾节点next为空。先使x的prior指向a，然后让a的next指针指向x。使x的next指向b，然后让b的prior指针指向x。假设需要插入的节点为x，前驱为a，后继为b。设前驱为x，要删除的节点为y，后继为z。让头节点的前驱指针指向链表的尾节点。让尾节点的后续指针指向头节点。
双向链表的插入和删除的实现
Nactua的博客
05-02 5787
双向链表的操作实现包括：初始化指针，打印链表，插入链表以及删除链表。 1、初始化结构体 实现的代码如下： #include <stdio.h> #include <malloc.h> //初始化结构体，一个是前驱指针，一个后继指针. typedef struct DoubleLinkedNode{ char data; struct DoubleLinkedNode *previous; struct DoubleLinkedNode *next; } DLNo
双链表的删除操作
m0_65060417的博客
11-05 731
删除p节点的后继节点。
双向循环链表、增删查改、判断回文、排序、论文+代码
07-25
首先，我们可以使用双向链表来存储链表中的元素，然后使用双向链表来实现元素的排序操作。 本资源摘要信息涵盖了双向循环链表、增删查改、判断回文、排序等知识点，是数据结构与算法课程设计的重要组成部分。
双向循环链表.zip
08-13
对c语言中双向循环链表的简单应用。能实现链表中的（前插人）后插入，查找，删除，移动的相关功能，并配有较为详细的注释，还画有数据和指针的流向图，帮助你快速理解对于链表中 各指针的指向关系。（测试时需将函数...
数据结构顺序表和链表（超详细）
08-14
此压缩包为1、无头+单向+非循环链表增删查改实现// 动态申请一个结点// 单链表打印// 单链表尾插// 单链表的头插// 单链表的尾删// 单链表头删// 单链表查找// 单链表在pos位置之后插入x// 单链表删除pos位置之后的...
比特数据结构课件-Lesson3-顺序表-链表.pdf
07-07
增删查改操作相对顺序表更灵活，但访问元素不如顺序表直接。 顺序表和链表的主要区别在于存储方式和元素访问效率。顺序表适合于随机访问，插入和删除操作在元素数量较大时效率降低；而链表在插入和删除操作上更高效...
Lesson3--顺序表_链表.pdf
10-06
在数组上完成数据的增删查改。顺序表一般可以分为静态顺序表和动态顺序表。 2.2 接口实现 静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。...
双向链表的增删改查
rookie123222的博客
07-01 172
1.注意判断temp==null 的位置，应考虑放在最前面，防止出现空指针异常； 2.双向链表的自我删除（实则为两个指针更改，原数据域保留，两个指针保留），注意待删除的结点是否为最后一个结点； 3.添加结点时，注意判断添加的结点是否为最后一个结点； //创建双向链表的类 class DoubleLink{ //头结点 private HeroNode2 head = new HeroNode2(0, "", ""); public HeroNode2 getHead()...
【数据结构】双向链表的遍历、添加、修改和删除
dengmsjava的博客
05-12 2437
双向链表的遍历、添加、修改和删除 （1）单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。 （2）单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除。
双向链表的增删查改
zw_ss
03-31 749
双向链表顾名思义，链表的每一个节点都有两个指针，一个指向上一个节点，一个指向下一个节点，通过指针将链表的头和尾连起来形成一个循环结构。 SeqList.h #pragma once #include&lt;stdio.h&gt; #include&lt;Windows.h&gt; #include&lt;assert.h&gt; typedef int DataType; typedef st...
双向链表的简单介绍和实现增删改查功能
weixin_44824500的博客
02-28 338
使用单链表查找的方向只能是一个方向，而且不能自我删除，得要依赖一个辅助节点， 而使用双向链表就可以解决这些缺点。 单链表中的每个节点包含着一个存放数据的data域，和一个指向下一节点的next域。 双向链表中，每个节点除了包含着一个存放数据的data域，和一个指向下一节点的next域外，还多了一个指向上一节点的pre域。 下面来实现代码： 先在HeroNode中添加一个指向上一节点的pre ...
双向循环链表简单的插入、删除、修改以及查找功能的实现
super_marie的博客
05-22 1424
1“`include include define T 1define F 0typedef int ElementType; typedef int Boolean; typedef struct node* Node;struct node //定义双向的结构体 { struct node* prior; ElementType value; struct n
双向循环链表增删查改C语言实现
m0_53421868的博客
10-11 1208
目录双向链表的结构双向链表的实现双向链表的声明双向链表的实现结点的创建头结点的创建链表的销毁链表的打印链表的尾插链表的尾删链表的头插链表的头删查找指定位置前插入指定位置删除 双向链表的结构 双向链表： 每个结点存在两个指针域，分别存储该结点的前驱结点引用和后继结点引用，从任意一个结点出发，都能通过前驱引用以及后继引用完成整个链表结点的访问。 所以不难看出，单向链表能干的事，双向链表也能干！但是正是因为这一特性，相比于单链表，双向链表在访问其他结点上带来方便的同时，将占用更多的资源，因此在使用的时候可.
双链表的创建、插入、删除与查询 C语言
起名好难呀！
07-16 1369
适合初学者代码 #include<stdio.h> #include<stdlib.h> struct node { int data; struct node *next; struct node *prior; }; typedef struct node *LinkList; void create(LinkList head,LinkList tail,int n...
双向链表的插入删除新增
chixushuchu的博客
05-04 550
链表节点 存放 结点值，前继结点，后续结点 public class DoubleLink { public Long value; public DoubleLink pre; public DoubleLink next; public DoubleLink(Long value) { this.value = value; } ...
单向循环链表的增删查改
04-04
因此，它们的增删查改操作也基本相同，只是需要考虑尾节点的特殊情况。 1. 增加节点 在单向循环链表中，增加节点需要考虑两种情况： （1）在链表头部插入节点 首先，创建一个新节点，并将其next指向头节点，然后...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值