C/C++双向链表的各种操作

已于 2023-01-01 10:25:29 修改
阅读量248 收藏 1
点赞数
分类专栏： 笔记 C 文章标签： 链表 数据结构 算法
于 2022-08-06 23:40:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35803412/article/details/126203253
版权
笔记 同时被 2 个专栏收录
27 篇文章 1 订阅
订阅专栏
C
21 篇文章 0 订阅
订阅专栏
双向链表的各种操作

运行环境:VS2022 X64
在这里插入图片描述

#include <iostream>
#include <Windows.h>

using namespace std;

//双向链表的结构体定义
typedef struct _LinkNode {
	int data;	//数据域
	struct _LinkNode* next;	//指向下一个节点的指针域
	struct _LinkNode* prev;	//指向上一个节点的指针域
}LinkList, LinkNode;

//初始化双向链表
bool DbInit_List(LinkList*& L) { //构造一个空的双向链表
	L = new LinkNode;	//生成新结点作为头结点，用头指针 L 指向头结点
	if (!L) { cout << "头结点生成失败!" << endl; return false; }

	L->next = NULL;
	L->prev = NULL;
	L->data = -1;

	return true;
}

//双向链表前插法
bool DbListInster_front(LinkList*& L, LinkNode* node) {
	if (!L || !node) { return false; }

	//只有头结点
	if (L->next == NULL) {
		node->next = NULL;
		node->prev = L;	//插入节点的前置指针域指向头结点
		L->next = node; //头节点的后置指针域指向插入的节点
	}
	else {
		L->next->prev = node; //把插入节点的后一个节点的前置节点指向自己
		node->next = L->next; //把插入的节点的后置指针域指向下一个节点

		node->prev = L;		//把自己的前置指针指向上一个节点
		L->next = node;		//把前一个节点的的后置指针,指向自己
	}
	return true;
}

//双向链表尾插法
bool DbListInster_back(LinkList*& L, LinkNode* node) {
	if (!L || !node) { return false; }

	LinkNode* last = NULL; //用于遍历链表
	last = L;

	while (last->next) last = last->next; //遍历链表,找到尾部

	node->next = NULL; //把自己的后置指针,置为空,因为是尾插法,后面没得节点
	node->prev = last; //把自己的前置指针域指向上一个节点
	last->next = node; //把前一个节点的后置指针域指向自己

	return true;
}

//双链表任意位置插入
bool DbLink_Inster(LinkList*& L, int i, int &e) { //i是插入的位置,e是插入的数据
	if (!L || !L->next) { return false; }
	if (i < 1) { cout << "插入的位置不能小于1!" << endl; return false; }

	int j = NULL;
	LinkList* p = NULL, * s = NULL;

	p = L;

	while (p && j < i) {
		p = p->next;
		j++;
	}

	if (!p || j != i) { cout << "节点不存在!" << endl; return false; }

	s = new LinkNode;
	s->data = e;

	s->next = p;		//把插入节点的后置指针域指向,后面一个节点
	s->prev = p->prev;	//把插入节点的前置指针域指向,前一个节点

	/*
	p->prev->next = s;	//把前一个节点的后置指针域指向自己
	p->prev = s;		//把后面一个节点的前置指针域指向自己
	bug记录:
	这里如果这样写就会出现错误
	p->prev = s;
	p->prev->next = s;
	因为先把p->prev改成了s 导致p->prev->next = s;的时候,p->prev
	已经被修改过了,就是访问自己了
	所以要注意修改的先后顺序
	*/
	p->prev->next = s;	//把前一个节点的后置指针域指向自己
	p->prev = s;		//把后面一个节点的前置指针域指向自己
	
	return true;
}

//双向链表的遍历
void DbLink_print(LinkList*& L) {
	LinkNode* p = NULL;

	if (!L) { cout << "链表为空!" << endl; return; }

	p = L;

	cout << "正序打印:";
	while (p->next) {
		cout << p->next->data << " ";
		p = p->next;
	}
	cout << endl;

	cout << "逆序打印:";
	while (p!=L) {
		cout << p->data << " ";
		p = p->prev;
	}
	cout << endl;
}

//双向链表获取元素
bool DbLink_GetElem(LinkList*& L, int i, int& e) { //i查询的节点,e查询节点的数据域
	if (!L || !L->next) { return false; }

	int index = NULL;
	LinkList* p = NULL;

	p = L->next;	//头结点的后一个节点
	index = 1;		//这里随着头结点+1

	while (p && index < i) {
		p = p->next;
		index++;
	}

	if (!p || index > i) { return false; }

	e = p->data;
	return true;
}

//双链表删除节点
bool DbLink_Delete(LinkList*& L, int i) { //i被删的位置
	LinkList* p = NULL;
	int index = NULL;

	if (!L || !L->next) { cout << "双向链表为空!" << endl; return false; }
	if (i < 1) { cout << "不能删除头结点!" << endl; return false; }

	p = L;
	while (p && index < i) {
		p = p->next;
		index++;
	}

	if (!p) { return false; }

	p->prev->next = p->next; //把被删除节点前一个节点的后置指针域指向被删除节点的后一个节点
	if (p->next) { //如果p不是最后一个节点
		p->next->prev = p->prev; //把被删除节点的后一个节点的前置指针域指向,被删除节点的前一个节点
	}
	delete p;

	return true;
}
//双链表按数据域查找
bool Link_FindElem(LinkList*& L, int& i) {	//查找的数据
	if (!L || i == -1) { return false; }
	LinkList* p = NULL;
	p = L;

	while (p->next) {
		if (p->data == i) {
			return true;
		}
		p = p->next;
	}

	return  false;
}

bool ListAmend(LinkList*& L, int i, int j) { //i查找的位置 j需要修改的数据
	if (!L || !L->next) { return false; }
	if (i < 1) {
		cout << "不能查询比1小的节点!" << endl;
		return false;
	}

	LinkNode* p = L;
	int index = NULL;
	while (p->next && index<i) {
		p = p->next;
		index++;
	}
	p->data = j;

	return true;
}

//双向链表的销毁
void DbLink_Destroy(LinkList*& L) {
	LinkNode* p = L; //定义临时节点 p 指向头节点

	cout << "销毁链表!" << endl;
	while (p) {
		L = L->next; //L 指向下一个节点
		cout << "删除元素:" << p->data << endl;
		delete p; //删除当前节点
		p = L; //p 移向下一个节点
	}
}

void ListInstrt_back1(LinkList*& L) {
	int e = NULL;
	LinkList* s2 = NULL;

	cout << "请输入需要插入的个数(尾插法):";
	cin >> e;
	while (e > 0) {
		s2 = new LinkNode;

		cout << "请输入数据:";
		cin >> s2->data;
		if (DbListInster_back(L, s2)) {
			cout << "插入成功!!" << endl;
			e--;
		}
		else {
			cout << "插入失败!!" << endl;
			return;
		}

	}
	DbLink_print(L);
}

void ListInstrt_front1(LinkList*& L) {
	LinkList* s2 = NULL;
	int e = NULL;

	cout << "请输入需要插入的个数(前插法):";
	cin >> e;
	while (e > 0) {
		s2 = new LinkNode;

		cout << "请输入数据:";
		cin >> s2->data;
		if (DbListInster_front(L, s2)) {
			cout << "插入成功!!" << endl;
			e--;
		}
		else {
			cout << "插入失败!!" << endl;
			return;
		}


	}
	DbLink_print(L);
}

void LinkInsert1(LinkList*& L) {
	int e = NULL;
	int b = NULL;

	cout << "请输入插入的个数:";
	cin >> b;
	while (b > 0) {
		int a = NULL;
		e = NULL;

		cout << "当前数据:" << endl;
		DbLink_print(L);

		cout << "请输插入的位置和数据(空格隔开):";
		cin >> a >> e;

		if (DbLink_Inster(L, a, e)) {
			cout << "插入成功!!" << endl;
			DbLink_print(L);
			b--;
		}
		else {
			cout << "插入失败!!" << endl;
			return;
		}


	}

}

void Link_GetElem1(LinkList*& L) {
	int i = NULL;
	int e1 = NULL;
	while (true) {
		cout << "请输入需要查询的节点(按0退出):";
		cin >> i;
		if (i == 0) { break; }
		if (DbLink_GetElem(L, i, e1)) {
			cout << "节点的数据域值是:" << e1 << endl;
		}
		else {
			cout << "该值不存在" << endl;
		}
	}
}

void Link_FindElem1(LinkList*& L) {
	while (true) {
		int i = NULL;
		cout << "请输入需要查询的值(输入0结束):";
		cin >> i;
		if (i == 0) { break; }

		if (Link_FindElem(L, i)) {
			cout << "查找的:" << i << "存在!" << endl;
		}
		else {
			cout << "查找的:" << i << "不存在!" << endl;
		}
	}
}

void ListAmend(LinkList*& L) {
	while (true) {
		int x = NULL;
		int y = NULL;
		cout << "请输入需要修改数据的节点,以及修改的数据(空格隔开,按 0 空格 0 回车结束):";
		cin >> x >> y;
		if (x == 0) { break; }
		if (ListAmend(L, x, y)) {
			cout << "修改成功!!" << endl;
			DbLink_print(L);
		}
		else {
			cout << "修改失败!!" << endl;
			return;
		}
	}
}

void LinkDelete1(LinkList*& L) {
	while (true) {
		int a = NULL;

		cout << "请输入需要删除的节点(按0结束):";
		cin >> a;
		if (a == 0) { break; }

		if (DbLink_Delete(L, a)) {
			cout << "删除成功!!" << endl;
			DbLink_print(L);
		}
		else {
			cout << "删除失败!!" << endl;
		}
	}
}
void function() {
	LinkList* s1;	//头结点
	DbInit_List(s1);	//初始化一个空的双向链表

	while (true) {
		int x = NULL;
		string str[]{
					"     双向链表        \n"
					"1.插入数据(尾插法)   \n"
					"2.插入数据(前插法)   \n"
					"3.任意位置插入数据   \n"
					"4.按节点查询数据     \n"
					"5.查询数据是否存在   \n"
					"6.修改任意节点的数据 \n"
					"7.查看链表中的数据	  \n"
					"8.删除任意节点       \n"
					"9.销毁链表           \n"
					"10.退出               \n"
		};
		cout << *str << endl;
		cout << "请输入需要执行的操作:";
		cin >> x;

		if (x <= 0 || x > 11) { cout << "条件不成立!!" << endl; return; }

		switch (x) {
		case 1:
			ListInstrt_back1(s1);
			system("pause");
			break;
		case 2:
			ListInstrt_front1(s1);
			system("pause");
			break;
		case 3:
			LinkInsert1(s1);
			system("pause");
			break;
		case 4:
			Link_GetElem1(s1);
			system("pause");
			break;
		case 5:
			Link_FindElem1(s1);
			system("pause");
			break;
		case 6:
			ListAmend(s1);
			system("pause");
			break;
		case 7:
			cout << "链表中的所有数据" << endl;
			DbLink_print(s1);
			system("pause");
			break;
		case 8:
			LinkDelete1(s1);
			system("pause");
			break;
		case 9:
			cout << "销毁链表后,就无法进行任何对链表的操作!!" << endl;
			DbLink_Destroy(s1);
			system("pause");
			break;
		case 10:
			exit(0);
			break;
		default:
			break;
		}


		system("cls");
	}
}
int main(void) {
	function();

	return 0;
}
誰能久伴不乏
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 双链表基本操作
qq_40423330的博客
05-18 239
双链表基本操作
双向链表的基本操作(c++)
weixin_43845922的博客
07-31 350
双向链表的实现 基本操作 bool InitDLinkList(DLinkList &L); bool Empty(DLinkList L); bool InsertNextDNode(DNode *p, int e);//在p结点之后插入s节点//后插操作 bool DeleteNextDNode(DNode *p);//删除p结点的后继结点 void DestroyDList(DLinkList &L);//销毁一个双向链表 bool PrintDList(DLinkList L); /
c++实现双链表基本操作详解
qq_61607805的博客
01-27 1383
本人是来自双非本科的一只大一菜鸟，加入校队（我是吊车尾┭┮﹏┭┮）已有一个月的时间，现在开始写我的第一篇博客记录我的学习历程，废话不多说，如理解有误，请勘正。对于一个一无所有的空链表，我们用0,1来表示它的头结点与尾结点（为空集）。所以接下来进行初始化操作：
std::list(双向链表) 、 std::vector(动态数组，随机访问)、std::map、std::unordered_map
最新发布
m0_47136986的博客
03-07 527
std::list 和 std::vector 是 C++ 标准库中的两种不同类型的容器，它们各有其特点和适用场景。
双向链表及其各种操作
qq_37232304的博客
05-05 423
什么是双向链表： 我们都知道单向链表中的每一个节点有且只有一个指针，这个指针就是用来指向下一个节点的，单向链表顾名思义就是链表方向是单方向的，而本文要介绍的双向链表就是链表方向是双方向的，也就是双向链表中的每一个节点有两个指针，一个指针用来指向上一个节点（前驱），另一个指针用指向下一个节点（后继）。 双向链表各种操作 头插法 代码实现 public void inse...
浅谈c++中双向链表的用法
FlyOrca的博客
05-17 192
c++双向链表用法的一篇文章
C/C++ 双链表之逆序的实例详解
01-01
C/C++ 双链表之逆序的实例详解 一、结点结构  双向链表的数据结构定义如下：  typedef struct node { ElemType data; struct node *prior struct node *next; }list;  其中，ElemType可以是任意数据类型...
c++双向链表操作示例(创建双向链、双向链表中查找数据、插入数据等)
12-25
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表...
C/C++双链表双向链表
01-29
实现双向链表的基本功能，添加，删除，查找，指定位置插入，打印链表，获取链表长度等等
C/C++链表增删改查排序操作
11-21
使用C++实现双向循环链表的增删改查排序等操作，可查看个人博客的【[数据结构和算法]C/C++双向循环链表实现(增删改查排序)】--链接https://blog.csdn.net/slimmm/article/details/84317806
C++双向链表程序
09-02
C语言链表程序，内含链表的创建、插入、查找、遍历、删除和释放。 C语言链表程序，内含链表的创建、插入、查找、遍历、删除和释放。
双向链表的基础操作（C++实现）
weixin_33984032的博客
03-05 196
★C++实现双向链表的基础操作（类的实现）#include<iostream> #include<cassert> usingnamespacestd; typedefintDataType; classdouble_link_list {//定义双向链表类，包括了双向的前驱和后继指针，以及对...
双向链表（循环）的基础操作（C++）
stars_night的博客
01-18 907
引言 对于释放空间和删除元素，都还有些问题，希望能够得到评论提示。 链表元素（结构体） 想保存的值和前元素、后元素指针 struct Node { int val; Node * next; Node * prev; }; 链表的创建 先创建一个头结点指针，然后构建创建函数，以头结点指针为参数并返回指针对象 int main() { Node * head = (Node *)malloc(sizeof(Node)); head->next = NULL; head->prev
C++ 双链表的基本操作
wangqiaozhi的专栏
01-06 780
在笔试面试过程中遇到的比较难一点点的编程，双链表就是其中之一了。对于缺少编程经验的同学而言更是如此，止步于这里大有人在。虽然我比较幸运没有遇到这样的问题，但是为了以防万一，或者说加深一下自己的印象，还是动手写了一把。以下就将我在VC6.0上调试通过的代码。 #include #include #include #include using namespace std; typedef
【C++ STL】细数C++ STL 的那些事---List（双向链表）
java开发指南博客 【转载】
04-08 171
一，概述 List将元素按顺序储存在链表中.与向量(vectors)相比,它允许快速的插入和删除，但是随机访问却比较慢。 list 不仅是一个双向链表，而且是一个环状双向链表 二，使用 #include &lt;list&gt; using namespace std; 注意：list是一个“前闭后开”的区间，即 list&lt;int&gt; lt(10,6...
数据结构---双向链表的操作
gaoqiandr的博客
10-23 371
对于数据结构双向链表的操作，很详细，并且简单易懂哦
双链表操作
02-03 833
处理完了单链表，这次处理双链表。 在一个双链表中，每个节点都包含两个指针，指向前一个节点的指针和指向后一个节点的指针。这可以使我们以任何方式遍历双链表，甚至可以忽略前后地在双链表中访问。下面的图示展示了一个双链表： 下面是节点类型的声明文件： double_linked_list_node.h #ifndef _DOUBLE_LINKED_LIST #define _DOUBLE_
利用C++实现双向链表的基本操作
weixin_43165699的博客
07-25 4100
本文采用利用C++实现了对双向链表的基本操作。操作包括：双向链表的构建、链表指定位置的插入、链表指定位置的删除、链表长度的获取、链表指定位置元素的获得及指定元素位置的获得、整体链表的删除。
解释一下c/c++中的链表
03-12
链表是一种数据结构，它由一系列节点组成，每个节点包含...链表有单向链表和双向链表两种形式，单向链表每个节点只有一个指针指向下一个节点，而双向链表每个节点有两个指针，一个指向前一个节点，一个指向后一个节点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值