双向带头循环链表（增删查改）

已于 2023-03-14 23:58:30 修改
阅读量323 收藏 2
点赞数 7
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2023-03-14 23:49:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70056514/article/details/129542403
版权

目录

一、什么是双向链表？

大家有没有发现上一期的单链表结构在尾插和中间插入的时候会使用得非常的难受呢？中间插入需要额外定义一个指针保存插入位置的前一个位置的地址，尾插又需要从头开始一直找到最后才能找到尾部再插入，归根到底都是因为单链表不能往回找上一个结点，所以今天给大家分享一个结构设计得更好的链表：双向带头循环链表。双向链表，顾名思义就是既能往后找下一个结点，又能往前找上一个结点的链表，那么需要怎么设计这个结构呢？其实很简单，只需要在结点的结构体里面多加一个指向前一个结点的指针就行了。下面我们就来逐步地实现这个双向链表。

在这里插入图片描述

二、双向带头循环链表的增删查改

2.1 结构体的声明

typedef int LTDataType;

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

}ListNode;

2.2 初始化链表

//用返回值的形式初始化链表
ListNode* ListInit()
{
	ListNode* phead = (ListNode*)malloc(sizeof(ListNode));
	if (phead == NULL)
	{
		perror("malloc phead fail");
		return NULL;
	}
	//phead是哨兵位头节点，不存储有效数据
	//空链表里面也存在一个头节点，prev和next指针都指向自己
	phead->next = phead;
	phead->prev = phead;
	phead->data = -1;
	return phead;
}

2.3 申请新节点

ListNode* BuyListNode(LTDataType x)
{
	ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
	if (newNode == NULL)
	{
		perror("malloc newNode fail");
		return NULL;
	}
	newNode->next = NULL;
	newNode->prev = NULL;
	newNode->data = x;
	return newNode;

}

2.4 链表打印

void ListPrint(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		printf("<=>%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");

}

2.5 双向链表在pos的前面进行插入

void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newNode = BuyListNode(x);
	if (newNode == NULL)
	{
		return;
	}
	
	ListNode* posPrev = pos->prev;
	newNode->next = pos;
	pos->prev = newNode;
	posPrev->next = newNode;
	newNode->prev = posPrev;

}

2.6 双向链表删除pos位置的节点

void ListErase(ListNode* pHead,ListNode* pos)
{
	assert(pos && pos != pHead);
	ListNode* posPrev = pos->prev;
	ListNode* posNext = pos->next;
	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
	pos = NULL;

}

2.7 头插

void ListPushFront(ListNode* pHead, LTDataType x)
{
	//pHead->next就是链表的头
	ListInsert(pHead->next, x);
}

2.8 头删

void ListPopFront(ListNode* pHead)
{
	ListErase(pHead, pHead->next);
}

2.9 尾插

void ListPushBack(ListNode* pHead, LTDataType x)
{
	//pHead的前一个位置就是尾部，插入实在pos位置的前一个位置插入
	ListInsert(pHead, x);
}

2.10 尾删

void ListPopBack(ListNode* pHead)
{
	ListErase(pHead, pHead->prev);
}

2.11 查找

ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

2.12 双向链表的销毁

void ListDestroy(ListNode** ppHead)
{
	//销毁需要把哨兵位的头节点pHead也释放掉
	//所以要传二级指针过来，也可以由调用该函数的人自己释放
	assert(ppHead && *ppHead);
	ListNode* cur = (*ppHead)->next;
	while (cur != *ppHead)
	{
		ListNode* del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	free(*ppHead);
	*ppHead = NULL;

}

三、代码汇总

3.1 List.h

List.h

#pragma once

//List.h

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

typedef int LTDataType;

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

}ListNode;

// 创建返回链表的头结点.
extern ListNode* ListInit();
// 双向链表销毁
extern void ListDestroy(ListNode** ppHead);
//申请新结点
extern ListNode* BuyListNode(LTDataType x);
// 双向链表打印
extern void ListPrint(ListNode* pHead);
// 双向链表尾插
extern void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
extern void ListPopBack(ListNode* pHead);
// 双向链表头插
extern void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
extern void ListPopFront(ListNode* pHead);
// 双向链表查找
extern ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
extern void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
extern void ListErase(ListNode* pHead, ListNode* pos);

3.2 List.c

List.c

#define _CRT_SECURE_NO_WARNINGS 1

//List.c

#include "List.h"

ListNode* ListInit()
{
	ListNode* phead = (ListNode*)malloc(sizeof(ListNode));
	if (phead == NULL)
	{
		perror("malloc phead fail");
		return NULL;
	}
	phead->next = phead;
	phead->prev = phead;
	phead->data = -1;
	return phead;
}

void ListDestroy(ListNode** ppHead)
{
	assert(ppHead && *ppHead);
	ListNode* cur = (*ppHead)->next;
	while (cur != *ppHead)
	{
		ListNode* del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	free(*ppHead);
	*ppHead = NULL;

}

void ListPrint(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		printf("<=>%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");

}

ListNode* BuyListNode(LTDataType x)
{
	ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
	if (newNode == NULL)
	{
		perror("malloc newNode fail");
		return NULL;
	}
	newNode->next = NULL;
	newNode->prev = NULL;
	newNode->data = x;
	return newNode;

}

void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newNode = BuyListNode(x);
	if (newNode == NULL)
	{
		return;
	}
	
	ListNode* posPrev = pos->prev;
	newNode->next = pos;
	pos->prev = newNode;
	posPrev->next = newNode;
	newNode->prev = posPrev;

}

void ListErase(ListNode* pHead,ListNode* pos)
{
	assert(pos && pos != pHead);
	ListNode* posPrev = pos->prev;
	ListNode* posNext = pos->next;
	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
	pos = NULL;

}

void ListPushBack(ListNode* pHead, LTDataType x)
{
	ListInsert(pHead, x);
}

void ListPushFront(ListNode* pHead, LTDataType x)
{
	ListInsert(pHead->next, x);
}

void ListPopBack(ListNode* pHead)
{
	ListErase(pHead, pHead->prev);
}

void ListPopFront(ListNode* pHead)
{
	ListErase(pHead, pHead->next);
}

ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

3.3 test.c

test.c

#define _CRT_SECURE_NO_WARNINGS 1

//test.c

#include "List.h"

void test_PushBack(void)
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 5);
	ListPrint(plist);
	ListNode* pos = ListFind(plist, 3);
	ListInsert(pos, 6);
	ListPrint(plist);
	pos = ListFind(plist, 1);
	ListErase(plist, pos);
	ListPrint(plist);

	ListDestroy(&plist);

}

void test_PushFront(void)
{
	ListNode* plist = ListInit();
	ListPushFront(plist, 1);
	ListPushFront(plist, 2);
	ListPushFront(plist, 3);
	ListPushFront(plist, 4);
	ListPushFront(plist, 5);
	ListPrint(plist);
	ListPopFront(plist);
	ListPrint(plist);

	ListPopFront(plist);
	ListPrint(plist);
	ListPopFront(plist);
	ListPrint(plist);
	ListPopFront(plist);
	ListPrint(plist);
	ListPopFront(plist);
	ListPrint(plist);

	ListDestroy(&plist);
}


int main()
{
	test_PushBack();
	//test_PushFront();
	return 0;
}

四、总结

双向链表这个数据结构设计得真的非常的好，无论你想对那个位置进行增删查改的任意操作，效率都比单链表高出一截，用起来非常的爽，就是那么nice，而且它的结构你看起来感觉它很复杂，其实看起来越复杂的东西学起来越省事，因为它的结构啥都有，太完美了，而且结构也就多了一个哨兵位的头节点和一个指向前一个元素的指针罢了，这不比单链表用得更爽？哈哈哈，各有各的好啦！你学会了吗？喜欢的点点赞点点关注呗，后期会持续输出数据结构的相关知识哦，点个关注才能及时学习干货哦，哈哈哈。

Gay~
关注
  • 7
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
【数据结构】—— 双链表的增删改查
周小末天天开心的博客
11-25 1758
双链表基础以及案例演示
数据结构之链表操作（单链表，单向循环链表，双向循环链表）查找节点，插入节点，删除节点，更新节点，新建节点，遍历，清空，判断空链表等操作
qq_45698138的博客
05-16 2016
一、线性表 线性表结构的数据是依次排列（一对一） （1）顺序结构：数组，顺序栈，顺序队列（顺序表） （2）链式存储：链表，链式栈，链式队列（线性表） 二、链表 2.1、链表 ​ 链表是一种具体的数据结构 ​ 1、逻辑上：一对一的排列 ​ 2、存储上：非连续的 ​ 3、算法：查找节点，插入节点，删除节点，更新节点，新建节点，遍历，清空，判断空链表等等 ​ 4、链表分类 ​ 单向链表，双向链表，单向循环链表，双向循环链表 ​ 5、链式存储特点 ​ 不需要一块连续
双向链表实现简单的增删查改
weixin_72868952的博客
01-29 1619
双向带头循环链表——用最复杂的结构完成最简单的工作
【数据结构】链表：带头双向循环链表的增删查改
最新发布
wangduduniubi的博客
05-16 1010
本篇要分享的内容是带头双向链表在刚开始接触链表的时候，我们所学仅仅所学的是单链表，相信大家用C语言学习单链表时也倍受二级指针的折磨。当然单链表只是链表结构内的一种，他的结构非常简单，但是理解并操作起来却非常困难；而我们今天要研究的是链表中结构最复杂，但是理解起来最简单的链表的结构。
双向链表的增删改查
weixin_48856218的博客
03-17 1098
单向链表特点：1.我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的.2.只能从头遍历到尾或者从尾遍历到头(一般从头到尾)双向链表特点1.每次在插入或删除某个节点时, 需要处理四个节点的引用, 而不是两个. 实现起来要困难一些2.相对于单向链表, 必然占用内存空间更大一些.3.既可以从头遍历到尾, 又可以从尾遍历到头双向链表的定义:双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。
双向循环链表、增删查改、判断回文、排序、论文+代码
07-25
C语言 双向循环链表，增删查改，判断回文，排序，论文，代码，自写可用，vs2013，课程设计，答辩
链表的增删查改.rar
05-14
链表的增删查改等基本功能实现代码有注释
家庭账本，链表的增删查改
03-16
利用结构体数组和链表完成增删查改，包括统计个人支出和整月支出，按日期支出等功能。没有特别复杂的数据结构，适合刚学习结构体和链表的学生练手。
C语言如何建立链表并实现增删查改详解
01-01
以下是本人完成的一个C语言建立链表并进行增删查改操作的程序，为方便学习，本人将整个程序分为头文件和主函数两部分： 1.头文件(函数部分) (1)初始化函数 #include #include typedef struct { int *head; int...
带头结点的双向循环链表
07-17
C++实现的带头结点的双向循环链表， 数据结构课设.。
双向循环链表实现增删改查的操作
佳佳鸽的博客
07-23 683
更多资料请点击：我的目录 本篇仅用于记录自己所学知识及应用，代码仍可优化，仅供参考，如果发现有错误的地方，尽管留言于我，谢谢! 此篇是双向循环链表实现增删改查的操作，其中： "增"包括在链尾、链中增加节点 "删"包括在链头、链中、链尾删除单个或多个节点 "改"包括在链头、链中、链尾更改单个或多个节点数值 "查"只是显示整个链表所有节点数值 #include <stdio.h> #include <stdlib.h> //设置节点 struct node { int data;
数据结构双向循环链表的增删
n
04-16 177
创建一个双向链表并实现增加和删除以及求表长 代码如下： #include<string.h> #include<stdlib.h> #include<errno.h> #define OK 1 #define ERROR 0 typedef struct { char name[8]; int id; int score; } student; ty...
双向循环链表基本操作（初始化，插入，删除，清空，销毁，访问前驱，后继等）
wfdtxz的专栏
11-20 9048
#include "stdio.h" #include #define OK 1 #define ERROR 0 #define OVERFLOW -1 #define TRUE 1 #define FALSE 0 typedef int ElemType; ty
（C语言版）链表（四）——实现双向循环链表创建、插入、删除、释放内存等简单操作
热门推荐
菜鸟学C/C++
02-24 1万+
双向循环链表是基于双向链表的基础上实现的，和双向链表的操作差不多，唯一的区别就是它是个循环的链表，通过每个节点的两个指针把它们扣在一起组成一个环状。所以呢，每个节点都有前驱节点和后继节点（包括头节点和尾节点）这是和双向链表不同的地方。我们看下双向循环链表的示意图（我在网上找了张图片，自己画的实在难看，有时间真的要去学下怎么画图了，然后可以写出更好的博客）： 在程序的编写方面呢，双向循环链表有
双向循环链表增删查改C语言实现
m0_53421868的博客
10-11 1204
目录双向链表的结构双向链表的实现双向链表的声明双向链表的实现结点的创建头结点的创建链表的销毁链表的打印链表的尾插链表的尾删链表的头插链表的头删查找指定位置前插入指定位置删除 双向链表的结构 双向链表： 每个结点存在两个指针域，分别存储该结点的前驱结点引用和后继结点引用，从任意一个结点出发，都能通过前驱引用以及后继引用完成整个链表结点的访问。 所以不难看出，单向链表能干的事，双向链表也能干！但是正是因为这一特性，相比于单链表，双向链表在访问其他结点上带来方便的同时，将占用更多的资源，因此在使用的时候可.
双向循环链表增、删、改、查
zillll的博客
04-26 709
双向循环链表增、删、改、查 cycle.c #include<stdio.h> #include<stdlib.h> #include"cycle.h" //先创建一个空的双向循环链表 biList *create(void) { biList *l = malloc(sizeof(*l)); l->first = NULL; return l; } /* 功能：增加一个数据，链表保持升序 参数：@l：头结点;@p：要插入的结点 注意：要考
用java实现双向循环链表的增删改查
刘逸风的博客
03-03 1117
用java实现双向循环链表的增删改查
带头双向循环链表的增删查改
dxzc007的博客
08-13 137
带头双向循环链表的增删查改
单向循环链表的增删查改
04-04
单向循环链表与单向链表类似，只是其尾节点指向头节点，形成了一个循环。因此，它们的增删查改操作也基本相同，只是需要考虑尾节点的特殊情况。 1. 增加节点 在单向循环链表中，增加节点需要考虑两种情况： （1）在链表头部插入节点 首先，创建一个新节点，并将其next指向头节点，然后将尾节点的next指向新节点，最后将头节点指向新节点即可。 （2）在链表尾部插入节点 首先，创建一个新节点，并将尾节点的next指向新节点，然后将新节点的next指向头节点，最后将尾节点指向新节点即可。 2. 删除节点 在单向循环链表中，删除节点需要考虑两种情况： （1）删除头节点 首先，将头节点指向其next节点，然后将尾节点的next指向新的头节点即可。 （2）删除尾节点 首先，找到尾节点的前一个节点，将其next指向头节点，然后将尾节点指向该节点即可。 3. 查找节点 在单向循环链表中，查找节点与单向链表相同，从头节点开始遍历链表，直到找到目标节点或到达尾节点为止。 4. 修改节点 在单向循环链表中，修改节点也与单向链表相同，先查找到目标节点，然后对其数据域进行修改即可。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值