带头结点双链表【详细解析+完整代码】

已于 2023-05-16 16:17:49 修改
阅读量1.1k 收藏 22
点赞数 2
文章标签： 链表 数据结构 算法 c语言 单链表
于 2023-05-16 16:17:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChenLin55/article/details/130704232
版权

C语言双链表

双链表的认识

双链表的定义

单链表的结点中只有一个指向其后继的指针，使得单链表要访问某个结点的前驱结点时，只能从头开始遍历，访问后驱结点的复杂度为O(1)，访问前驱结点的复杂度为O(n)。为了克服上述缺点，引入了双链表。

双链表的结点中有两个指针prior和next，分别指向前驱结点和后继结点。

结点结构:
在这里插入图片描述

带头结点链表结构:
在这里插入图片描述

typedef struct LNode {
	ElemType data;
	struct LNode* next,*prior;
}LNode, * LinkList;

带头结点优点

  • 保证了每个结点都有前驱结点，因此在链表上第一个结点的操作与其他结点操作一致，无需特殊处理
  • 无论链表是否为空，其头指针都是指向头结点的非空指针。可以对空表，非空表的情况进行统一处理。

双链表特点

  • 每个节点都由三部分组成：
    前一个节点的指针prior
    保存的元素data
    后一个节点的指针next

  • 双向链表的第一个节点的prior以及最后节点的next都是NULL

双的操作

初始化

双链表与单链表基本一致，为了操作方便加入头结点，那么初始化双链表其实就是定义一个头结点，然后将前后指针域置空。

bool InitList(LinkList& L) {
	L = (LNode*)malloc(sizeof(LNode));
	if (L == NULL)
	{
		printf("内存不足，分配空间失败");
		return false;
	}
	L->next = NULL;
	L->prior = NULL;
	return true;
}

建立双链表

头插法

思路和单链表头插建表大同小异。创建一个新结点，与头结点想连接。需要注意的是一开始时HeadNode->next = NULL，那么HeadNode->next就没有prior指针域，因此HeadNode->next->prior不用指向NewNode的地址。经过建立第一个结点后，HeadNode->next存在了，因此HeadNode->next->prior指向NewNode的地址。
在这里插入图片描述
如果没考虑到第一个结点的特殊情况，编译器会报错引发了异常: 写入访问权限冲突，
HeadNode->next 是 nullptr。

LinkList List_HeadInsert(LinkList& L) {
	InitList(L);
	int x;
	printf("输入链表元素（以0结束）：\n");
	scanf_s("%d", &x);
	while (x != 0) {
		LNode* head = (LNode*)malloc(sizeof(LNode));
		head->data = x;
		head->next = L->next;
		if(L->next!=NULL)
		   L->next->prior = head;
		head->prior = L;
		L->next = head;
		scanf_s("%d", &x);
	}
	return L;
}

头插法的特点：单链表读入数据的顺序和输出的顺序是相反的，是逆序输出，时间复杂度是o(n)。
但是双链表的遍历输出可以正序也可以逆序，这就不管建表是头插还是尾插都能正序或者逆序输出。

尾插法

尾插法相对于头插法，更简单，因为不用考虑建立第一个结点的特殊情况。方法和单链表的尾插法一直，只是多了结点的prior指针的连接。

在这里插入图片描述

注意：TailNode = NewNode 不要写成 NewNode = TailNode 详情解释参考上一篇单链表的博客

LinkList List_TailInsert(LinkList& L) {
	InitList(L);
	LNode* NewNode, * TailNode = L;
	int x;
	printf("输入链表元素（以0结束）:\n");
	scanf_s("%d", &x);
	while (x != 0) {
		NewNode = (LNode*)malloc(sizeof(LNode));
		NewNode->data = x;
		TailNode->next = NewNode;
		NewNode->prior = TailNode;
		TailNode = NewNode;
		scanf_s("%d", &x);
	}
	TailNode->next = NULL;
	return L;
}

遍历双链表

这是带头结点的链表，所以先找到第一个结点p，p为空则为空链表，然后遍历到尾结点就行。
遍历到尾结点后，又可以利用prior，向前遍历。

void PrintList(LinkList L) {
	LNode* p = L;
	if (!L->next)
		printf("空链表");
	else {
		printf("顺序打印:");
		while (p->next) {
			p = p->next;
			printf("%d ", p->data);
		}
		printf("\n逆序打印:");
		while (p->prior)
		{
			printf("%d ", p->data);
			p = p->prior;
		}
		printf("\n");
	}
}

双链表的长度

思路就是遍历链表，记录遍历次数就是长度。

int Length(LinkList L) {
	LNode* p = L->next;
	int len = 0;
	while (p) {
		p = p->next;
		len++;
	}
	return len;
}

查找操作

按值查找

从链表的第一个结点开始，依次比较表中各个结点的数据域的值，若某结点数据域的值等于x，则返回该结点的指针；若整个单链表中没有这样的结点，则返回空。

LNode* LocateElem(LinkList L, int x) {
	LNode* p = L->next;
	while (p && p->data != x) {
		p = p->next;
	}
	return p;
}

按位查找

从链表的头结点开始，顺着指针域逐个往下搜索，直到找到第 i 个结点为止，否则返回最后一个结点的指针域NULL。

LNode* GetElem(LinkList L, int i) {
	LNode* p = L;
	int j = 0;
	if (i<0 || i>Length(L))
		return NULL;
	else {
		while (j < i)
		{
			p = p->next;
			j++;
		}
	}
	return p;
}

当然你也可以从第一个结点开始，往下搜索。我为了方便后续操作找到头结点，所以是从头结点往下搜索。

插入操作

将值为x的新结点插入到单链表L的第i个位置上。从表头开始遍历，查找第 i-1个结点，即插入位置的前驱结点为p，然后利用前插操作，令新结点s的指针域指向p的后继结点，再令p的后继结点的prior指针域指向新结点s，s的prior指针指向i位置结点的前驱结点，最后p的next指针指向s结点完成插入。

bool Insert(LinkList& L, int i, int x) {
	if (i < 1 || i>Length(L))
		return false;
	LNode* p = GetElem(L, i - 1);
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = x;
	s->next = p->next;
	p->next->prior = s;
	s->prior = p;
	p->next = s;
	return true;
}

在这里插入图片描述

从插入操作就能体现出GetElem函数从头结点往下搜索的好处，它能找到第一个结点的前驱结点(头结点)，因此就不用特殊处理第一个结点了。

删除操作

将单链表的第 i 个结点删除。先检查删除位置的合法性，然后从头开始遍历，找到i结点，可以直接访问前驱和后继结点。修改前驱结点next指向以及后继结点prior的指向最后再释放结点p的存储空间。
在这里插入图片描述

bool Delete(LinkList& L, int i)
{
	if (i<1 || i>Length(L)) {
		printf("输入不合法\n");
		return false;
	}
	LNode* p = GetElem(L, i);
	if (!p) 
		return false;
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free (p);
	return true;
}

完整代码及实例

完整代码

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

typedef int ElemType;

typedef struct LNode {
	ElemType data;
	struct LNode* next,*prior;
}LNode, * LinkList;

bool InitList(LinkList& L) {
	L = (LNode*)malloc(sizeof(LNode));
	if (L == NULL)
	{
		printf("内存不足，分配空间失败");
		return false;
	}
	L->next = NULL;
	L->prior = NULL;
	return true;
}

LinkList List_HeadInsert(LinkList& L) {
	InitList(L);
	LNode* NewNode, * HeadNode = L;
	int x;
	printf("输入链表元素（以0结束）：\n");
	scanf_s("%d", &x);
	while (x != 0) {
		NewNode = (LNode*)malloc(sizeof(LNode));
		NewNode->data = x;
		NewNode->next = HeadNode->next;
		if(HeadNode->next!=NULL)
			HeadNode->next->prior = NewNode;
		NewNode->prior = HeadNode;
		HeadNode->next = NewNode;
		scanf_s("%d", &x);
	}
	return L;
}


LinkList List_TailInsert(LinkList& L) {
	InitList(L);
	LNode* NewNode, * TailNode = L;
	int x;
	printf("输入链表元素（以0结束）:\n");
	scanf_s("%d", &x);
	while (x != 0) {
		NewNode = (LNode*)malloc(sizeof(LNode));
		NewNode->data = x;
		TailNode->next = NewNode;
		NewNode->prior = TailNode;
		TailNode = NewNode;
		scanf_s("%d", &x);
	}
	TailNode->next = NULL;
	return L;
}


//遍历操作
void PrintList(LinkList L) {
	LNode* p = L;
	if (!L->next)
		printf("空链表");
	else {
		printf("顺序打印:");
		while (p->next) {
			p = p->next;		//  头结点数据域为空，因此直接从头结点的下一结点开始遍历
			printf("%d ", p->data);
		}
		printf("\n逆序打印:");
		while (p->prior)
		{
			printf("%d ", p->data);
			p = p->prior;

		}
		printf("\n");
	}
	
}

int Length(LinkList L) {
	LNode* p = L->next;
	int len = 0;
	while (p) {
		p = p->next;
		len++;
	}
	return len;
}

LNode* LocateElem(LinkList L, int x) {
	LNode* p = L->next;
	while (p && p->data != x) {
		p = p->next;
	}
	return p;
}

LNode* GetElem(LinkList L, int i) {
	LNode* p = L;
	if (i<0 || i>Length(L))
		return NULL;
	else {
		for (int j = 0; j < i; j++) {
			p = p->next;
		}
	}
	return p;
}

//将x插入到单链表L的第i个位置上
bool Insert(LinkList& L, int i, int x) {
	if (i < 1 || i>Length(L))
		return false;
	LNode* p = GetElem(L, i - 1);
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = x;
	s->next = p->next;
	p->next->prior = s;
	s->prior = p;
	p->next = s;
	return true;
}

bool Delete(LinkList& L, int i)
{
	if (i<1 || i>Length(L)) {
		printf("输入不合法\n");
		return false;
	}
	LNode* p = GetElem(L, i);
	if (!p) 
		return false;
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free (p);
	return true;
}


int main()
{
	LinkList L;
	InitList(L);
	printf("头插建立链表\n");
	List_HeadInsert(L);
	PrintList(L);
	printf("插入99到第2位\n");
	Insert(L, 2, 99);
	PrintList(L);
	printf("删除第1位\n");
	Delete(L, 1);
	PrintList(L);

	printf("\n\n尾插建立链表\n");
	List_TailInsert(L);
	PrintList(L);
	printf("插入99到第1位\n");
	Insert(L, 1, 99);
	PrintList(L);
	printf("删除第1位\n");
	Delete(L, 1);
	PrintList(L);
}

测试结果

头插建立链表
输入链表元素（以0结束）：
1 2 3 4 5 6 7 0
顺序打印:7 6 5 4 3 2 1
逆序打印:1 2 3 4 5 6 7
插入99到第2位
顺序打印:7 99 6 5 4 3 2 1
逆序打印:1 2 3 4 5 6 99 7
删除第1位
顺序打印:99 6 5 4 3 2 1
逆序打印:1 2 3 4 5 6 99


尾插建立链表
输入链表元素（以0结束）:
1 2 3 4 5 6 7 0
顺序打印:1 2 3 4 5 6 7
逆序打印:7 6 5 4 3 2 1
插入99到第1位
顺序打印:99 1 2 3 4 5 6 7
逆序打印:7 6 5 4 3 2 1 99
删除第1位
顺序打印:1 2 3 4 5 6 7
逆序打印:7 6 5 4 3 2 1
ChenLin55
关注
  • 2
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
带头结点的双向循环链表
07-17
C++实现的带头结点的双向循环链表， 数据结构课设.。
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
03-13
链表 链表_使用C语言实现非循环双向链表_带头结点+尾结点
【数据结构】带头双向循环链表
m0_59292239的博客
11-07 1691
【数据结构】带头双向循环链表具体实现
【数据结构】C语言实现双向链表（带头结点、循环）
SHLYYY
05-10 956
/ 在pos之前插入 void LinkedListInsert(LinkedListNode * pos , ListDataType x);// 删除pos位置的值 void LinkedListErase(LinkedListNode * pos);带头结点、双向、循环链表的实现都非常的简单，需要注意判空条件与遍历终止的条件。在代码写法上，对于某个节点的前一个或后一个的问题，我们最好分别使用变量去记录，这样代码的逻辑更清晰，可读性更高。
双链表（带头结点）
s_ai_yan的博客
03-06 477
通过 `DList_Init` 函数创建带有头结点的双链表，头结点的 `prior` 和 `next` 始终指向 `NULL`。- 使用 `DList_Show` 和 `DList_Show_Back` 函数，分别从头到尾和从尾到头打印链表的所有结点的值。- 通过 `DList_Empty` 函数判断链表是否为空，检查头结点的 `next` 是否为 `NULL`。4. **创建双链表（头插法，带头节点）：**6. **通过值获取结点和位序：**1. **初始化链表：**9. **主函数：**
Day3：数据结构之带头双链表
weixin_46873777的博客
08-09 769
带头双链表前言1、双链表的基本概念2、双链表的好处3、双链表的基本操作头文件定义1. 初始化2. 创建一个新结点3. 打印4. 头插5. 头删6. 尾插7. 尾删8. 查找9. 插入10. 删除11. 销毁总结 目录 目录 顺序表 单链表（不带附加头结点） 双链表（带附加头结点） 今天给大家讲的是双链表 前言 上一节，我们说到单链表，知道了单链表的一些缺点和注意事项，这一节我们来学习双链表，看看双链表是否能完美解决单链表的一些问题。 1、双链表的基本概念 在双链表中有两个指
【初阶数据结构】——带头双向循环链表（C描述）
m0_70980326的博客
11-21 1196
带头双向循环链表详解
【数据结构】——单链表的基本操作（带头结点）
weixin_51398574的博客
07-01 3746
1.在单链表的定义中不能省略结构体名称LNode（第2行中）。原因：在该结构体内部使用到了该结构体类型去定义next指针域。2.第5行中的重命名LNode和*LinkList的意义：//将结构体重命名为LNode//将结构体的指针重命名为LinkList。
双链表及其他链式结构：求双链表的长度
weixin_63381305的博客
10-18 479
题目中输入一个n，然后输入n个值，在createlist()中已挑选出了这n个值中满足条件的元素创建了一个双链表。请你写一个求双链表长度的算法，在主函数调用该算法求出双链表的长度来。
线性表文档之循环双链表
二木成林
04-05 1370
线性表文档之循环双链表
数据结构-带头双向链表的建立，详细教程
weixin_42976474的博客
05-21 640
前言 上一篇文章中我们学习了单链表的实现 本节将带大家学习带头双向链表的实现，希望能够对大家有一些帮助，话不多说，直接开干！！ 文章目录前言一、带头双向链表的概念和结构二. 带头双向链表的接口实现2.1 打印2.2 初始化2.3 开辟节点2.4 尾部插入节点2.5 尾部删除节点2.6 头部插入节点2.7 头部删除节点2.8 查找2.9 在Pos位置前插入2.10 在Pos位置删除2.11 销毁链表总结 一、带头双向链表的概念和结构 概念：带头双向链表是一种 带不存储数据的哨兵卫，循环，双向的一种链表结构
头插法建立双向链表
qq_40741513的博客
07-12 6499
单链表只能向后访问其他节点的数据，若需要寻找某节点前面节点的数据，则需要从表头开始，重新进行遍历，效率不高，为了克服单链表单向性的缺点，可以利用双向链表 双向链表有两个指针域，一个指向直接后继，一个指向直接前驱，头插法建立双链表的方法如下 结构体定义如下 typedef struct DuLNode{ int data; struct DuLNode *prior, *next; }DuLNode, *DuLNode; prior代表前驱，next代表后继 初始化头节点head,
数据结构（使用头插法实现双链表）
DMHY123的博客
07-20 1196
为什么使用双链表？
带头结点双链循环线性表.rar_循环双链表
09-14
带头结点双链循环线性表，数据结构的常用经典算法
C语言实现带头结点的链表的创建、查找、插入、删除操作
09-04
主要介绍了C语言实现带头结点的链表的创建、查找、插入、删除操作方法,对于了解数据结构中链表的各项操作有很好的借鉴价值,需要的朋友可以参考下
带头结点的单向链表的基本操作的实验代码和实验报告
04-14
使用给定数据结构，实现带头结点的单向链表的创建、删除链表、插入结点等操作，每个学生的学号互不相同，学号不同而姓名相同则为不同的学生，每个学生的学号在合并后的链表中不重复，如果出现重复，则删除年龄较小...
数据结构---线性表（顺序表）附代码
最新发布
2302_81153999的博客
04-27 419
假定数组有10个空间，已经使用了5个，向数组中插入数据步骤： 求数组的长度，求数组的有效数据个数，向下标为数据有效个数的位置插⼊数据（注意：这里是否要判断数组是否满了，满了还能继续插⼊吗）..... 假设数据量非常庞大，频繁的获取数组有效数据个数会影响程序执行效率。同理，程序中如果不对数据进行管理，可能会导致数据丢失、操作数据困难、野指针等情况。常见的数值1、2、3、4.....、教务系统里保存的用户信息（姓名、性别、年龄、学历等 ）、网页里肉眼可以看到的信息（文字、图片、视频等等），这些都是数据。
快速排序详解及优化方式
2301_80636143的博客
04-27 634
快速排序的时间复杂度是O(n log n)，其中n为待排序数组的长度。快速排序的每次划分操作需要O(n)的时间复杂度，而递归调用的次数为O(log n)，因此总的时间复杂度为O(n log n)。在最坏的情况下，即数组已经有序的情况下，快速排序的时间复杂度为O(n^2)。
【数据结构】图的应用（最小生成树、拓扑排序、最短路径等）
2201_75475240的博客
04-27 689
本文章介绍数据结构中的图的应用，包括最小生成树的Prim算法和Kruskal算法，拓扑排序和最短路径，且还包含408习题（附有解析）。此外，含有关于Prim算法，Kruskal算法和Dijkstra算法全部具体实现代码。
编写算法逆置一个带头结点的双链表代码c++
05-14
以下是逆置一个带头结点的双链表的C++代码： ```c++ #include <iostream> using namespace std; struct ListNode { int val; ListNode* next; ListNode* prev; ListNode(int x) : val(x), next(NULL), prev(NULL) {} }; ListNode* reverseList(ListNode* head) { if (head == NULL || head->next == NULL) { return head; } ListNode* curr = head->next; ListNode* prev = NULL; while (curr != NULL) { ListNode* next = curr->next; curr->next = prev; curr->prev = next; prev = curr; curr = next; } head->next = prev; head->next->prev = NULL; return head; } int main() { ListNode* head = new ListNode(-1); ListNode* tail = head; for (int i = 1; i <= 5; i++) { ListNode* node = new ListNode(i); tail->next = node; node->prev = tail; tail = node; } cout << "Original list: "; ListNode* curr = head->next; while (curr != NULL) { cout << curr->val << " "; curr = curr->next; } cout << endl; head = reverseList(head); cout << "Reversed list: "; curr = head->next; while (curr != NULL) { cout << curr->val << " "; curr = curr->next; } cout << endl; return 0; } ``` 这里使用了双指针法，通过一个 `prev` 指针和一个 `curr` 指针来逆置链表。同时需要注意一些细节，比如链表头结点的处理和指针的赋值顺序等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值