408-王道-双向链表

已于 2022-12-26 11:21:41 修改
阅读量243 收藏
点赞数
分类专栏： 王道考研408-数据结构 文章标签： 链表 数据结构
于 2022-11-21 21:23:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56553975/article/details/127972845
版权

1.选择菜单

在这里插入图片描述

2.头插法

void insertHead(DLinkList& L) {
	DNode* s; int x;
	L = (DLinkList)malloc(sizeof(DNode));//带头结点的链表,不带头结点
	L->next = NULL;
	L->prior = NULL;
	scanf("%d", &x);//从标准输入读取数据
	while (x != 999) {
		s = (DLinkList)malloc(sizeof(DNode));//申请一个空间空间，强制类型转换
		s->data = x;
		s->next = L->next;
		if (L->next != NULL)//插入第一个结点时，不需要这一步操作
		{
			L->next->prior = s;
		}
		s->prior = L;
		L->next = s;
		scanf("%d", &x);//读取标准输入
	}
}

3.尾插法

void insertEnd(DLinkList& L) {
	int x;
	L = (DLinkList)malloc(sizeof(DNode));//带头节点的链表
	DNode* s, * r = L;
	L->prior = NULL;
	scanf("%d", &x);
	while (x != 999) {
		s = (DNode*)malloc(sizeof(DNode));
		s->data = x;
		r->next = s;
		s->prior = r;
		r = s;//r指向新的表尾结点
		scanf("%d", &x);
	}
	r->next = NULL;//尾结点的next指针赋值为NULL
}

4.修改元素

bool modifyNode(DLinkList& L, int index ,ElemType data) {
	DLinkList temp = L->next;
	int count = 0;
	while (temp != NULL) {
		count++;
		if (count == index) {
			temp->data = data;
			return true;
		}
		else {
			temp = temp->next;
		}
	}
	return false;
}

5.查找元素

DLinkList searchNode(DLinkList L , int index) {
	int count = 0;
	DLinkList temp = L->next;
	if (index<1 || index>size(L)) {
		return NULL;
	}
	while (temp != NULL) {
		count++;
		if (count == index) {
			return temp;
		}
		else {
			temp = temp->next;
		}

	}
	return NULL;
}

6.删除元素

bool deleteNode(DLinkList& L, int index ) {
	if (index<1 || index>size(L)) {
		return false;
	}
	else {
		int count = 0;
		DLinkList temp = L->next;
		if (index == 1) {
			L->next = L->next->next;
			L->next->prior = L;
			return true;
		}
		while (temp != NULL) {
			count++;
			if(count == index){
				DLinkList parent = temp->prior;
				parent->next = temp->next;
				temp->prior = parent;
				temp->next = NULL;
				return true;
			}
			else {
				temp = temp->next;
			}
		}

	}

	return false;
}

7.遍历元素

void printfList(DLinkList L) {
	DLinkList temp = L->next;
	int count = 0;
	while (temp != NULL) {
		count++;
		printf("DlinkList[%d] = %d\n", count, temp->data);
		temp = temp->next;
	}
}

8.插入元素

bool insertNode(DLinkList& L, int index, ElemType data) {
	int count = 0;
	if (index<1 || index>size(L)) {
		return false;
	}else {
		DLinkList temp = L->next;
		while (temp != NULL) {
			count++;
			if (count == index) {
				DLinkList parent = temp->prior;
				DLinkList newNode = (DLinkList)malloc(sizeof(DNode));
				newNode->data = data;
				newNode->next = temp;
				newNode->prior = parent;
				parent->next = newNode;
				return true;
			}
			else {
				temp = temp->next;
			}

		}
		return false;
	}
}

9.链表长度

int size(DLinkList L) {
	DLinkList temp = L->next;
	int count = 0;
	while (temp != NULL) {
		count++;
		temp = temp->next;
	}
	return count;
}

10.汇总

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
//双向链表尾插法
//按序号查找结点值
//新结点插入第i个位置
//删除第i个结点
//链表打印
typedef int ElemType;
typedef struct DNode {
	ElemType data;
	struct DNode* prior;
	struct DNode* next;
}DNode,* DLinkList;

void insertHead(DLinkList& L);
void insertEnd(DLinkList& L);
bool deleteNode(DLinkList& L,int index);
bool modifyNode(DLinkList& L, int index,ElemType data);
bool insertNode(DLinkList& L, int index, ElemType data);
void printfList(DLinkList L);
void choice(DLinkList& L);
void menu(DLinkList& L);
int size(DLinkList L);
DLinkList searchNode(DLinkList L, int index);

bool insertNode(DLinkList& L, int index, ElemType data) {
	int count = 0;
	if (index<1 || index>size(L)) {
		return false;
	}else {
		DLinkList temp = L->next;
		while (temp != NULL) {
			count++;
			if (count == index) {
				DLinkList parent = temp->prior;
				DLinkList newNode = (DLinkList)malloc(sizeof(DNode));
				newNode->data = data;
				newNode->next = temp;
				newNode->prior = parent;
				parent->next = newNode;
				return true;
			}
			else {
				temp = temp->next;
			}

		}
		return false;
	}
}
bool deleteNode(DLinkList& L, int index ) {
	if (index<1 || index>size(L)) {
		return false;
	}
	else {
		int count = 0;
		DLinkList temp = L->next;
		if (index == 1) {
			L->next = L->next->next;
			L->next->prior = L;
			return true;
		}
		while (temp != NULL) {
			count++;
			if(count == index){
				DLinkList parent = temp->prior;
				parent->next = temp->next;
				temp->prior = parent;
				temp->next = NULL;
				return true;
			}
			else {
				temp = temp->next;
			}
		}

	}

	return false;
}
bool modifyNode(DLinkList& L, int index ,ElemType data) {
	DLinkList temp = L->next;
	int count = 0;
	while (temp != NULL) {
		count++;
		if (count == index) {
			temp->data = data;
			return true;
		}
		else {
			temp = temp->next;
		}
	}
	return false;

}
int size(DLinkList L) {
	DLinkList temp = L->next;
	int count = 0;
	while (temp != NULL) {
		count++;
		temp = temp->next;
	}
	return count;
}

DLinkList searchNode(DLinkList L , int index) {
	int count = 0;
	DLinkList temp = L->next;
	if (index<1 || index>size(L)) {
		return NULL;
	}
	while (temp != NULL) {
		count++;
		if (count == index) {
			return temp;
		}
		else {
			temp = temp->next;
		}

	}
	return NULL;
}
//双向链表头插法
void insertHead(DLinkList& L) {
	DNode* s; int x;
	L = (DLinkList)malloc(sizeof(DNode));//带头结点的链表,不带头结点
	L->next = NULL;
	L->prior = NULL;
	scanf("%d", &x);//从标准输入读取数据
	while (x != 999) {
		s = (DLinkList)malloc(sizeof(DNode));//申请一个空间空间，强制类型转换
		s->data = x;
		s->next = L->next;
		if (L->next != NULL)//插入第一个结点时，不需要这一步操作
		{
			L->next->prior = s;
		}
		s->prior = L;
		L->next = s;
		scanf("%d", &x);//读取标准输入
	}
}
void insertEnd(DLinkList& L) {
	int x;
	L = (DLinkList)malloc(sizeof(DNode));//带头节点的链表
	DNode* s, * r = L;
	L->prior = NULL;
	scanf("%d", &x);
	while (x != 999) {
		s = (DNode*)malloc(sizeof(DNode));
		s->data = x;
		r->next = s;
		s->prior = r;
		r = s;//r指向新的表尾结点
		scanf("%d", &x);
	}
	r->next = NULL;//尾结点的next指针赋值为NULL
}

void printfList(DLinkList L) {
	DLinkList temp = L->next;
	int count = 0;
	while (temp != NULL) {
		count++;
		printf("DlinkList[%d] = %d\n", count, temp->data);
		temp = temp->next;
	}
}
void choice(DLinkList& L) {
	int choice;
	printf("请输入你的选择：");
	scanf("%d", &choice);
	switch (choice) {
	case 1:
		insertHead(L);
		break;
	case 2:
		insertEnd(L);
		break;
	case 3: {
		int index;
		ElemType data;
		printf("请输入要你修改的序号:");
		scanf("%d", &index);
		printf("修改的值为:");
		scanf("%d", &data);
		bool isModify = modifyNode(L, index, data);
		if (isModify) {
			printf("修改成功\n");
		}
		else {
			printf("修改失败\n");
		}
		break;
	}
	case 4: {
		int index;
		printf("请输入你要查找的序号：");
		scanf("%d", &index);
		DLinkList search = searchNode(L, index);
		if (search != NULL) {
			printf("查找成功,结点数据为%d\n", search->data);
		}
		else {
			printf("查找失败\n");
		}
		break;
	}
	case 5: {
		int index;
		printf("请输入你要删除的序号:");
		scanf("%d",&index);
		bool isDelete = deleteNode(L, index);
		if (isDelete) {
			printf("删除成功\n");
		}
		else {
			printf("删除失败\n");
		}
		break;
	}
	case 6:
		printfList(L);
		break;
	case 7: {
		int index;
		ElemType data;
		printf("请输入你要插入的位置：");
		scanf("%d", &index);
		printf("请输入你要添加的值");
		scanf("%d", &data);
		bool isInsert = insertNode(L, index, data);
		if (isInsert) {
			printf("插入成功\n");
		}
		else {
			printf("插入失败\n");
		}
		break;
	}
	case 8: 
		printf("长度为%d\n", size(L));
		break;
	default:
		break;
	}
	menu(L);

}


void menu(DLinkList& L) {
	printf("----------------双向链表-----------------\n");
	printf("               1.头插法                 \n");
	printf("               2.尾插法                 \n");
	printf("               3.修改元素               \n");
	printf("               4.查找元素               \n");
	printf("               5.删除元素               \n");
	printf("               6.遍历元素               \n");
	printf("               7.插入元素               \n");
	printf("               8.链表长度               \n");
	choice(L);
}




int main() {
	DLinkList L;
	menu(L);
	return 0;
}
天空的城_
关注
专栏目录
(王道408考研数据结构)第二章线性表-第三节2：双链表的定义及其操作（插入和删除）
快乐江湖的博客
11-10 1535
文章目录一：双链表的定义二：双链表代码描述三：双链表的初始化四：双链表的插入五：双链表的删除 一：双链表的定义 双链表：相较于单链表而言，双链表在原先的基础上再增加一个指针域，用于指向它的前驱结点 二：双链表代码描述 使用C语言，描述双链表的结点如下 typedef struct DNode { DataType data; struct DNode* prior;//指向前驱结点 struct DNode* next;//指向后继结点 }DNode 因此对于链表中的某一个结点p，其前驱结点就是p
(王道408考研数据结构)第二章线性表-第三节3：循环单链表和循环双链表
快乐江湖的博客
11-10 1385
文章目录一：循环链表定义二：循环单链表三：循环双链表 一：循环链表定义 循环链表：规定好头尾结点的指向形成环状 循环单链表：其尾节点的next指针由原本的空改为指向头结点 循环双链表：其尾节点的next指针由原本的空改为指向头结点，同时头结点的prior指针指向尾节点 二：循环单链表 原来的单链表如果p是尾节点，一定有p->next=NULL; 循环单链表如果p是尾节点，一定有p->next=Head; 注意循环单链表的初始化 bool InitList(LNode*& He
《王道》第11章 链表之双链表
南方有乔木的博客
04-11 487
《王道》第11章 链表之双链表 目录 1.双链表的插入(以插入到p结点前为例) 2.双链表的删除 3.代码 4.补充 1.双链表的插入(以插入到p结点前为例) 第一步：首先找到插入位置，节点 s 将插入到节点 p 之前 第二步：将节点 s 的前驱指向节点 p 的前驱，即 s->prior = p->prior; ...
王道——双链表
下次再说的博客
03-15 181
* *下次再说 *
王道数据结构 双链表 ★★★★★
旅途
06-16 4183
c语言数据结构之双链表
2022 数据结构与算法《王道》学习笔记 （六）双链表
小超嵌入式笔记
03-05 409
数据结构与算法系列文章目录 本文内容摘自《王道数据结构》，经自我总结后做成笔记，供学习参考用。 本文部分图片摘自博文 文章目录数据结构与算法系列文章目录前言1、双链表的插入操作2.双链表的删除操作3.静态链表4.顺序表和链表的比较 前言 单链表结点中只有一个指向其后继的指针，使得单链表只能从头结点依次顺序地向后遍历。要访问某个结点的前驱结点（插入、删除操作时），只能从头开始遍历，访问后继结点的时间复杂度为O(1)，访问前驱结点的时间复杂度为O(n)。 为了克服单链表的上述缺点，引入双链表，双链表结点中
2015年数据结构联考复习指导-王道论坛
08-18
单链表只有一个方向，而双向链表可以双向遍历。链表不需连续的内存空间，但访问元素不如数组直接。 栈是一种后进先出（LIFO）的数据结构，常用于函数调用、表达式求值等场景。栈的主要操作有压栈（push）、弹栈...
线性表的链式表示--双链表
qq_43581971的博客
07-27 453
双链表小结
双向链表（非循环）
MOON5555的博客
10-30 2351
1、头文件(dilst.h) #pragma once //带头结点的双向链表(非循环) typedef struct DNode { int data;//数据域 struct DNode *next;//后继指针 struct DNode *prio;//前驱指针 }DNode,*DList; //初始化双向链表 void InitDList(DList plist); //头插
2023王道考研数据结构第二章---单链表
weixin_52572034的博客
08-17 1359
2023王道考研数据结构第二章---单链表
王道数据结构——双链表、循环双链表实现
qq_42242452的博客
05-02 1123
王道考研双链表、循环双链表
数据结构：双链表（王道2022）
weixin_45091567的博客
07-29 352
双链表 typedef struct DNode{ //定义双链表 ElemType data; struct DNode *prior,*next; }DNode,*DLinkList; DNode 、 *DLinkList 两者是等价的 初始化（带头节点） typedef struct DNode{ //定义双链表 ElemType data; struct DNode *prior,*next; }DNode,*DLinkList; //初始化双链表 bool InitD
考研408 王道 数据结构 算法题整理（二）链表
nabobess的博客
03-09 456
考研408 王道 数据结构 算法题整理（二）链表
王道数据结构精简笔记——双链表
最新发布
weixin_53830825的博客
07-11 165
双链表不可随机存取，按位查找、按值查找操作都只能用遍历的方式实现。
王道考研数据结构--2.2.双链表
我是个好人呀，????
06-21 727
/C语言自定义bool操作/*数据元素类型*//*双链表结构体定义*/typedef struct DNode //定双链表结点类型//每个结点存放一个数据元素//指针指向下一节点//指针指向上一节点。
23王道——循环双链表
下次再说的博客
03-16 1085
#include<iostream>
【数据结构】【王道】【线性表】双链表的实现及基本操作（可直接运行）
treesorshining的博客
07-12 711
总目录 1.2 初始化 1.3 判空 1.4 结点后插入_1 1.5 结点后插入_2 1.6 按位序插入 1.7 删除后继结点 1.8 按位查找 1.9 按值查找 1.10 销毁链表 1.11 输出所有链表元素 2.完整代码 3.运行截图
考研数据结构（王道版）：循环双链表上基本操作的实现(C语言）
知且行的博客
01-20 815
循环双链表： 与单链表相比，双链表的优势就是可以双向操作链表，在单链表中只能从表头节点开始往后顺序遍历整个链表，而循环双链表可以从表中任意节点遍历。其缺点就是 由于一个不仅有头指针，而且存在尾指针，相比于单链表来说就比较浪费存储空间。 循环双链表代码实现： #include <stdio.h> #include <stdlib.h> #include <mat...
2019《王道数据结构》算法题-双链表C++实现
qq_17713905的博客
09-27 402
#include&lt;iostream&gt; using namespace std; template&lt;class T&gt; struct Node{ T data; Node&lt;T&gt;* next; Node&lt;T&gt;* pre; int freq; Node(Node&lt;T&gt;* p = NULL , Node&lt;T&gt;* n = NU...
数据结构-链表实现：双向循环链表类详解
本文主要介绍了双向循环链表的定义，并提到了其他几种链表类型，如单链表、循环链表、双向链表以及稀疏矩阵。此外，还概述了单链表的特点、存储映像、类定义以及插入与删除的操作。 在数据结构中，链表是一种线性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值