[数据结构]---带头双向循环链表基本功能实现及与单链表,顺序表区别

最新推荐文章于 2023-09-11 15:16:50 发布
最新推荐文章于 2023-09-11 15:16:50 发布
阅读量189 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41300114/article/details/101059817
版权
本文介绍了带头双向循环链表的增删查改功能实现，包括初始化、申请结点、销毁、尾插、尾删、头插、头删、查找、插入和删除操作。强调了该链表结构在操作上的便利性，时间复杂度为O(1)，并对比了顺序表和单链表，认为在现代计算机中，应优先考虑效率而非空间复杂度。
摘要由CSDN通过智能技术生成

带头双向循环链表增删查改实现

实现功能:

//初始化
void ListInit(List* plist);

//申请结点
ListNode* BuyListNode();

//销毁
void ListDestory(List* plist);

//尾插
void ListPushBack(List* plist, LTDataType x);

//尾删
void ListPopBack(List* plist);

//头插
void ListPushFront(List* plist, LTDataType x);

//头删
void ListPopFront(List* plist);

//查找
ListNode* ListFind(List* plist, LTDataType x);

// 在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);

// 删除pos位置的节点
void ListErase(List*plist,ListNode* pos);

//打印
void ListPrint(List* plist);

//List.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//带头双向循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType _data;
	struct ListNode* _next;
	struct ListNode* _prev;
}ListNode;

typedef struct List
{
	ListNode* _head;
}List;

//初始化
void ListInit(List* plist);

//申请结点
ListNode* BuyListNode();

//销毁
void ListDestory(List* plist);

//尾插
void ListPushBack(List* plist, LTDataType x);

//尾删
void ListPopBack(List* plist);

//头插
void ListPushFront(List* plist, LTDataType x);

//头删
void ListPopFront(List* plist);

//查找
ListNode* ListFind(List* plist, LTDataType x);

// 在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);

// 删除pos位置的节点
void ListErase(List*plist,ListNode* pos);

//打印
void ListPrint(List* plist);

//List.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "List.h"

//初始化
void ListInit(List* plist)
{
	plist->_head = BuyListNode(-1);
	plist->_head->_next = plist->_head;
	plist->_head->_prev = plist->_head;
}

//申请新的结点
ListNode* BuyListNode(LTDataType x)
{
	ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
	//判断分配是否成功
	assert(newNode);
	newNode->_data = x;
	newNode->_next = NULL;
	newNode->_prev = NULL;
	return newNode;
}


//销毁
void ListDestory(List* plist)
{
	assert(plist);
	ListNode* tmp;
	tmp = plist->_head->_next;
	//不能先释放头结点,防止二次释放
	while (tmp!=plist->_head)
	{
		ListNode* next = tmp->_next;
		tmp = next;
	}
	//最后释放
	free(plist->_head);
	plist->_head = NULL;
}

// 在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);

	ListNode* newnode = BuyListNode(x); // 申请新结点
	ListNode* prev = pos->_prev; // pos前一个结点

	prev->_next = newnode; // 连接pos前一个结点和新结点
	newnode->_prev = prev;

	pos->_prev = newnode; // 连接pos和新结点
	newnode->_next = pos;

}

//头插
void ListPushFront(List* plist, LTDataType x)
{
	assert(plist);
	//头插和在第一个结点前面插入一样
	ListInsert(plist->_head->_next, x);
	//ListNode* next;
	//ListNode* newNode = BuyListNode(x);
	//next = plist->_head->_next;
	//plist->_head->_next = newNode;
	//newNode->_prev = plist->_head;
	//newNode->_next = next;
	//next->_prev = newNode;
}

//尾插
void ListPushBack(List* plist, LTDataType x)
{
	assert(plist);
	尾插和在头结点前面插入一个结点一样
	ListInsert(plist->_head, x);
	//ListNode* tail;
	//ListNode* newNode =BuyListNode(x) ;
	//tail = plist->_head->_prev;
	//tail->_next = newNode;
	//newNode->_prev = tail;
	//newNode->_next = plist->_head;
	//plist->_head->_prev = newNode;
}

// 删除当前pos位置的节点
void ListErase(List*plist,ListNode* pos)
{
	ListNode*prev, *next;
	assert(pos && plist);
	//注意空链表
	if (plist->_head == pos)
		return;

	prev = pos->_prev;
	next = pos->_next;
	prev->_next = next;
	next->_prev = prev;
	free(pos);
	pos = NULL;
}

//头删
void ListPopFront(List* plist)
{
	//assert(plist);
	//等于删除头结点后面的结点
	ListErase(plist,plist->_head->_next);
	//ListNode* ret,*next;
	不能删掉头节点
	//if (plist->_head = plist->_head->_next)
	//	return;
	//next = plist->_head->_next;
	//ret = next->_next;
	//plist->_head->_next = ret;
	//ret->_prev = plist->_head;
	//free(next);
	//next = NULL;
}

//尾删
void ListPopBack(List* plist)
{
	//assert(plist);
	//等于删除头结点前面的结点
	ListErase(plist,plist->_head->_prev);
	//ListNode* ret,*tail;
	注意不能删掉头节点
	//if (plist->_head == plist->_head->_next)
	//	return;
	//tail = plist->_head->_prev;
	//ret = tail->_prev;

	//ret->_next = plist->_head;
	//plist->_head->_prev = ret;
	//free(tail);
	//tail = NULL;
}

//查找
ListNode* ListFind(List* plist, LTDataType x)
{
	ListNode* NewNode;
	assert(plist);
	NewNode = plist->_head;
	while (NewNode->_next!=plist->_head)
	{
		NewNode = NewNode->_next;
		if(NewNode->_data==x)
		{
			return NewNode;
		}
	}
	printf("不存在此结点\n");
	return NULL;
}

//打印
void ListPrint(List* plist)
{
	assert(plist);
	//头不存放数据,所以直接指向头的下一个结点
	ListNode* ret=plist->_head->_next;
	while (ret!=plist->_head)
	{
		printf("%d  ", ret->_data);
		ret = ret->_next;
	}
	printf("\n");
}

注意:实现功能部分进行了必要的代码复用,注释中包含了不用进行复用时的写法

//ListTest.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "List.h"

int main()
{
	List phead;
	//ListNode* ret;
	ListInit(&phead);
	ListPushFront(&phead, 3);
	ListPushFront(&phead, 2);
	ListPushFront(&phead, 1);
    ListPushBack(&phead, 4);
	ListPushBack(&phead, 5);
	//ListPrint(&phead);//1 2 3 4 5
	ListPopBack(&phead);
	ListPopBack(&phead);
	ListPopBack(&phead);
	ListPopBack(&phead);
	ListPopBack(&phead);
	ListPopBack(&phead);
	//ListPopFront(&phead);
	//ListPopFront(&phead);
	//ListPopFront(&phead);
	//ListPopFront(&phead);
	//ListPopFront(&phead);
	//ListPopFront(&phead);
	//ret = ListFind(&phead, 3);
	//printf("%d\n", ret->_data);
	//ListPopBack(&ret);
	ListPrint(&phead);//2 4
	ListDestory(&phead);
	system("pause");
	return 0;
}

通过练习带头双向循环链表,我们不难发现这种结构进行操作时十分方便,因为无论给出哪一个节点我们都可以通过prev或者next指针直接拿到我们所需要的数据,操作时间复杂度为O(1),避免了对链表进行遍历.

   图片来源于: https://blog.csdn.net/belonghwl/article/details/100835387

对比前面的顺序表,单链表,还有今天看的双链表来看,如果我们有要去完成一个任务,假设以上三种数据结构我们都可以使用并完成任务,那么个人觉得使用顺序:顺序表>双链表>单链表. 因为现代计算机已经在存储大小方面远远优胜于之前的计算机,因此内存占用大小(空间复杂度)已经没有那么重要,更重要的关注的是效率(时间复杂度).

 

 

夜微雨
关注
专栏目录
数据结构— 循环链表、双向链表【插入&删除】、双向循环链表
四季轮换叶，一路招摇胜
03-31 5699
循环链表也称为环形链表，其结构与单链表相似，只是将单链表的首尾相连。将最后一个结点的后继指针指向第一个结点。
【数据结构】单链表详解-无头单向不循环链表
p2141548684的博客
05-20 453
链表是一种物理存储上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。单链表、双链表和循环链表。单向、双向、带头、不带头、循环、不循环。链表的八种带头单向循环链表、带头单向非循环链表、带头双向循环链表、带头双向非循环链表、无头单向循环链表、无头单向非循环链表、无头双向循环链表、无头双向非循环链表。
数据结构--带头双向循环链表的基本功能实现
【Dyson】的博客
08-18 316
带头双向循环链表 : 是一种无死角链表, 是链表的一种，带有头结点, 其次它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点 , 且它的头指向尾 , 尾指向头 , 是循环的 , 是双向的 , 是带头结点的 , 基本结构如下图所示 :                                   ...
c语言实现双向循环链表以及部分函数功能
qq_43581695的博客
04-15 426
双向链表的结点里包含一个指向上一个元素的pre指针，一个指向下一个元素的next指针，而要实现循环只需要将头节点的pre指向最后一个节点，而最后后一个节点的next指向头节点。下面是代码实现部分。 首先时头文件部分 #pragma once #include <stdlib.h> #include <stdio.h> #include <assert.h&g...
双链表（双向带头循环链表）
L_R
09-17 593
双向链表 双向链表也叫双链表，是链表中的一种。它的每个数据结点中都有两个指针，分别指向直接前驱和直接后继，所以从链表的任意一个结点都可以很方便的访问到它的前驱结点和后继结点，一般我们都构造双向循环链表。 带头结点和不带头结点 　　其实这个带头结点和不带头结点在单链表那篇博客中就应该提的，但是我放在这里，原因是，本篇主要介绍带头结点的双向循环链表。在这里结合例子介绍会更加清楚一些。 那么...
單鏈錶、雙向鏈錶節點的掛接與摘除
weixin_33924312的博客
06-16 59
------------------------單鏈錶#include <stdio.h>#include <stdlib.h>typedef struct node *link;struct node{ unsigned int item; link next;};static link head=NULL;link make_node(...
数据结构：线性表之-循环双向链表(万字详解)
最新发布
2301_77649794的博客
09-11 2634
双向链表（Doubly Linked List）是一种常见的链表数据结构。它与普通链表的区别在于，每个节点都有两个指针，一个指向前一个节点，一个指向后一个节点，因此可以从任意一个节点开始，双向遍历整个链表。双向链表的节点通常由三部分组成：数据部分（存储节点的值）、前驱指针（指向前一个节点的指针）和后继指针（指向后一个节点的指针）。相比于单向链表，双向链表可以更方便地进行正反向遍历和节点的插入、删除操作。
漫话数据结构-单循环链表及基本操作.pptx
11-03
数据结构是计算机科学中的核心概念，它涉及到如何高效地存储和处理数据。...在理解和掌握了各种数据结构如顺序表、单链表和单循环链表的特性后，我们可以根据需要选择最适合的数据结构来优化我们的算法和程序。
图解无头单向非循环链表和带头双向循环链表
zhaocx111222333的博客
01-17 790
图解无头单向非循环链表和带头双向循环链表单链表(单向不带头)数据节点和头结点新增节点函数和初始化基本操作1.尾插2.尾删3.头插4.头删5.任意位置新增节点6.任意位置删除7.寻找数据8.销毁链表带头双向循环链表数据节点和头节点新增节点函数和初始化基本操作(删除和增加)1.尾插2.尾删3.头插4.头删5.在任意位置删除6.在任意位置增加 链表是一种重要的数据结构,其概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链 接次序实现的 。 这里介绍两种链表: 无头单
【 C# 】（一） --------- 泛型带头节点的单链表，双向链表实现
爱喝柠檬的二哈的博客
09-24 641
在编程领域，数据结构与算法向来都是提升编程能力的重点。而一般常见的数据结构是链表，栈，队列，树等。事实上C#也已经封装好了这些数据结构，在头文件 System.Collections.Generic 中，直接创建并调用其成员方法就行。不过我们学习当然要知其然，亦知其所以然。 本文实现的是链表中的单链表和双向链表，并且实现了一些基本方法 一. 定义一个链表接口 MyList 接口里声明了...
【数据结构】单向链表,单向循环链表,双向循环链表
weixin_33850890的博客
08-03 234
单向链表 头文件 1 //@　author　成鹏致远 2 //@　net http://infodown.tap.cn 3 //@　qq 552158509 4 //@ blog　lcw.cnblogs.com 5 6 #ifndef _LINKLIST_H 7 #define _LINKLIST_H 8 9 #include &lt;stdio....
PTA 带头节点的双向循环链表操作
void的博客
06-24 3545
题目要求：读入一系列整数，依次插入到双向循环链表的头部和尾部，然后顺序和逆序输出链表。 输入格式: 输入一行整数（空格分隔），以-1结束。 输出格式: 第一行输出链表顺序遍历的结果，第二行输出逆序遍历的结果。 输入样例: 在这里给出一组输入。例如： 1 2 3 4 5 6 -1 输出样例: 5 3 1 2 4 6 6 4 2 1 3 5 import java.util.Scanner; // 链表节点 class Node{ int val; Node pre; Node next; Nod
用头指针表示的双向循环链表一些基本操作实现（带头节点）
qq_31239371的博客
05-11 1062
//用头指针表示的双向循环链表的一些基本操作实现（带头节点） #include <stdio.h> #include <stdlib.h> #include <iostream> using namespace std; #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define MaxSize 100 .
循环链表的基本运算
weixin_45770021的博客
05-27 288
#include<iostream.h> typedef char ElemType; typedef struct DNode { ElemType data; struct DNode *prior; struct DNode *next; }linklist; //1.初始化链表 void chushi(linklist *L) { L=new linklist; L->next=NULL; } //2.建立链表 void jianli(linklist *&L,ElemTy
(PTA编程题解答)定义单向链表：输入若干个正整数（输入-1为结束标志），要求按输入数据的逆序并输出。
热门推荐
王琪琛
04-20 2万+
原题如下：7-1 单向链表4（10 分）定义单向链表：输入若干个正整数（输入-1为结束标志），要求按输入数据的逆序并输出。输入输出示例：括号内为说明输入样例:1 2 3 4 5 6 7 -1 输出样例:7 6 5 4 3 2 1答案解析如下：#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef int ElemType;//声明定义...
带头结点的双向链表操作
c0re的博客
09-05 537
本题目要求读入一系列整数，依次插入到双向循环链表的头部和尾部，然后顺序和逆序输出链表。链表节点类型可以定义为链表类型可以定义为初始化链表的函数可声明为分配节点的函数可声明为头部插入的函数可声明为尾部插入的函数可声明为顺序遍历的函数可声明为逆序遍历的函数可声明为。
双向链表及循环链表
weixin_44129779的博客
05-13 164
双向链表及循环链表 双向链表 双链表和单链表相比，多了一个指向尾指针（tail），双链表的每个结点都有一个头指针head和尾指针tail,双链表相比单链表更容易操作，双链表结点的首结点的head指向为null，tail指向下一个节点的tail;尾结点的head指向前一个结点的head，tail 指向为null，是双向的关系 双向链表代码 import java.util.Iterator; p...
pta线性表
Stella218的博客
11-22 588
7-1一元多项式求导 设计函数求一元多项式的导数。 #include<iostream> using namespace std; struct Node { int data; Node* next; }; Node* lend = NULL;//定义一个指针，一直指向最后一个节点 void Insert(int data) { Node* p = new Node;//分配内存，把新节点存入当前链表里 p->data = data; p->next = N.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值