数据结构_线性表_双向链表（C语言实现+基本操作

已于 2024-01-30 13:20:14 修改
阅读量1k 收藏 19
点赞数 21
分类专栏： 数据结构 文章标签： 数据结构 链表 c语言
于 2024-01-29 23:47:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73726899/article/details/135922085
版权

系列文章目录

单链表（自用-CSDN博客

数据结构_线性表_顺序表（C语言实现+超详细逐步解析-CSDN博客

代码可以在gitee获取：

ListNode · 景鹤/learning_Byte_c - 码云 - 开源中国 (gitee.com)

前言

带头双向循环链表学习！！！

一、基本概念

定义：双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱

为什么选择双向链表?

可以提高链表的查找效率！

直接上图！

结点的结构
  1. 我们把存储数据元素信息的域称为数据域。
  2. 存储数据元素之间的链接信息即下一个存储数据元素地址的部分称为指针域。
  3. 由数据域和指针域组成的数据元素a的存储映像称为节点

 链表结构

二、基本操作

1.定义

typedef int LTDateType;			//便于更改存储类型

typedef struct ListNode {		
    LTDateType data;			//存储数据元素信息
    struct ListNode *pre;		//存储上一个节点信息
    struct ListNode *next;		//存储下一个节点信息
} ListNode;

2.动态申请空间，开辟一个节点

采用malloc函数，动态开辟一块sizeof(ListNode)大小的空间进行存储

LTNode* BuyLTNode(LTDataType x) {//开辟结点
	LTNode* newNode = (LTNode*)malloc(sizeof(LTNode));

	if (newNode == NULL) {
		perror("malloc failed");
		exit(-1);
	}

	newNode->data = x;
	newNode->next = NULL;
	newNode->pre = NULL;

	return newNode;
}

3. 初始化（创建哨兵位）

//采用返回值，不使用二级指针，符合整体的代码风格
LTNode* LTInit() {//初始化  
	LTNode* phead = BuyLTNode(0);

	phead->next = phead;
	phead->pre = phead;

	return phead;
}

4.打印

注意循环停止条件，不等于头指针！

遍历的是循环链表！！！

因此在不等于头指针的时候，才停止。

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

	assert(phead != NULL);

	LTNode* pphead = phead->next;
	while (pphead != phead)	//注意循环停止条件，不等于头指针
	{
		printf("%d->",pphead->data);
		pphead = pphead->next;
	}
	printf("\n");
}

5.尾插

第一种写法： 直接根据尾插特点，进行编写

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

	assert(phead != NULL);


	LTNode* tail = phead->pre;//找到尾结点
	LTNode* newNode = BuyLTNode(x);//开辟新节点
	
	tail->next = newNode;
	newNode->pre = tail;
	newNode->next = phead;
	phead->pre = newNode;	

}

6.尾删



void LTPopBack(LTNode* phead) {//尾删
	assert(phead != NULL);//链表不为空
	assert(phead->next != NULL);//且存在除头节点外的，第二个结点，能够进行删除


//第一种方法
	//LTNode* tail = phead->pre;//找到尾结点
	//LTNode* tailPre = tail->pre;//尾结点之前的结点
	//free(tail);

	//tailPre->next = phead;
	//phead->pre = tailPre;

//第二种方法
	LTErase(phead->pre);
}

7.头插

void LTPushFront(LTNode* phead, LTDataType x) {//头插
	assert(phead != NULL);//链表不为空

//第一种方法
	//LTNode* newNode = BuyLTNode(x);//开辟新节点
	//LTNode* first = phead->next;

	//phead->next = newNode;
	//newNode->pre = phead;

	//first->pre = newNode;
	//newNode->next = first;

//第二种方法
	LTInsert(phead->next,x);
}

8.头删

void LTPopFront(LTNode* phead) {//头删
	assert(phead != NULL);//链表不为空
	assert(phead->next != NULL);//且存在除头节点外的，一个结点，能够进行删除

//第一种方法
	//LTNode* first = phead->next;//首结点
	//LTNode* second = first->next;

	//phead->next = second;
	//second->pre = phead;
	//free(first);

//第二种方法
	LTErase(phead->next);
}

9.插入（在pos之前插入）

可以在头插/尾插 中复用！！！

//可以在头插/尾插 中复用！！！
//在pos之前插入
void LTInsert(LTNode* pos, LTDataType x) {
	assert(pos);

	LTNode* posPre = pos->pre;
	LTNode* newNode = BuyLTNode(x);
	
	posPre->next = newNode;
	newNode->pre = posPre;

	pos->pre = newNode;
	newNode->next = pos;
}

10.删除pos位置

// 删除pos位置
void LTErase(LTNode* pos) {
	assert(pos);
	
	LTNode* front = pos->pre;
	LTNode* back = pos->next;
	free(pos);

	front->next = back;
	back->pre = front;

}

11.求表长

//表长
void  LTSize(LTNode* phead) {
	assert(phead != NULL);

	int size = 0;
	LTNode* pphead = phead->next;
	while (pphead != phead)	//注意循环停止条件，不等于头指针
	{
		size++;
		pphead = pphead->next;
	}	
	printf("length: %d", size);
}

12.销毁链表

// 销毁(手动置空)
void ListDestory(ListNode* phead) {
	ListNode* curr = phead->next;
	while (curr != phead) {
		ListNode* next = curr->next;
		free(curr);
		curr = next;
	}
	free(phead);
}

三、代码总览

1.头文件 ListNode.h

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

typedef int LTDataType;

typedef struct ListNode {
	struct ListNode* pre;
	struct ListNode* next;
	
	LTDataType data;

}LTNode;

LTNode* BuyLTNode(LTDataType x);//开辟结点

LTNode* LTInit();//初始化   
//采用返回值，不使用二级指针，符合整体的代码风格

void LTPrint(LTNode* phead);//打印
void LTPushBack(LTNode* phead, LTDataType x);//尾插
void LTPopBack(LTNode* phead);//尾删

void LTPushFront(LTNode* phead, LTDataType x);//头插
void LTPopFront(LTNode* phead);//头删

void LTSize(LTNode* phead);


void LTInsert(LTNode* pos, LTDataType x);
 
void LTErase(LTNode* pos);

void ListDestory(ListNode* phead);

2.接口  ListNode.c

#include"ListNode.h"
//双向循环链表
LTNode* BuyLTNode(LTDataType x) {//开辟结点
	LTNode* newNode = (LTNode*)malloc(sizeof(LTNode));

	if (newNode == NULL) {
		perror("malloc failed");
		exit(-1);
	}

	newNode->data = x;
	newNode->next = NULL;
	newNode->pre = NULL;

	return newNode;
}

//采用返回值，不使用二级指针，符合整体的代码风格
LTNode* LTInit() {//初始化  
	LTNode* phead = BuyLTNode(0);

	phead->next = phead;
	phead->pre = phead;

	return phead;
}

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

	assert(phead != NULL);

	LTNode* pphead = phead->next;
	while (pphead != phead)	//注意循环停止条件，不等于头指针
	{
		printf("%d->",pphead->data);
		pphead = pphead->next;
	}
	printf("\n");
}


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

	assert(phead != NULL);

	LTNode* tail = phead->pre;//找到尾结点
	//LTNode* newNode = BuyLTNode(x);//开辟新节点
	//
	//tail->next = newNode;
	//newNode->pre = tail;
	//newNode->next = phead;
	//phead->pre = newNode;

	LTInsert(phead,x);
	
}



void LTPopBack(LTNode* phead) {//尾删
	assert(phead != NULL);//链表不为空
	assert(phead->next != NULL);//且存在除头节点外的，第二个结点，能够进行删除

	//LTNode* tail = phead->pre;//找到尾结点
	//LTNode* tailPre = tail->pre;//尾结点之前的结点
	//free(tail);

	//tailPre->next = phead;
	//phead->pre = tailPre;

	LTErase(phead->pre);
}


void LTPushFront(LTNode* phead, LTDataType x) {//头插
	assert(phead != NULL);//链表不为空

	//LTNode* newNode = BuyLTNode(x);//开辟新节点
	//LTNode* first = phead->next;

	//phead->next = newNode;
	//newNode->pre = phead;

	//first->pre = newNode;
	//newNode->next = first;

	LTInsert(phead->next,x);
}


void LTPopFront(LTNode* phead) {//头删
	assert(phead != NULL);//链表不为空
	assert(phead->next != NULL);//且存在除头节点外的，一个结点，能够进行删除

	//LTNode* first = phead->next;//首结点
	//LTNode* second = first->next;

	//phead->next = second;
	//second->pre = phead;
	//free(first);

	LTErase(phead->next);
}

//表长
void  LTSize(LTNode* phead) {
	assert(phead != NULL);

	int size = 0;
	LTNode* pphead = phead->next;
	while (pphead != phead)	//注意循环停止条件，不等于头指针
	{
		size++;
		pphead = pphead->next;
	}	
	printf("length: %d", size);
}


//可以在头插/尾插 中复用！！！
//在pos之前插入
void LTInsert(LTNode* pos, LTDataType x) {
	assert(pos);

	LTNode* posPre = pos->pre;
	LTNode* newNode = BuyLTNode(x);
	
	posPre->next = newNode;
	newNode->pre = posPre;

	pos->pre = newNode;
	newNode->next = pos;
}
// 删除pos位置
void LTErase(LTNode* pos) {
	assert(pos);
	
	LTNode* front = pos->pre;
	LTNode* back = pos->next;
	free(pos);

	front->next = back;
	back->pre = front;

}

// 销毁(手动置空)
void ListDestory(ListNode* phead) {
	ListNode* curr = phead->next;
	while (curr != phead) {
		ListNode* next = curr->next;
		free(curr);
		curr = next;
	}
	free(phead);
}

3.测试 Test.c

#include"ListNode.h"
void TestList1() {
	LTNode* plist = LTInit();

	LTPushBack(plist,1);
	LTPushBack(plist,2);
	LTPushBack(plist,3);
	LTPushBack(plist,4);

	LTPrint(plist);

	LTPopBack(plist);
	LTPrint(plist);
}

void TestList2() {
	LTNode* plist = LTInit();

	LTPushFront(plist, 5);
	LTPushFront(plist, 2);
	LTPushFront(plist, 3);
	LTPushFront(plist, 4);

	LTPrint(plist);
	LTPopFront(plist);
	LTPrint(plist);
	LTSize(plist);

}

//测试insert在头插尾插中复用
void TestList3() {
	LTNode* plist = LTInit();

	LTPushFront(plist, 1);
	LTPushFront(plist, 2);
	LTPushFront(plist, 3);

	printf("第一次push：");
	LTPrint(plist);

	LTPopBack(plist);

	printf("pop：");
	LTPrint(plist);

	
	

	LTPushBack(plist, 4);
	LTPushBack(plist, 5);
	LTPushBack(plist, 6);
	printf("第2次push：");
	LTPrint(plist);

	LTPopFront(plist);

	printf("pop：");
	LTPrint(plist);

	LTSize(plist);

}
int main() {
	TestList3();
	
	return 0;
}

 四、运行截图

景鹤
关注
专栏目录
数据结构---线性表之双链表（C语言）
03-29
本文将深入探讨双链表的基本原理，以及如何使用C语言实现双链表的创建、插入和删除操作。 双链表是一种线性数据结构，与单链表不同，它在每个节点中包含两个指针，分别指向其前一个节点和后一个节点。这种设计使得...
双向链表API及C语言实现
03-29
双向链表的API和C语言实现，程序说明在我的专栏《数据结构与算法学习笔记》中双向链表相关文章。包含了双向链表的结点结构体、表头结构体、创建双向链表、销毁双向链表、获取链表长度、清空双向链表、插入一个节点...
数据结构_线性表_顺序表（C语言实现+超详细逐步解析
m0_73726899的博客
01-26 1432
数据结构，顺序表全部代码+超详细注释~
数据结构——线性表（C语言实现）
m0_56399733的博客
07-12 1683
数据结构线性表的内容：顺序表+链表，增删查改，C语言实现，含有运行结果！！！动态顺序变、单链表、双链表，循环链表；
数据结构-C语言-线性表 || 双向链表的实现
内容丰富，不需简介
10-04 470
双向链表的初始化； 基于所构建的双向链表，利用算法完成单个元素的查找、插入、删除及时间空间复杂度分析； 完成重复元素的删除操作。
双向链表--C语言实现数据结构
2201_76062618的博客
05-13 5117
本文详细介绍带头双向循环链表，内容较为丰富
C语言数据结构之线性表-双向链表篇
2301_79201049的博客
01-26 1060
注意：这里的 带头 跟前⾯我们说的 头节点 是两个概念，实际前面的在单链表阶段称呼不严 谨，但是为了大家更好的理解就直接称为单链表的头节点
数据结构3_线性表_双向链表
毛钱儿的博客
04-09 303
数据结构3_线性表_3 总览： 线性表： 线性表是具有相同数据类型的n(n>=0)个数据元素的有序序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，其一般表示为： L=(a1,a2,a3,a4,∗∗∗,an) L = (a1,a2,a3,a4,***,an) L=(a1,a2,a3,a4,∗∗∗,an) a1为表头元素，an为表尾元素，除了an其他元素都有唯一的直接后继，除...
数据结构线性表之双链表之c语言实现
qq_53580962的博客
07-30 494
双链表的基本操作
c语言数据结构——链表的实现及其基本操作
希望自己从编程小白变成大佬
04-06 4491
顺序表的问题及思考中间/头部的插入删除，时间复杂度为O(N)增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。思考：如何解决以上问题呢？下面我们给出了链表的结构，让我们来看看吧。
【数据结构】线性表——带头双向循环链表
qq_65596720的博客
05-10 1484
带头双向循环链表的优点 1.支持任意位置时间复杂度为O(1)的插入和删除。 2.按照需求申请释放空间，无需担心空间不够用，无需担心浪费。 3.带头可以省去链表为空时的判断，可以使代码更加简约 带头双向循环链表的缺点 1.不可以进行下标随机访问。 2.缓存利用率低 带头双向循环链表是线性表的一种，带头双向循环链表是链式存储的线性表，不同于顺序表，链表在内存空间中不连续。 带头：带头就是带哨兵位，可以省链表为空时进行的判断。 双向：由结构体内的next指针下一条数据进行链接，由prev对前一条数据
C语言数据结构 双向链表的建立与基本操作
01-01
C语言数据结构 双向链表的建立与基本操作 双向链表比单链表有更好的灵活性，其大部分操作与线性表相同。下面总结双向链表与单链表之间的不同之处及我在实现过程中所遇到的问题。 1.双向链表的建立 双向链表在初始...
数据结构与算法基础课程 C语言C++程序语言设计教程 2_3线性表-链表 共43页.pptx
07-20
本课程旨在为学生提供关于数据结构与算法的基础知识，重点介绍线性表这一重要的数据结构类型，尤其是链表的实现与应用。通过学习，学生将能够理解链表的基本概念、掌握链表的操作方法，并能够在实际编程中灵活运用...
数组、单链表和双链表介绍以及双向链表的CC++Java实现 数组和链表.pdf
04-18
数组、单链表和双链表介绍以及双向链表的C、C++和Java实现 在计算机科学中，数组、单链表和双链表是...双向链表的实现可以使用C、C++和Java三种语言，它们的实现方式也有所不同，但是它们都可以实现双链表的基本操作。
数据结构与算法：高级数据结构与实际应用
weidl001的博客
10-16 1096
本章介绍了跳表、Trie树、B树与 B+树等高级数据结构，以及它们在实际系统中的应用。这些数据结构在提高查找效率、优化存储和加速特定任务方面具有不可替代的作用。通过深入理解这些结构及其特性，我们能够选择最合适的数据结构来应对复杂的实际问题。在下一章中，我们将深入讨论并查集与线段树的高级应用，以及它们在图论和范围查询中的重要作用。
【数据结构】AVL树（C++实现）
weixin_73914025的博客
10-13 761
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。它的左右子树都是AVL树左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在Olog2nO(log_2 n)Olog。
七大经典排序算法优化：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序、归并排序代码详解
weixin_64593595的博客
10-15 1736
本文深入探讨了七大经典排序算法的优化：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序和归并排序。适合需要稳定性排序的场景，通过对这些算法的分析和优化，能够根据具体需求选择合适的排序方法，从而提高程序性能和效率。
《C++中栈的实现：探索高效数据结构》
xy520521的博客
10-13 596
当向栈中添加元素时，创建一个新的节点，将其数据设置为要添加的元素，并将其指向下一个节点设置为当前的栈顶节点，然后将栈顶指针指向新节点。当从栈中删除元素时，将栈顶指针指向当前栈顶节点的下一个节点，并释放原来栈顶节点的内存。首先，数组的大小是固定的，一旦栈的大小超过了数组的容量，就需要进行复杂的扩容操作。其次，数组实现的栈在内存中的分配是连续的，可能会导致内存碎片的问题。此外，链表实现的栈在内存中的分配是不连续的，不会产生内存碎片。但是，链表实现的栈在进行插入和删除操作时需要进行指针的操作，相对来说比较复杂。
数据结构——链表，哈希表
最新发布
m0_66925868的博客
10-19 271
若有错误与不足请指出，关注DPT一起进步吧！
C语言实现数据结构：线性表的存储结构与操作
"数据结构答案-用C语言描述，涵盖了线性表的顺序存储...这个资源提供了关于数据结构中线性表的基本概念和操作，包括顺序存储和链式存储的实现细节，以及相关的算法实现，对于学习C语言描述的数据结构和算法非常有帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

景鹤

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值