数据结构三：双链表（C/C++实现）

已于 2023-07-30 21:45:56 修改
阅读量99 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c语言 c++
于 2023-07-30 21:06:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62078117/article/details/132011280
版权

目录

双链表（C）：

双链表（C++）：

测试结果：

总结：

双链表比单链表多了个指向前一个结点的指针，更方便进行插入和删除操作。

代码使用带头结点的链表，这样可以方便实现代码。

并且在初始化链表的时候使用尾插法建立链表。

双链表（C）：

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

typedef int ElemType;
typedef struct DNode {	//双链表结点
	ElemType data;
	struct DNode* prior, * next;
}DNode,*DLinkList;

//默认采用带头结点、尾插法建立链表（方便写代码）
int DListInit(DLinkList* L)//此处的L为二级指针
{
	int x;
	*L = (DLinkList)malloc(sizeof(DNode));	//头结点
	if (*L == NULL)	return 0;
	(*L)->prior = NULL;
	(*L)->next = NULL;
	DNode* r = *L;//尾指针
	scanf_s("%d", &x);
	while (x != 9999) {
		DNode* s = (DNode*)malloc(sizeof(DNode));
		if (s == NULL)	return 0;
		s->data = x;
		r->next = s;
		s->prior = r;
		r = s;		//尾插s，同时移动尾指针
		scanf_s("%d", &x);
	}
	r->next = NULL;
	return 1;
}
//链表判空
int DListIsEmpty(DLinkList L)
{
	if (L->next == NULL)	
		return 1;
	else
		return 0;
}
//销毁链表
int DListDestory(DLinkList* L)
{
	DNode* p = (*L)->next;//p指向待删除结点
	while (p != NULL) {
		(*L)->next = p->next;
		p->next->prior = *L;	//连接头结点与p的后一个结点
		free(p);
		p = (*L)->next;
	}
	p = *L;
	free(p);
	p = NULL;
	*L = NULL;	//删除头结点
	return 1;
}
//查找第i个结点
DNode* DListSearchNode(DLinkList L, int i)
{
	if (i < 1)	return NULL;

	DNode* p = L->next;//p初始指向第一个结点
	int j = 1;//计数值
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	return p;
}
//按值查找结点
DNode* DListSearchElem(DLinkList L, ElemType e)
{
	DNode* p = L->next;//p初始指向第一个结点
	while (p != NULL && p->data != e) {
		p = p->next;
	}
	return p;
}
//求链表表长（头结点不算长度）
int DListLenth(DLinkList L)
{
	if (L == NULL)	return 0;

	DNode* p = L->next;//p初始指向第一个结点
	if (p == NULL)	return 0;
	int len = 1;
	while (p->next != NULL) {
		p = p->next;
		len++;
	}
	return len;
}
//在p结点之后插入s结点
int	InsertNextDNode(DNode* p, DNode* s)
{
	if (p == NULL || s == NULL)	return 0;

	s->next = p->next;
	if (p->next != NULL)
		p->next->prior = s;	//防止空指针出错
	s->prior = p;
	p->next = s;
	return 1;
}
//在p结点之前插入s结点
int InsertPriorDNode(DNode* p, DNode* s)
{
	if (p == NULL || s == NULL)	return 0;
	
	s->prior = p->prior;
	p->prior->next = s;
	s->next = p;
	p->prior = s;
	return 1;
}
//第i个位置后插结点e，新结点位于i处
int DListRearInsert(DLinkList* L, int i, ElemType e)
{
	DNode* p = DListSearchNode(*L, i - 1);//找到第i-1个结点
	if (p == NULL)	return 0;

	DNode* s = (DNode*)malloc(sizeof(DNode));
	if (s == NULL)	return 0;
	s->data = e;
	if (InsertNextDNode(p, s)) {//后插结点
		return 1;
	}
	else {
		return 0;
	}
}
//第i个位置前插入结点e，新节点位于i-1处
int DListFrontInsert(DLinkList* L, int i, ElemType e)
{
	DNode* p = DListSearchNode(*L, i - 1);//找到第i-1个结点
	if (p == NULL)	return 0;

	DNode* s = (DNode*)malloc(sizeof(DNode));
	if (s == NULL)	return 0;
	s->data = e;
	if (InsertPriorDNode(p, s)) {//前插结点
		return 1;
	}
	else {
		return 0;
	}
}
//删除第i个结点，并返回删除数据
int DListDeleteNode(DLinkList* L, int i, ElemType* e)
{
	DNode* p = DListSearchNode(*L, i - 1);//找到第i-1个结点
	if (p == NULL)	return 0;

	DNode* q = p->next;//q指向待删除结点
	if (q == NULL)	return 0;
	p->next = q->next;
	q->next->prior = p;
	*e = q->data;
	free(q);
	q = NULL;
	return 1;
}
//删除特定结点e
int DListDeleltNodeP(DLinkList* L, ElemType e)
{
	DNode* p = DListSearchElem(*L, e);//p指向待删除结点
	if (p == NULL)	return 0;

	if (p->next == NULL) {	//表示p为链表最后一个结点
		p->prior->next = NULL;
		free(p);
		p = NULL;
	}
	else {
		p->prior->next = p->next;
		p->next->prior = p->prior;
		free(p);
		p = NULL;
	}
	return 1;
}
//从头输出双链表
void DListPrint(DLinkList L)
{
	if (L == NULL || L->next == NULL)	return;

	DNode* p = L->next;
	int i = 1;
	while (p != NULL) {
		printf("data[%d]:%d     ", i, p->data);
		p = p->next;	//必须先输出再移动指针
		i++;
	}
	printf("\n");
}

int main()
{
	DLinkList L;
	/*************************链表初始化***************************/
	printf("请输入数据，构建链表：\n");
	DListInit(&L);
	if (DListIsEmpty(L)) {
		printf("链表为空！\n");
	}
	else {
		printf("链表非空！\n");
	}
	printf("链表中数据为：\n");
	DListPrint(L);
	printf("链表长度为：%d\n", DListLenth(L));
	/*************************************************************/


	/*************************插入、删除结点***********************/
	if (DListRearInsert(&L, 4, 12345)) {//在第4个位置后插入12345
		printf("在第4个位置后插入12345成功！\n");
		printf("链表中数据为：\n");
		DListPrint(L);
		printf("链表长度为：%d\n", DListLenth(L));
	}
	else {
		printf("在第4个位置后插入12345失败！\n");
	}
	printf("\n\n");
	if (DListFrontInsert(&L, 3, 999)) {//在第3个位置前插入999
		printf("在第3个位置前插入999成功！\n");
		printf("链表中数据为：\n");
		DListPrint(L);
		printf("链表长度为：%d\n", DListLenth(L));
	}
	else
	{
		printf("在第3个位置前插入999失败！\n");
	}
	printf("\n\n");
	int e;
	if (DListDeleteNode(&L, 5, &e)) {//删除第5个位置的结点
		printf("删除第5个结点成功！删除的数据为：%d\n", e);
		printf("链表中数据为：\n");
		DListPrint(L);
		printf("链表长度为：%d\n", DListLenth(L));
	}
	else {
		printf("删除第5个结点失败！");
	}
	printf("\n\n");
	/*************************************************************/

	system("pause");
	return 0;
}

双链表（C++）：

#include <iostream>

typedef int ElemType;
typedef struct DNode {	//双链表结点
	ElemType data;
	struct DNode* prior, * next;
}DNode, * DLinkList;

//默认采用带头结点、尾插法建立链表（方便写代码）
//C++可以使用引用，不需要操作二级指针；还可以使用bool来进行判断
bool DListInit(DLinkList& L)
{
	int x;
	L = (DLinkList)malloc(sizeof(DNode));	//头结点
	if (L == NULL)	return false;
	L->prior = NULL;
	L->next = NULL;
	DNode* r = L;//尾指针
	scanf_s("%d", &x);
	while (x != 9999) {
		DNode* s = (DNode*)malloc(sizeof(DNode));
		if (s == NULL)	return false;
		s->data = x;
		r->next = s;
		s->prior = r;
		r = s;		//尾插s，同时移动尾指针
		scanf_s("%d", &x);
	}
	r->next = NULL;
	return true;
}
//链表判空
bool DListIsEmpty(DLinkList L)
{
	if (L->next == NULL)
		return true;
	else
		return false;
}
//销毁链表
bool DListDestory(DLinkList& L)
{
	DNode* p = L->next;//p指向待删除结点
	while (p != NULL) {
		L->next = p->next;
		p->next->prior = L;	//连接头结点与p的后一个结点
		free(p);
		p = L->next;
	}
	p = L;
	free(p);
	p = NULL;
	L = NULL;	//删除头结点
	return true;
}
//查找第i个结点
DNode* DListSearchNode(DLinkList L, int i)
{
	if (i < 1)	return NULL;

	DNode* p = L->next;//p初始指向第一个结点
	int j = 1;//计数值
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	return p;
}
//按值查找结点
DNode* DListSearchElem(DLinkList L, ElemType e)
{
	DNode* p = L->next;//p初始指向第一个结点
	while (p != NULL && p->data != e) {
		p = p->next;
	}
	return p;
}
//求链表表长（头结点不算长度）
int DListLenth(DLinkList L)
{
	if (L == NULL)	return false;

	DNode* p = L->next;//p初始指向第一个结点
	if (p == NULL)	return false;
	int len = 1;
	while (p->next != NULL) {
		p = p->next;
		len++;
	}
	return len;
}
//在p结点之后插入s结点
bool InsertNextDNode(DNode* p, DNode* s)
{
	if (p == NULL || s == NULL)	return false;

	s->next = p->next;
	if (p->next != NULL)
		p->next->prior = s;	//防止空指针出错
	s->prior = p;
	p->next = s;
	return true;
}
//在p结点之前插入s结点
bool InsertPriorDNode(DNode* p, DNode* s)
{
	if (p == NULL || s == NULL)	return false;

	s->prior = p->prior;
	p->prior->next = s;
	s->next = p;
	p->prior = s;
	return true;
}
//第i个位置后插结点e，新结点位于i处
bool DListRearInsert(DLinkList& L, int i, ElemType e)
{
	DNode* p = DListSearchNode(L, i - 1);//找到第i-1个结点
	if (p == NULL)	return false;

	DNode* s = (DNode*)malloc(sizeof(DNode));
	if (s == NULL)	return false;
	s->data = e;
	if (InsertNextDNode(p, s)) {//后插结点
		return true;
	}
	else {
		return false;
	}
}
//第i个位置前插入结点e，新节点位于i-1处
bool DListFrontInsert(DLinkList& L, int i, ElemType e)
{
	DNode* p = DListSearchNode(L, i - 1);//找到第i-1个结点
	if (p == NULL)	return false;

	DNode* s = (DNode*)malloc(sizeof(DNode));
	if (s == NULL)	return false;
	s->data = e;
	if (InsertPriorDNode(p, s)) {//前插结点
		return true;
	}
	else {
		return false;
	}
}
//删除第i个结点，并返回删除数据
bool DListDeleteNode(DLinkList& L, int i, ElemType& e)
{
	DNode* p = DListSearchNode(L, i - 1);//找到第i-1个结点
	if (p == NULL)	return false;

	DNode* q = p->next;//q指向待删除结点
	if (q == NULL)	return false;
	p->next = q->next;
	q->next->prior = p;
	e = q->data;
	free(q);
	q = NULL;
	return true;
}
//删除特定结点e
bool DListDeleltNodeP(DLinkList& L, ElemType e)
{
	DNode* p = DListSearchElem(L, e);//p指向待删除结点
	if (p == NULL)	return false;

	if (p->next == NULL) {	//表示p为链表最后一个结点
		p->prior->next = NULL;
		free(p);
		p = NULL;
	}
	else {
		p->prior->next = p->next;
		p->next->prior = p->prior;
		free(p);
		p = NULL;
	}
	return true;
}
//从头输出双链表
void DListPrint(DLinkList L)
{
	if (L == NULL || L->next == NULL)	return;

	DNode* p = L->next;
	int i = 1;
	while (p != NULL) {
		printf("data[%d]:%d     ", i, p->data);
		p = p->next;	//必须先输出再移动指针
		i++;
	}
	printf("\n");
}

int main()
{
	DLinkList L;
	/*************************链表初始化***************************/
	std::cout << "请输入数据，构建链表：\n";
	DListInit(L);
	if (DListIsEmpty(L)) {
		std::cout << "链表为空！\n";
	}
	else {
		std::cout << "链表非空！\n";
	}
	std::cout << "链表中数据为：\n";
	DListPrint(L);
	std::cout << "链表长度为：" << DListLenth(L) << std::endl;
	/*************************************************************/


	/*************************插入、删除结点***********************/
	if (DListRearInsert(L, 4, 12345)) {//在第4个位置后插入12345
		std::cout << "在第4个位置后插入12345成功！\n";
		std::cout << "链表中数据为：\n";
		DListPrint(L);
		std::cout << "链表长度为：" << DListLenth(L) << std::endl;
	}
	else {
		std::cout << "在第4个位置后插入12345失败！\n";
	}
	std::cout << "\n" << std::endl;
	if (DListFrontInsert(L, 3, 999)) {//在第3个位置前插入999
		std::cout << "在第3个位置前插入999成功！\n";
		std::cout << "链表中数据为：\n";
		DListPrint(L);
		std::cout << "链表长度为：" << DListLenth(L) << std::endl;
	}
	else
	{
		std::cout << "在第3个位置前插入999失败！\n";
	}
	std::cout << "\n" << std::endl;
	int e;
	if (DListDeleteNode(L, 5, e)) {//删除第5个位置的结点
		std::cout << "删除第5个结点成功！删除的数据为：" << e << std::endl;
		std::cout << "链表中数据为：\n";
		DListPrint(L);
		std::cout << "链表长度为：" << DListLenth(L) << std::endl;
	}
	else {
		std::cout << "删除第5个结点失败！\n";
	}
	std::cout << "\n" << std::endl;
	/*************************************************************/

	system("pause");
	return 0;
}

测试结果：

总结：

双链表插入以及删除的时候要小心操作指针，防止发生空指针错误、指向不正确等问题。

以上

以上均为个人学习心得，如有错误，请不吝赐教~

THE END

~O'Connor
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
<4>数据结构与算法（C/C++实现）视频教程
06-10
C/C++实现数据结构与算法视频培训课程全面介绍计算机行业，基本的数据结构与算法，既有理论的深度也有实战的技法。课程全程讲师手敲代码，一步步代你走进数据结构与算法。本课程涉及的数据结构与算法有，栈，队列，...
数据结构--双链表的c/c++实现（超详细注释/实验报告）
池塘春草梦的博客
09-26 2783
如果希望从表中快速确定某一个结点的前去，其中一个解决方法就是在单链表的每个结点再增加一个指向其前去的指针域prior。这样形成的链表中就有两条方向不同的链，称之为双向链表(Double Linked List)。
C/C++数据结构（三） —— 双向带头循环链表
Edison's 小宇宙
08-16 1万+
【数据结构系列】链表之双向带头循环链表的基本操作
数据结构双链表基本操作（C/C++实现）
JunsIr的技术栈
10-22 1599
数据结构双链表基本操作（C/C++实现） 注意：本代码为了测试运行默认含有操作所需数据，如有需要可自己增删改相关数据 涉及基本运算 初始化双链表 依次采用尾插法插入元素 输出双链表 输出双链表的长度 判断双链表是否为空 输出双链表的第n个元素 输出元素x的位置 在第n个元素位置上插入x元素 输出双链表 删除双链表的第n个元素 输出双链表 释放双链表 GitHub地址（包含.cpp文件和可执行程...
【数据结构】链表—C/C++实现
热门推荐
朝花夕拾
11-04 1万+
数据结构中的链表是计算机科学领域的一个核心概念，用于有效地组织和管理数据元素，以便进行数据的增加、删除、插入和查找操作。链表是一种线性数据结构，与数组不同，它的元素在内存中不需要连续的存储空间，这赋予了链表更大的灵活性和可扩展性。
数据结构：单向链表反转（C/C++）
kaixian2003的博客
03-25 1650
单向链表在数据结构中比较常见，要求实现单向链表的反转，如下图所示： 反转前： 反转后： 代码如下： #include <stdio.h> #include <stdlib.h> struct list{ int var; struct list *next; }; //反转单向链表 void reversal(struct list* &head) { struct list *p1,*pre,*after; p1=head; pre=head; head=h
C/C++ 双链表之逆序的实例详解
01-01
C/C++ 双链表之逆序的实例详解 一、结点结构  双向链表的数据结构定义如下：  typedef struct node { ElemType data; struct node *prior struct node *next; }list;  其中，ElemType可以是任意数据类型...
利用C++实现双链表基本接口示例代码
12-31
本文主要给大家介绍了关于C++实现双链表基本接口的相关内容，分享出来供大家参考学习，话不多说，来一起看看详细的介绍吧。 首先先简单通过图示区分单链表和双链表的结构差异： 单链表的基本接口实现可参考：单链表...
Data_Structure_C.rar_数据结构_C/C++_
08-12
基本数据结构的C实现。包括:（1）线性顺序表（2）单链表（3）双向循环链表（4）顺序栈（5）链式队列（6）循环队列（7）二叉树的先序、中序、后序的递归遍历和非递归遍历。
C/C++链表增删改查排序操作
11-21
使用C++实现双向循环链表的增删改查排序等操作，可查看个人博客的【[数据结构和算法]C/C++双向循环链表实现(增删改查排序)】--链接https://blog.csdn.net/slimmm/article/details/84317806
【数据结构】二叉树（带图详解）
Z1tai的博客
04-27 1541
链表和数组都是线性结构，而树是非线性的结构。树是依靠分支关系定义出的一种层次结构。社会亲缘关系和组织结构图都可以用树来形象地表示。
数据结构系列-二叉树之前序遍历
in_seattle的博客
04-26 504
这篇文章，我们主要的内容是对二叉树当中的前历的算法进行讲解，二叉树中的算法所要求实现的是 从根到左子树再到右子树的遍历顺序，可能这样不太好理解，我们拿一张图片进行解释，我们先来分析一下这个的实现逻辑是什么，按照根节点，左子树，右子树的顺序，我们先来判断一下这个应该实现的结果是什么。在这里，我们将空也表现了出来，那下面，我们就讲解一下怎么用代码实现这个过程。假设在这个二叉树当中，我们要实现二叉树遍历当中的前历，我们应该怎么做呢。这些代码我们在前面就详细的进行了展开，在这里我们就不进行详细的讲解。
【数据结构】第二章 线性数据结构.线性表.顺序表
KX_52517的博客
04-26 1347
线性数据结构章节
【数据结构】图（Graph）
2201_75475240的博客
04-24 1300
本文章介绍数据结构中的图的基本知识，包括概念、邻接表、邻接矩阵、深度遍历和广度遍历，且还包含408习题（附有解析）。此外，含有关于邻接表和两种遍历全部具体实现代码。
数据结构练习：链表扩容
2301_80369371的博客
04-25 332
一：创建一个新链表，遍历原链表的同时，将原链表的值复制给新链表。二：将新链表插入到原链表中（大致如下）3.*&是c++的写法，等同于c中的*2.记得malloc后要free。1.头结点是不存有数据的。
数据结构(八)——排序
señoritaw的博客
04-25 1100
排序(Sort)，就是重新排列表中的元素，使表少的元素满足按关键字有序的过程。输入∶n个记录R1,R2...., Rn，对应的关键字为k1, k2,... , kn输出:输入序列的一个重排R1',R2'....,Rn'，使得有k1'≤k2'≤...≤kn'(也可递减)算法的稳定性。若待排序表中有两个元素R,和R，其对应的关键字相同即key = keyj，且在排序前R;在R,的前面，若使用某一排序算法排序后，R仍然在R的前面，则称这个排序算法是稳定的，否则称排序算法是不稳定的。
排序-八大排序FollowUp
最新发布
2301_78838401的博客
04-27 977
最坏情况下:0(n^2)最好情况下:0(n)当数据越有序 排序越快适用于: 待排序序列 已经基本上趋于有序了!空间复杂度:0(1)稳定性:稳定的。
【C 数据结构】二叉树
普罗米修斯的博客
04-24 1087
性质 3 的计算方法为：对于一个二叉树来说，除了度为 0 的叶子结点和度为 2 的结点，剩下的就是度为 1 的结点（设为。同时，对于每一个结点来说都是由其父结点分支表示的，假设树中分枝数为 B，那么总结点数。例如，图 1a) 就是一棵二叉树，而图 1b) 则不是。而分枝数是可以通过 n1 和 n2 表示的，即。两种方式得到的 n 值组成一个方程组，就可以得出。所以，n 用另外一种方式表示为。使用顺序表（数组）存储二叉树。顺序存储只适用于完全二叉树。满二叉树也是完全二叉树。每个结点的度都为 2。
数据结构系列-堆排序当中的T-TOK问题
in_seattle的博客
04-24 329
在这个代码当中有几个比较厉害的点需要我们注意一下，首先在他的创建数据的那个阶段，我们使用了随机数，但是它那里进行了取余，这样的好处是将数字的范围控制在一个程度之内，可以检测自己的程序是否正确表达。T-TOK说简单点，就是说，假如有10000个数据（随机的），让你找到其中最大的10个数据，有什么快速的方法，遍历吗？这个是不显示的，效率是最低的。之前我们讲到了堆排序的实现逻辑，那么接下来我们重点关注的就是其中的T-TOK问题。所以，我们能想到的比较好的方法就是堆排序当中的T-TOK问题。
数据结构双向链表c++
03-31
双向链表是一种常见的数据结构，与单向链表相比，它每个节点都有两个指针，分别指向前驱节点和后继节点。这样，双向链表可以实现双向遍历，插入和删除操作也更加方便。 以下是用C语言实现双向链表的代码： ```c #...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值