1.3 双链表

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

这一章是有关双链表的算法分析和代码实现。
双链表的结点数据结构：

/*双链表结点的数据结构*/
typedef struct DNode {
	ElemType data;						//数据域
	struct DNode* prior;				//前驱指针
	struct DNode* next;					//后继指针
}DNode, *DLinkList;

主要有以下实现功能的函数：

  1. DLinkList CreateListbyHeadInsert(DLinkList& L)) 功能：头插法建立双链表（逆向建立双链表）；
    参数：L:链表；
    时间复杂度：O(n);

  2. DLinkList CreateListbyTailInsert(DLinkList& L) 功能：尾插法建立双链表（正向建立双链表）；
    参数：L:链表；
    时间复杂度：O(n)；

  3. DNode* GetNode(DLinkList& L, int i) 功能：按位查找，拿到第i个位置的结点并返回；
    参数：L:链表 , i:要查找的结点的位置;
    时间复杂度：O(n);

  4. DNode* LocateNode(DLinkList L, ElemType e) 功能：按值查找,查找第一个数据域和e相等第结点并返回；
    参数：L:链表，e:要查找的结点的值；
    时间复杂度：O(n)；

  5. bool DNodeInsert(DLinkList& L, int i, ElemType e) 功能：插入结点，在第i个位置插入一个结点；
    参数：L:链表 ，i:插入的位置，e:插入结点的值
    时间复杂度：O(n);

  6. bool DNodeDelete(DLinkList& L, int i) 功能：删除结点,删除第i个结点；
    参数：L:链表，i:删除结点的位置；
    时间复杂度：O(n);

  7. bool DNodeRevise(DLinkList& L, int i, ElemType e) 功能：修改结点,将第i个结点的数据修改为e；
    参数：L:链表，i:要修改的结点位置，e:要改成的值；
    时间复杂度：O(n)；

  8. int LinkLength(DLinkList L) 功能：求表长；
    参数：L:链表；
    时间复杂度：O(n)；

  9. void PrintList(DLinkList L) 功能：输出所有结点的值；
    参数：L:链表；
    时间复杂度：O(n);

图解：
（1）双链表初始化
双链表初始化
（2）头插法建立双链表
在头插法建立双链表中，p指向头结点，s指向新插入的结点。每次插入新结点都要进行的步骤有：

 		s->next = p->next;				
		if(p->next)						
			p->next->prior = s;
		s->prior = p;
		p->next = s;

这里需要注意的是在执行“p->next->prior = s”前要进对p->next是否存在进行判断，若不存在可能会导致NULL->prior的空指针错误。
比如下图中，插入第一个结点时p->next就不存在，自然就不执行“p->next->prior = s”了。
头插法建立双链表
运行结果

（3）尾插法建立双链表
在尾插法建立双链表中，r指向表尾结点，s指向新插入的结点。每次插入新结点都要进行的步骤有：

s->prior = r;
s->next = NULL;
r->next = s;
r = s;

需要注意的是不要忘了将s->next指向NULL。以及每次最后一步都要移动表尾结点指针r;
尾插法建立双链表
运行结果

完整代码：

#include<cstdio>
#include<cstdlib>
#include<iostream>

#define ElemType int

/*--------------------------------------------------------数据结构部分--------------------------------------------------------*/

/*双链表结点的数据结构*/
typedef struct DNode {
	ElemType data;						//数据域
	struct DNode* prior;				//前驱指针
	struct DNode* next;					//后继指针
}DNode, *DLinkList;

/*初始化双链表*/
void InitList(DLinkList& L) {
	L = new DNode;
	L->next = NULL;
	L->prior = NULL;
}

/*头插法建立双链表*/
DLinkList CreateListbyHeadInsert(DLinkList& L) {
	InitList(L);
	int x;
	DNode* s;
	DNode* p = L;
	scanf("%d", &x);
	while (x!=9999)
	{
		s = new DNode;
		s->data = x;
		s->next = p->next;				//注意这里的顺序
		if(p->next)						//判断p->next是否为空，若为空则不用执行下一步代码，否则NULL->prior会出错
			p->next->prior = s;
		s->prior = p;
		p->next = s;
		scanf("%d", &x);
	}
	return L;
}

/*尾插法建立双链表*/
DLinkList CreateListbyTailInsert(DLinkList& L) {
	InitList(L);						//初始化
	int x;
	DNode* s, * r = L;					//r为表尾指针，指向双链表最后一个结点
	scanf("%d", &x);
	while (x != 9999)					//输入9999结束
	{
		s = new DNode;
		s->data = x;
		s->prior = r;
		s->next = NULL;
		r->next = s;
		r = s;
		scanf("%d", &x);
	}
	return L;
}

/*按位查找，拿到第i个位置的结点并返回*/
DNode* GetNode(DLinkList& L, int i) {
	int j = 1;								//计数，初始为1
	DNode* p = L->next;						//头结点赋值给p
	if (i == 0)								//若i == 0 则返回头结点
		return L;
	if (i < 1)								//若i无效则返回NULL
		return NULL;
	while (p && j < i)						//从第一个结点开始找，找到第i个结点
	{										//在p == NULL(表遍历结束)或j == i(已找到第i个结点)时跳出循环
		p = p->next;
		j++;
	}
	return p;								//返回第i个结点的指针，若i大于表长返回NULL
}

/*按值查找,查找第一个数据域和e相等第结点并返回*/
DNode* LocateNode(DLinkList L, ElemType e) {
	DNode* p = L->next;
	while (p != NULL && p->data != e)		//从第1个结点开始查找data为e的结点
	{
		p = p->next;						//移动结点指针
	}
	return p;								//找到后返回该节点的指针，否则返回NULL
}

/*插入结点，在第i个位置插入一个结点*/
bool DNodeInsert(DLinkList& L, int i, ElemType e) {
	DNode* s;
	DLinkList p = L;
	p = GetNode(L, i - 1);					//查找插入位置的前驱结点
	if (!p)									//p == NULL未找到，返回false
		return false;
	s = new DNode;							//插入结点
	s->data = e;
	s->next = p->next;						//s->next指向原来p的下一个结点
	if (p->next)							//和头插法建立双链表同理
		p->next->prior = s;
	s->prior = p;							//s->prior指向它的前一个结点p
	p->next = s;							//p->next指向新增的s结点
	return true;
}

/*删除结点,删除第i个结点*/
bool DNodeDelete(DLinkList& L, int i) {
	DNode* q;
	DLinkList p = L;
	p = GetNode(L, i - 1);					//查找删除位置的前驱结点
	if (!p)									//未找到第i个位置的前驱结点，返回false
		return false;
	q = p->next;							//q指向被删除结点
	if (!q)									//边界判断：第i个位置有前驱结点，但是不存在第i个位置的结点，返回false
		return false;
	q = p->next;							//q指向被删除结点
	p->next = q->next;						//将*q结点从链中断开
	if(q->next)								//判断要删除的第i个结点有无后继结点
		q->next->prior = p;
	free(q);								//释放结点的存储空间
	return true;
}

/*修改结点,将第i个结点的数据修改为e*/
bool DNodeRevise(DLinkList& L, int i, ElemType e) {
	DLinkList p = L;
	p = GetNode(L, i);						//拿到要修改的结点
	if (!p || i == 0)						//结点不能为空，不能修改头结点
		return false;
	p->data = e;							//修改结点的值
	return true;
}

/*求表长并返回*/
int LinkLength(DLinkList L) {
	DNode* p = L->next;						//头节点不存放数据，不算长度
	int sum = 0;
	while (p)
	{
		p = p->next;						//移动结点指针
		sum++;
	}
	return sum;								//返回表长
}


/*打印表*/
void PrintList(DLinkList L) {
	DNode* p = L->next;					//判断是否表空
	if (!p)
		printf("表空\n");
	else {
		printf("双链表数据：\n");
		while (p) {
			printf("%d  ", p->data);
			p = p->next;
		}
		printf("\n共%d个元素\n", LinkLength(L));
	}
}

/*--------------------------------------------------------功能函数部分--------------------------------------------------------*/
/*插入结点的功能*/
void Insert(DLinkList& L) {
	int location;
	ElemType elem;
	printf("输入要插入的元素：");
	scanf("%d", &elem);
	printf("要插入的位置：");
	scanf("%d", &location);
	if (DNodeInsert(L, location, elem))
		printf("插入成功\n");
	else
		printf("插入失败\n");
}

/*删除结点的功能*/
void Delete(DLinkList& L) {
	int location;
	printf("输入要删除的元素的位置：");
	scanf("%d", &location);
	if (DNodeDelete(L, location))
		printf("删除成功\n");
	else
		printf("删除失败\n");
}

/*修改结点的功能*/
void Revise(DLinkList& L) {
	int i;
	ElemType e;
	printf("输入要修改的位置：");
	scanf("%d", &i);
	printf("修改为：");
	scanf("%d", &e);
	if (DNodeRevise(L, i, e))
		printf("修改成功\n");
	else
		printf("修改失败\n");
}

void Search(DLinkList L) {
	int searchChoice;
	printf("（1）按位查找\n");
	printf("（2）按值查找\n");
	printf("选择查找功能：\n");
	scanf("%d", &searchChoice);
	int i;
	ElemType e;
	DNode* p;
	switch (searchChoice)
	{
	case(1):
		printf("输入要查找的节点位置：");
		scanf("%d", &i);
		p = GetNode(L, i);
		if (p && i != 0)					//查找的结点不能为空，也不能查找头结点的值
			printf("第%d个结点的值为%d\n", i, p->data);
		else
			printf("查找失败\n");
		break;
	case(2):
		printf("输入要查找的结点的值：");
		scanf("%d", &e);
		p = LocateNode(L, e);
		if (p)
			printf("找到该元素,查找成功\n");
		else
			printf("找不到该元素,查找失败\n");
		break;
	default:
		break;
	}
}


void menu() {
	printf("\n\n");
	printf("①----------头插法建立双链表----------\n");
	printf("②----------尾插法建立双链表----------\n");
	printf("③----------     打印表     ----------\n");
	printf("④----------    插入结点    ----------\n");
	printf("⑤----------    删除结点    ----------\n");
	printf("⑥----------    修改结点    ----------\n");
	printf("⑦----------    查找结点    ----------\n");
	printf("\n\n");
}

int main() {
	DLinkList L;
	int choice;
	do
	{
		menu();
		scanf("%d", &choice);
		switch (choice)
		{
			case(1):
				printf("输入每个元素的值（输入9999停止建表）\n");
				CreateListbyHeadInsert(L);
				break;
			case(2):
				printf("输入每个元素的值（输入9999停止建表）\n");
				CreateListbyTailInsert(L);
				break;
			case(3):
				PrintList(L);
				break;
			case(4):
				Insert(L);
				break;
			case(5):
				Delete(L);
				break;
			case(6):
				Revise(L);
				break;
			case(7):
				Search(L);
				break;
			default:
				break;
		}

	} while (choice != 0);
}
LiSeMn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之单链表的头插法和尾插法
weixin_44230780的博客
12-23 359
description： 输入3 4 5 6 7 9999 一串整数 ，9999代表结束，通过头插法新建链表并输出，通过尾插法新建链表并输出。应将尾指针的指针域赋值给要插入的链表结点 再将尾指针的指针域指向插入结点 最后将尾指针指向新插入的结点。需要将头结点的指针域 赋给 要插入结点的指针域 再将头结点的指针域指向要插入结点。注意输出要采用如下代码（oj判题对空格敏感）20221223 作业链表。//打印链表中每个结点的值。
单链表基本操作代码
urbeen的博客
07-12 2246
#include <stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; //头插法建立单链表 LinkList Link_HeadInsert(LinkList &L){ LNode *s; int x; L = (LinkList)malloc(size.
单链表（带头结点）——建立、查找、插入、删除、销毁等操作的代码实现（王道版）
a1833235073的博客
07-23 1396
单链表（带头结点）建立、查找、插入、删除、销毁等操作的代码实现（王道版）
数据结构之单链表（C语言）
qq_46067866的博客
04-09 1692
//初始化 int InitList(LinkList L) //求表长 int Length(LinkList L) //尾插法创建单链表 LinkList CreateList(LinkList L) //按值查找 int LocateElem(LinkList L,ElemType e) //按位查找 LNode *GetElem(LinkList L,int i) //插入 int ListInsert(LinkList L,int i,ElemType e) //删....
数据结构(1)线性表/单链表的基本实现（c）（详细的很）
YSJ367635984的博客
04-02 2922
------------> 切入主题 ： 线性表是数据结构课程内最简单最基本的一种结构，其存储方式包括顺序存储和链式存储，实现的基本操作包括：创建，插入，查找，输出，长度，删除数据，删除重复数据，判空，判满，合并，清空，销毁。 1.线性表的顺序存储（画个草图哈！） 线性表顺序存储的结构体： typedef int ElementType; typedef struct{ Eleme...
1.2 单链表
LiSeMn的博客
08-24 387
这一章是单链表的算法分析和代码实现。 单链表的结点数据结构： typedef struct LNode { ElemType data; //数据域 struct LNode* next; //指针域 }LNode, *LinkList ; 主要有以下实现功能的函数： LinkList List_HeadInsert(LinkList& L) 功能：头插法建立单链表（逆向建立单链表）； 参数：L:链表头结点； 时间复杂度：O(n); LinkList Li
concurrentlinkedhashmap-lru-1.3.jar.zip
11-11
《并发优化：ConcurrentLinkedHashMap-LRU在1.3版本中的实现详解》 在Java编程领域，高效的数据结构和算法是提升系统性能的关键。当面对高并发环境时，线程安全且性能优良的缓存机制显得尤为重要。...
数据结构与算法 —— Java 实现（链表）
01-21
Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个节点（after）1.7 编写...
C++课程作业-基于Qt实现的链表操作演示系统源码(含详细注释+报告).zip
最新发布
12-20
1.3 设计思想 根据题意，需要对不同链表进行同样的几项基本操作，实现标准交互式图形界面，可以 分为算法设计和界面设计两部分。 算法设计方面：对于单链表，本程序链表的建立采用带头结点方式，即每次建立链表都 ...
leetcode双人赛-MyLeetCode:我的LeetCode
06-30
leetcode双人赛 LeetCode 刷题笔记 ...1.3 链表 链表 1. 防止删除后链表为空 2. 递归的思路 链表交换 链表的翻转要3个指针 判断环 这边快慢指针是fast->next和fast->next->next做判单依据 链表反转 1.4 栈
数据结构课件（清华大学出版）
09-12
1.3 双向链表：双向链表的节点含有前驱和后继指针，便于双向遍历，但在插入和删除时需要维护更多的指针。 二、树形结构 树形结构模拟了层级关系，广泛应用于文件系统、数据库索引等场景。 2.1 二叉树：每个节点...
单链表的基本操作实现
qq_61825521的博客
09-09 432
C++代码实现单链表的创建、插入等基本操作（详细)
王道单链表课后题代码实现及链表基本操作实现
西小庄村高伟 的博客
06-07 803
链表的基本定义与方法列表 #include<stdio.h> #include<stdlib.h> #define TRUE 1 #define FALSE 0 typedef int Element; typedef struct LNode{ Element data; LNode *next; }*LinkList; bool InitList(LinkList &L); //初始化线性表 L bool DestoryList(LinkList &L
数据结构——链表的操作
莉莉莉的博客
10-30 326
直接贴模板代码 以后再写注释 包括插入删除取元素操作 #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #define ERROR 0 #define OK 1 typedef int ElemType; /*定义表元素的类型*/ typedef struct LNode /*线性表的单链表存储*/ { ElemType data; ...
数据结构—单链表的操作与实现—c++代码（含全部代码）
Initial_Mind的博客
01-21 6109
单链表的操作与实现
利用尾插法建立单链表(纯C语言小白版)
qq_60567426的博客
08-30 6087
【代码】利用尾插法建立单链表(纯C语言小白版)
转——链表中LinkList L与LinkList *L的区别
weixin_30457551的博客
12-09 5555
typedef struct Node{ int elem; struct node * next; }node,*LinkList; 　　 对于LinkList L: L是指向定义的node结构体的指针,可以用->运算符来访问结构体成员,即L->elem,而(*L)就是个Node型的结构体了,可以用点运算符访问该结构体成员,即(*L).elem; 对于Link...
数据结构—单链表的实现（c语言版）
南方硅人的博客
06-22 918
1、线性表的单链表表示 链式存储线性表时，不需要使用地址连续的存储单元，即不要求逻辑上相邻的元素在物理位置上也相邻，它通过“链”建立起来数据元素之间的逻辑关系，因此插入和删除操作不需要移动元素，而只需要修改指针，但也会失去顺序表可随机存取的优点。 2、单链表的基本操作 函数 说明 void InitList(LinkList &L); //初始化顺序表 int Length(LinkList &L); //返回当前长度； bool Empty(LinkList &am
单链表的基本操作
求知若饥 虚心若愚
12-09 1205
单链表最为人熟悉，随便一搜都讲的很好，所以还是不要献丑，直接上代码吧。 #include #include #include #include typedef struct LNode { void *data; // 这里设成指针型是因为 这里储存是要操作的数据的首地址，通过该数据域的地址（4个字节）操作它，提高效率，而无类型是为了通用 struct LNode *ne
1.3 对链表设置头结点的作用是什么?简述线性链表头指针，头结点，首元结点(第一个结点) 三个概念的区别；
04-04
对链表设置头结点的作用是使得链表的操作更加方便。头结点是一个不存储数据的特殊结点，它的作用是在链表的头部设置一个固定的位置，使得链表的首元结点始终存在，并且不会被删除。通过头结点，我们可以方便地对链表...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值