双链表的基本操作

最新推荐文章于 2024-08-05 09:00:00 发布
最新推荐文章于 2024-08-05 09:00:00 发布
阅读量862 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Eccentric_Lee/article/details/121039922
版权

循环双链表


**前言：**双链表可以分为带头的双链表和不带头的双链表
而本次是针对带头的循环双链表的基本操作：

定义链表中元素的数据类型：

typedef int LTDataType;

定义链表的基本结构：

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

初始化双链表：

LTNode* ListInit() {

	//申请头结点
	LTNode* phead = (LTNode *)malloc(sizeof(LTNode));
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

打印双链表中的元素：

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

申请一个新结点：

LTNode* BuyListNode(LTDataType x) {
	LTNode* newnode = (LTNode *)malloc(sizeof(LTNode));

	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	

	return  newnode;
}

双链表中进行后插操作：

void ListPushBack(LTNode *phead, LTDataType x) {
	assert(phead);
	LTNode *newnode = BuyListNode(x);
	LTNode *tail = phead->prev;

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

双链表中进行后删操作：

void ListPopBack(LTNode *phead) {
	assert(phead);
	assert(phead->next);
	LTNode *tail = phead->prev;

	phead->prev = tail->prev;
	tail->prev->next = phead;
	free(tail);
	tail = NULL;
}

双链表中进行前插操作：

void ListPushFront(LTNode *phead, LTDataType x) {
	assert(phead);
	LTNode* newnode = BuyListNode(x);
	LTNode *cur = phead->next;

	newnode->next = cur;
	newnode->prev = phead;
	phead->next = newnode;
	cur->prev = newnode;
}

双链表中进行前删操作：

void ListPopFront(LTNode* phead) {
	assert(phead);
	assert(phead->next != phead);
	LTNode* cur = phead->next;
	phead->next = cur->next;
	cur->next->prev = phead;
	free(cur);
	cur = NULL;
}

双链表中找特定值为x的结点：

LTNode* ListFind(LTNode* phead, LTDataType x) { //找结点
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead) {
		if (cur->data == x) {
			return cur;
		}
		else {
			cur = cur->next;
		}
	}
	return NULL;
}

双链表中在特定结点前插入一个结点：

void ListInsert(LTNode* pos, LTDataType x) {
	assert(pos);
	LTNode* posPrev = pos->prev;
	LTNode* newnode = BuyListNode(x);

	posPrev->next = newnode;
	newnode->next = pos;
	newnode->prev = posPrev;
	pos->prev = newnode;
}

双链表中删除结点：

void ListErase(LTNode* pos) {
	assert(pos);

	LTNode* posPrev = pos->prev;
	LTNode* posNext = pos->next;

	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
	pos = NULL;
}

销毁链表：

void ListDestroy(LTNode* phead) {
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead) {
		LTNode* curNext = cur->next;
		free(cur);
		cur = curNext;
	}
	free(phead);
	phead = NULL;
}

双链表中增删的优化：

在基本的功能实现后我们可以看到代码其实是具有耦合性的，我们可以对双链表的增删进行优化：

后插操作：

void ListPushBack(LTNode* phead, LTDateType x)
{
	assert(phead);
	ListInsert(phead, x);
}

前插操作：

void ListPushFront(LTNode* phead, LTDateType x)
{
	assert(phead);
	ListInsert(phead->next, x);
}

后删操作：

void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);
	ListErase(phead->prev);
}

前删操作：

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);
	ListErase(phead->next);
}

VS中代码：

DList.h头文件：

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

typedef int LTDataType;

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

LTNode* ListInit();
void ListDestroy(LTNode *phead);
void ListPrint(LTNode *phead);

LTNode *BuyListNode(LTDataType);
void ListPushBack(LTNode* phead, LTDataType x);
void ListPopBack(LTNode* phead);
void ListPushFront(LTNode* phead, LTDataType x);
void ListPopFront(LTNode* phead);

LTNode* ListFind(LTNode* phead, LTDataType x);

void ListInsert(LTNode* pos, LTDataType x);
void ListErase(LTNode* pos);

DList.c源文件：

#include"DList.h"

LTNode* ListInit() {

	//申请头结点
	LTNode* phead = (LTNode *)malloc(sizeof(LTNode));
	phead->next = phead;
	phead->prev = phead;

	return phead;
}
LTNode* BuyListNode(LTDataType x) {
	LTNode* newnode = (LTNode *)malloc(sizeof(LTNode));

	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	

	return  newnode;
}
void ListPrint(LTNode *phead) {
	assert(phead);
	LTNode* cur = phead;
	while (cur->next!=phead) {
		cur = cur->next;
		printf("%d ", cur->data);
	}
	printf("\n");
}
void ListPushBack(LTNode *phead, LTDataType x) {
	assert(phead);
	LTNode *newnode = BuyListNode(x);
	LTNode *tail = phead->prev;

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

void ListPopBack(LTNode *phead) {
	assert(phead);
	assert(phead->next);
	LTNode *tail = phead->prev;

	phead->prev = tail->prev;
	tail->prev->next = phead;
	free(tail);
	tail = NULL;
}
void ListPushFront(LTNode *phead, LTDataType x) {
	assert(phead);
	LTNode* newnode = BuyListNode(x);
	LTNode *cur = phead->next;

	newnode->next = cur;
	newnode->prev = phead;
	phead->next = newnode;
	cur->prev = newnode;
}

void ListPopFront(LTNode* phead) {
	assert(phead);
	assert(phead->next != phead);
	LTNode* cur = phead->next;
	phead->next = cur->next;
	cur->next->prev = phead;
	free(cur);
	cur = NULL;
}

LTNode* ListFind(LTNode* phead, LTDataType x) { //找结点
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead) {
		if (cur->data == x) {
			return cur;
		}
		else {
			cur = cur->next;
		}
	}
	return NULL;
}
void ListInsert(LTNode* pos, LTDataType x) {
	assert(pos);
	LTNode* posPrev = pos->prev;
	LTNode* newnode = BuyListNode(x);

	posPrev->next = newnode;
	newnode->next = pos;
	newnode->prev = posPrev;
	pos->prev = newnode;
}

void ListErase(LTNode* pos) {
	assert(pos);

	LTNode* posPrev = pos->prev;
	LTNode* posNext = pos->next;

	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
	pos = NULL;
}

void ListDestroy(LTNode* phead) {
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead) {
		LTNode* curNext = cur->next;
		free(cur);
		cur = curNext;
	}
	free(phead);
	phead = NULL;
}

main.c源文件：

#include"DList.h"
int main() {
	LTNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushFront(plist, 0);
	ListPrint(plist);
	ListPopBack(plist);
	ListPopFront(plist);
	ListPrint(plist);
	LTNode* pos = ListFind(plist, 1);//如果找到就删除这个数
	if (pos) {
		ListInsert(pos, 5);
		ListInsert(pos, 6);
		ListErase(pos);

	}
	ListPrint(plist);
	ListDestroy(plist);
	plist = NULL;
	return 0;
}

顺序表和链表的优缺点的对比：

顺序表：

优点：
  • 支持随机访问，需要随机访问结构支持算法可以很好的运用。
  • CPU高速缓存命中率高
缺点：
  • 头部中部插入删除的时间复杂度高：O(n)
  • 连续的物理地址存储空间，空间不够时，学要开辟连续的空间，代价比较大。
  • 可能造成一定的空间浪费

链表：

优点：
  • 任意位置插入或者删除的时间效率高：O(1)
  • 可以根据自己的需求进行申请和释放空间。
缺点：
  • 不支持随机访问（用下标访问），意味着一些排序，二分查找在此结构中不适用。
  • 链表中存储一个值的同时也要存储连接指针，同时也有一定的消耗。
  • CPU高速缓存的命中率更低。
Eccentric_Lee
关注
专栏目录
双向链表基本操作(C语言)
weixin_46503238的博客
04-29 3214
#include <stdio.h> #include <stdlib.h> #include<stdbool.h> //双向链表 typedef int Elemtype; typedef struct DNode { Elemtype data; struct DNode *prior,*next; } DNode,*DLinkList; //尾插法创建链表 DLinkList CreateList() { int x; DLin
数据结构双链表基本操作（C/C++实现）
JunsIr的技术栈
10-22 1634
数据结构双链表基本操作（C/C++实现） 注意：本代码为了测试运行默认含有操作所需数据，如有需要可自己增删改相关数据 涉及基本运算 初始化双链表 依次采用尾插法插入元素 输出双链表 输出双链表的长度 判断双链表是否为空 输出双链表的第n个元素 输出元素x的位置 在第n个元素位置上插入x元素 输出双链表 删除双链表的第n个元素 输出双链表 释放双链表 GitHub地址（包含.cpp文件和可执行程...
双链表的基本操作（创建，插入，删除，读取等）
10-29
双链表基本操作的程序，（先在主程序内定义一个数组，再把数组内的元素作为结点一个个插入到链表内，显示链表内所有结点及链表长度，删除某一个结点，再次显示链表内所有结点以及链表长度）。
数据结构——双链表详解（超详细）
最新发布
effort123_的博客
08-05 470
哨兵位这个名字看起来是很威武的，其实了解它之后就知道它仅仅就是名字威武点，它才是真正意义上的头结点，哨兵位是不存数据的，它的存在仅仅就是为了说明这个链表是带头的，是用来“放哨的”，小编在讲述单链表的时候曾多次提到了头结点这个名字，那个时候头结点是链表第一个结点，这个叫法是不太规范的，不过为了让读者朋友更好的去理解链表的知识，小编于是就直接头结点来代替链表第一个结点了，不过各位读者朋友一定要清楚。下面紧跟小编的步伐，开启今天的双链表之旅！
双向链表的基本操作
XGTTTTT011的博客
04-16 1470
双向链表的基本操作，今天先写到这里，有机会再写一下循环链表，明天写栈和队列。
双向链表及其基本操作
10-29
C语言，实现双向链表以及其基本操作，基本操作：链表初始化、创建、查询、删除、释放，查询和删除均有两种方式，一种是按照值，另一种是按照结点的序号。
双向链表基本操作.cpp
10-17
双向链表基本操作.cpp
双链表基本操作
致宁的大博客！
10-18 161
#define _CRT_SECURE_NO_WARNINGS #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct Head *PHead; typedef struct Node *PNode; struct Head { //头结点 int length; PNode next; }; struct N...
数据结构双链表基本操作
09-16
双向链表的基本操作包括：判断链表是否为空、计算链表的长度、遍历链表。判断链表是否为空和计算链表的长度的方法和单链表一样，主要和双向链表中的指向后继的指针有关。遍历链表时，需要遍历指向后继的指针和指向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值