数据结构基础-链表

最新推荐文章于 2024-08-17 16:47:39 发布
最新推荐文章于 2024-08-17 16:47:39 发布
阅读量74 收藏
点赞数
分类专栏： C++ 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41729472/article/details/133381557
版权

链表的核心要素

每个节点由数据域和指针域组成

指针域指向下一个节点的内存地址

结构体的定义

typedef struct _LinkNode {
    ElemType data;
    struct _LinkNode* next;
}LinkList, LinkNode;

单链表

初始化

bool initList(LinkList*& L) {
	L = new LinkNode;
	if (!L) return false;
	L->next = NULL;
	return true;
}

增加元素

前插法

bool insertFrontList(LinkList*& L,LinkNode* node) {
	if (!L || !node) return false;
	node->next = L->next;
	L->next = node;
	return true;
}

尾插法

bool insertRearList(LinkList*& L, LinkNode* node) {
	if (!L || !node) return false;
	//找到最后一个节点
	LinkNode* last = NULL;
	last = L;
	while (last->next) last = last->next;
	node->next = NULL;
	last->next = node;
	return true;
}

插入元素

bool insertList(LinkList*& L, int pos, ElemType& e) {
	int j = 0;
	LinkList* p, * s;
	//在带头结点的单链表 L 中第 i 个位置插入值为 e 的新结
	p = L;
	while (p && j < pos - 1) {//查找第 i-1 个结点，p 指向该结点
		p = p->next;
		j++;
	}
	if (!p || j > pos - 1) return false;
	s = new LinkNode;
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

遍历链表

void printList(LinkList*& L) {
	LinkNode* p;
	p = L->next;
	while (p) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}

获取元素

bool getElem(LinkList*& L, int pos, ElemType& e) {
	LinkList* p;
	int j = 1;
	p = L->next;
	while (p && j < pos) {
		p = p->next;
		j++;
	}
	if (!p || j > pos) return false;
	e = p->data;
	return true;
}

查找元素

bool findElem(LinkList*& L, ElemType e) {
	LinkList* p;
	p = L->next;
	while (p && p->data != e) {
		p = p->next;
	}
	if (!p) return false;

}

删除节点

bool deleteList(LinkList*& L, int pos) {
	int j = 0;
	LinkNode* p, * q;
	p = L;
	while (p->next && j < pos - 1) {
		p = p->next;
		j++;
	}
	if (!(p->next) || j > pos - 1) return false;
	q = p->next;
	p->next = q->next;
	delete q;
	return true;
}

销毁链表

void destroyList(LinkList*& L) {
	LinkList* p = L;
	cout << "销毁链表" << endl;
	while (p) {
		L = L->next;
		cout << "销毁节点" << p->data << endl;
		delete p;
		p = L;
	}
}

测试

int main() {
	LinkList* L = NULL;
	LinkNode* s = NULL;
	//1. 初始化一个空的链表
	initList(L);
	//2. 使用前插法插入数据
	int n;
	cout<<"前插法创建单链表"<<endl;
	cout<<"请输入元素个数 n：";
	cin>>n;
	cout<<"\n 请依次输入 n 个元素：" <<endl;
	while(n>0){
		s = new LinkNode; //生成新节点 s
		cin>>s->data;
		insertFrontList(L, s);
		n--;
	}
	//4. 单链表的输出
	printList(L);

	//5. 任意位置插入元素
	for (int j = 0; j < 3; j++) {
		int i, x;
		cout << "请输入插入的位置和元素（用空格隔开）:";
		cin >> i;
		cin >> x;
		if (insertList(L, i, x)) {
			cout << "插入成功.\n\n";
		}
		else {
			cout << "插入失败!\n\n";
		}
		printList(L);
	}
	//6. 单链表根据位置获取元素
	int element = 0;
	if (getElem(L, 2, element)) {
		cout << "获取第二个元素成功, 值：" << element << endl;
	}
	else {
		cout << "获取第二个元素失败!" << endl;
	}
	//7. 单链表根据值查询元素所在的位置
	int index = 0;
	if (findElem(L, 10, index)) {
		cout << "查找元素 10 存在,所在位置: " << index << endl;
	}
	else {
		cout << "不存在元素 10." << endl;
	}
	//8. 单链表删除元素
	if (deleteList(L, 2)) {
		cout << "删除第 2 个元素成功!" << endl;
		printList(L);
	}
	else {
		cout << "删除第 2 个元素失败!" << endl;
	}
	//9. 销毁单链表
	destroyList(L);
	return 0;
}

循环链表

空的循环链表

例：有 10 个小朋友按编号顺序 1，2，。。。，10 顺时针方向围成一圈。从 1 号开 始顺时针方向 1，2，。。。，9 报数，凡报数 9 者出列（显然，第一个出圈为 编号 9 者）。 最后一个出圈者的编号是多少？第 5 个出圈者的编号是多少？

#include <iostream>
using namespace std;

typedef struct _LinkNode {
	int data;
	struct _LinkNode* next;
}LinkNode, LinkList;

bool initList(LinkList*& L) {
	L = new LinkNode;
	if (!L) return false;
	L->next = L;
	L->data = -1;
	return true;
}

bool insertRearList(LinkList*& L, LinkNode* node) {
	LinkNode* last = NULL;
	if (!L || !node) return false;
	last = L;
	while (last->next!=L) last = last->next;
	node->next = L;
	last->next = node;
	return true;
}

void printList(LinkList* L) {
	LinkList* p;
	if (!L || L == L->next) {
		cout << "链表为空" << endl;
		return;
	}
	p = L->next;
	while (p != L) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}

bool Joseph(LinkList*&L,int interval) {
	LinkList* p, * q;
	int i = 0, j = 0, times = 0, num = 0;
	p = L;
	if (!L || p->next == L) {
		cout << "链表为空！" << endl;
		return false;
	}
	if (interval < 1) {
		cout << "报数淘汰口令不能小于1" << endl;
		return false;
	}
	do {
		i += interval;
		while (p->next) {//查找第 i 个结点，p 指向该结点的上一个节点
			if (p->next != L) j++;
			if (j >= i) break;
			p = p->next;
		}
		times++;
		q = p->next;
		num = q->data;
		if (times == 5) cout << "第五个出圈的编号是：" << num << endl;
		printf("cur: %d last: %d next: %d\n", q->data, p->data, q->next->data);
		p->next=q->next;
		delete q;
		printList(L);
	} while (L->next != L);
	cout << "最后一个出圈的编号是：" << num << endl;
	return true;
}

int main() {
	int i, x;
	LinkList* L;
	LinkNode* s;
	//1. 初始化一个空的循环链表
	if (initList(L)) {
		cout << "初始化一个空的循环链表!\n";
	}
	//2. 创建循环链表（尾插法）
	cout << "尾插法创建循环链表, 插入 10 个元素..." << endl;
	i = 0;
	while ((++i) <= 10)
	{
		s = new LinkNode;//生成新结点
		s->data = i; //输入元素值赋给新结点的数据域
		s->next = NULL;
		if (insertRearList(L, s)) {
			cout << "插入成功!" << endl;
		}
		else {
			cout << "插入失败!" << endl;
		}
	}
	cout << "尾插法创建循环链表输出结果:\n";
	printList(L);
	//3. 解答约瑟夫问题
	Joseph(L, 9);
	return 0;
}

双链表

双链表定义

typedef struct _DbLinkNode {
	int data;
	struct _DbLinkNode* prev;
	struct _DbLinkNode* next;
}DbLinkNode, DbLinkList;

初始化双链表

bool initDbList(DbLinkList*& L) {
	L = new DbLinkNode;
	if (!L) return false;
	L->data = -1;
	L->next = NULL;
	L->prev = NULL;
	return true;
}

头插法创建双链表

bool insertFrontDbList(DbLinkList*& L, DbLinkNode* node) {
	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 insertRearDbList(DbLinkList*& L, DbLinkNode* node) {
	if (!L || !node) return false;
	DbLinkList* last = L;
	while (last->next) last = last->next;
	node->next = NULL;
	node->prev = last;
	last->next = node;
	return true;
}

指定位置插入元素

bool insertDbList(DbLinkList*& L, int i, int& e) {
	if (!L || !L->next) return false;
	if (i < 1) return false;
	int j = 0;
	DbLinkList * p, * s;
	p = L;
	while (p && j < i) {//查找位置为 i 的结点，p 指向该结点
		p = p->next;
		j++;
	}
	if (!p || j != i) {
		cout << "不存在节点：" << i << endl;
		return false;
	}
	cout << "p: " << p << endl;
	s = new DbLinkNode;//生成新节点
	s->data = e;
	s->next = p;
	s->prev = p->prev;
	p->prev->next = s;
	p->prev = s;
	return true;
}

遍历双链表

void printDbList(DbLinkList*& L) {
	DbLinkNode* p = NULL;
	if (!L) {
		cout << "链表为空." << endl;
		return;
	}
	p = L;
	while (p->next) {
		cout << p->next->data << "\t";
		p = p->next;
	}
	//逆向打印
	cout << endl << "逆向打印" << endl;
	while (p) {
		cout << p->data << "\t";
		p = p->prev;
	}
	cout << endl;
}

获取元素

bool getElemDbList(DbLinkList*& L, int i, int& e) {
	int index;
	DbLinkList* p;
	if (!L || !L->next) return false;
	p = L->next;
	index = 1;
	while (p && index < i) {//顺链表向后扫描，直到 p 指向第 i 个元素或 p 为空
		p = p->next; //p 指向下一个结点
		index++; //计数器 index 相应加 1
	}
	if (!p || index > i) {
		return false; //i 值不合法,i＞n 或 i<=0
	}
	e = p->data;
	return true;
}

删除双链表

bool deleteDbList(DbLinkList*& L, int i) {
	DbLinkList* p;
	int index = 0;
	if (!L || !L->next) {
		cout << "双向链表为空!" << endl;
		return false;
	}
	if (i < 1) return false; //不能删除头节点
	p = L;
	while (p && index < i) {
		p = p->next;
		index++;
	}
	if (!p) { //当节点不存在时，返回失败
		return false;
	}
	p->prev->next = p->next; //改变删除结点前驱结点的 next 指针域
	p->next->prev = p->prev; //改变删除节点后继节点的 prev 指针域
	delete p; //释放被删除结点的空间
	return true;
}

销毁双链表

void destroyDbList(DbLinkList*& L) {
	//定义临时节点 p 指向头节点
	DbLinkList* p = L;
	cout << "销毁链表!" << endl;
	while (p) {
		L = L->next;//L 指向下一个节点
		cout << "删除元素: " << p->data << endl;
		delete p; //删除当前节点
		p = L; //p 移向下一个节点
	}
}

测试

int main() {
	DbLinkList* L = NULL;
	DbLinkNode* s = NULL;
	//1. 初始化一个空的双向链表
	initDbList(L);
	//2. 使用前插法插入数据
	int n;
	cout << "前插法创建双向链表" << endl;
	std::cout << "请输入元素个数 n：";
	cin >> n;
	cout << "\n 请依次输入 n 个元素：" << endl;
	while (n > 0) {
		s = new DbLinkNode; //生成新节点 s
		cin >> s->data;
		insertFrontDbList(L, s);
		n--;
	}
	//3. 使用尾插法插入数据
	cout << "尾插法创建双向链表" << endl;
	std::cout << "请输入元素个数 n：";
	cin >> n;
	cout << "\n 请依次输入 n 个元素：" << endl;
	while (n > 0) {
		s = new DbLinkNode; //生成新节点 s
		cin >> s->data;
		insertRearDbList(L, s);
		n--;
	}
	//4. 双向链表的输出
	printDbList(L);
	//5. 任意位置插入元素
	for (int j = 0; j < 3; j++) {
		int i, x;
		cout << "请输入插入的位置和元素（用空格隔开）:";
		cin >> i;
		cin >> x;
		if (insertDbList(L, i, x)) {
			cout << "插入成功.\n\n";
		}
		else {
			cout << "插入失败!\n\n";
		}
		printDbList(L);
	}
	//6. 双向链表根据位置获取元素
	int element = 0;
	if (getElemDbList(L, 2, element)) {
		cout << "获取第二个元素成功, 值：" << element << endl;
	}
	else {
		cout << "获取第二个元素失败!" << endl;
	}
	//7. 双向链表删除元素
	if (deleteDbList(L, 2)) {
		cout << "删除第 2 个元素成功!" << endl;
		printDbList(L);
	}
	else {
		cout << "删除第 2 个元素失败!" << endl;
	}
	if (deleteDbList(L, 1)) {
		cout << "删除第 1 个元素成功!" << endl;
		printDbList(L);
	}
	else {
		cout << "删除第 1 个元素失败!" << endl;
	}
	//8. 销毁双向链表
	destroyDbList(L);
	return 0;
}

run sun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构-链表.pdf
08-15
数据结构-链表是计算机科学和信息技术领域中的一个基础概念，它广泛应用于计算机科学和信息技术领域。链表是一种非常重要的数据结构，它可以分为单向链表、循环链表和双向循环链表等。链表的优点是插入和删除操作...
C语言数据结构-链表版学生管理系统
10-02
在计算机科学中，数据结构是组织、存储和处理数据的重要工具，而链表作为一种基础且灵活的数据结构，被广泛应用于各种复杂算法和系统设计中。本项目《C语言数据结构-链表版学生管理系统》通过C语言实现了基于链表的...
数据结构-链表篇
热门推荐
qq_16268979的博客
01-10 1万+
数据结构-链表篇
数据结构-链表（代码详解）
hcx009的博客
04-23 1212
数据结构与算法——线性表（链表篇）_线性链表-CSDN博客，但是这篇博客不能细看，也不能深究，因为错误和纰漏太多了，包括但不限于变量名的错误，函数传参的误导性，以及部分知识点错的离谱，本文也只是跟着这篇博客整理的知识点的结构来自己写的代码，毕竟：Talk is cheap, show me the code.//1.//2.//这里的typedef是取别名的意思//把 struct LNode取个简单的名字为 LNode。
Python中常用的数据结构---链表
qq_43061415的博客
03-09 3390
## Python中常用的数据结构---链表 常用的数据结构有数组、链表(一对一)、栈和队列、哈希表、树(一对多)、图(多对多)等结构。 在本目录下我们将讲解，通过python语言实现常用的数据结构。 #### 2.链表 2.1链表的结构 链表（linked list）是一种在物理上非连续、非顺序的数据结构，由若干节点（node）所组成。 （1）单向链表的每一个节点又包含两部分，一部分是存放数据的变量data，另一部分是指向下一节点的指针next。 表示方式如下：
【数据结构-链表】链表的基本操作
Mount256的博客
10-26 1820
【数据结构-链表】链表的基本操作
数据结构解析-链表
码农成长记
02-28 1258
数据结构-链表
数据结构-链表基础详解(超详细代码)
mayu_xuan的博客
12-04 3330
链表的定义及代码包含顺序表和单链表 目录一、线性表 1.线性表定义2.线性表特点二、线性表的顺序表示（顺序表）1、顺序表的优缺点2.插入操作3.删除操作4.练习三、线性表的链式表示（单链表）1.单链表定义2.单链表优缺点3.插入操作4.删除操作 5.查找操作5.1按序号查找结点 5.2按值查找结点 6.练习 1、顺序表的优缺点 1.优点：最好情况：在表尾插入元素，不需要移动元素，时间复杂度
Linux内核基础数据结构-双链表
飞翔de刺猬
07-19 1106
链表概述 链表作为一种基本的数据结构，得益于其简单的结构、优良的性能（双向链表的插入和删除复杂度都是O(1))，被广泛的应用于各种程序设计中。链表一般分为单向链表和双向链表。对于单向链表，其删除和插入的一般复杂度都是O(n)，所以，工程上一般很少使用，下面介绍的所有链表都是双向链表。 常见的双向链表数据结构定义如下： struct list_node_xxx{ struct list_node_xxx *prev，*next； //具体的数据，比如一个char数组 char data[100]; };
数据结构---顺序表，链表
includeevey的博客
08-03 2476
2w字带你走进链表
c语言数据结构---链表
邓富民的博客
12-08 954
1.对链表的理解2.链表每个节点的创建3.输出链表链表的基本结构 首先，一条铁链，有多个节点，每两个节点之间会连接起来。 那么这些节点是如何创建的呢？ —结构体— 创建一个结构体类型，该结构体有两个成员，一个是数据data，一个是结构体指针。 为什么要这样创建呢？ 一条铁链，要有第一个节，第二个节，第三个节… 第一个节和第二个节之间，是不是互相扣在一起呢？下面： 结构体成员设置完后
数据结构-单向循环链表
没出过地球
06-11 2006
定义：单向环形链表是指在单链表的基础上，最后一个节点的指针域指向链表的第一个节点，从而构成一个闭合的环。结构：每个节点包含一个数据域和一个指针域。数据域用于存储数据，指针域用于指向下一个节点。在单向环形链表中，最后一个节点的指针域指向第一个节点，形成环状结构。
链表_数据结构--链表_
10-01
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。与数组不同，链表的元素不是在内存中连续存储，而是通过节点之间的引用连接起来。每个节点通常包含两个部分：数据...
数据结构-链表的C语言使用
03-25
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在C语言中，链表不像是数组那样在内存中连续存储元素，而是通过一系列分散的内存块（称为节点）来表示数据。每个...
数据结构学习--线性表及其应用--链表
06-25
通过这些基本操作的实践，学生可以深入理解链表的工作原理和操作方式，这不仅有助于掌握链表的实现，还能为后续学习如栈、队列、树等更复杂的数据结构奠定基础。此外，了解链表的优缺点有助于在实际问题中选择合适的...
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 675
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
数据结构----链表
新手嵌入式学习的博客
08-16 1194
数据结构顺序表中单向链表（包括有头单向链表，无头单向链表，单向循环链表）
数据结构：栈
最新发布
2301_80744520的博客
08-17 334
顺序栈的表示存储方式：利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素。栈底一般在低地址。top：指示栈顶元素位置base：指示栈底元素位置stacksize：表示栈的最大容量接下来，我们用更详细的一幅图来描述顺序栈：起始状态，top和base都指向0的位置，此时是空栈：base==top，且栈的容量stacksize=4。接下来为空的栈添加元素（入栈），将新的元素添加到top所指位置，再将top移向下一位置，我们最终可以观察到top并没有指向D，而是栈的外面，即4的位置。
uva1586分子量（Molar Mass,ACM/ICPC Danang 2007）
2301_80844586的博客
08-14 242
然后代码具体要考虑i++每次进行i++自动i++这样避免算完字母后碰到数字然后会多算一次字母。就是一位算数字后i++如果【i+2】就是匹配到两位数的话再次i++；这样可以有效避免数字越界（你可以好好思考一下）如果都没有就是1直接定义1即可。第一个是有四个字母然后把for循环中匹配到的字母进行确认到z里面后面进行。第二的大逻辑就行下面的if那个三大判断条件第一个是一位数并且是。也是改了小两天，然后说一下核心代码逻辑两大块的核心。就是没有数字的就是1的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

run sun

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值