PAT-BASIC1025——反转链表/PAT-ADVANCED1074/Data Structures and Algorithms7-2——Reversing Linked List

最新推荐文章于 2023-10-04 17:26:34 发布
最新推荐文章于 2023-10-04 17:26:34 发布
阅读量294 收藏
点赞数
分类专栏： PAT乙级真题题解 PAT甲级真题题解 Data Structures and Algorithms 文章标签： PAT 甲级、乙级 链表 1025、1074 反转链表、Reversing Linked List
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41231926/article/details/83278019
版权

我的PAT-BASIC代码仓：https://github.com/617076674/PAT-BASIC

我的PAT-ADVANCED代码仓：https://github.com/617076674/PAT-ADVANCED

我的Data Structures and Algorithms代码仓：https://github.com/617076674/Data-Structures-and-Algorithms

原题链接：

PAT-BASIC1025：https://pintia.cn/problem-sets/994805260223102976/problems/994805296180871168

PAT-ADVANCED1074：https://pintia.cn/problem-sets/994805342720868352/problems/994805394512134144

Data Structures and Algorithms7-2：https://pintia.cn/problem-sets/16/problems/664

题目描述：

PAT-BASIC1025：

PAT-ADVANCED1074、Data Structures and Algorithms7-2：

知识点：链表

思路一：用vector来保存输入的数据（在PAT中提交测试点5会超时）

这个思路的大致情况如下：

为便于描述，我们将待翻转的每一段链表称作分链表。

（1）定义一个结构体point，里面有3个int型变量，address、data和next。

（2）用一个vector<point>型变量points接收输入的各节点信息。由于题目所给的节点信息并不是按照链表的顺序给的。所以我们需要根据题目给的首节点地址firstPointAddress在points中寻找出链表应该有的正确顺序。

（3）对于每一个节点地址tempAddress，我们都需要在points中寻找address值为tempAddress的point，并根据其next来寻找下一个point，直至tempAddress为-1，我们可以跳出循环，停止寻找。由于每次寻找address值为tempAddress的point时，我们都需要遍历整个points，这未免有点太浪费时间。因此，我用了一个vector<bool>型的变量flag来记录points中相应索引的节点是否已经被访问过。如果被访问过了，我们就可以不去判断其address值是否为tempAddress。

（4）在求得按链表顺序存储的vector<point>型变量beforeChangePoints之后，我们需要寻找每个分链表的首节点，将除了第一个分链表之外的首节点值存储在vector<point>型变量tempFirstPointAddresses中。

（5）做好了上述准备之后，我们可以来翻转链表。只要当前链表需要翻转，则进行以下循环。

a：如果当前分链表的下一个分链表需要翻转，那么当前分链表的首节点的next应该从tempFirstPointAddresses中读取。

b：如果当前分链表的下一个分链表不需要翻转

b-1：如果当前分链表的末端刚好是整个链表的末端，那么当前分链表的首节点的next值应该设为-1。

b-2：如果当前分链表的末端未到达整个链表的末端，那么当前分链表的首节点的next值应该是beforeChangePoints索引+k位置元素的address值。

（6）翻转完链表之后，beforeChangePoints中的链表顺序已被打乱，我们需要用一个新的vector<point>型变量afterChangePoints来记录新的链表顺序值。这个过程和（3）中的过程一模一样。

（7）最后，我们顺序输出afterChangePoints中的结果即可。

时间复杂度是O(n ^ 2)，其中n为输入链表中的节点个数。空间复杂度是O(n)。

由于在（3）、（7）步中排序链表节点之时花费的大量时间导致这个思路在测试点5超时了。

C++代码：

#include<iostream>
#include<vector>

using namespace std;

struct point {
	int address;
	int data;
	int next;
};

int main() {

	int firstPointAddress;
	int n;
	int k;

	cin >> firstPointAddress >> n >> k;

	vector<point> points;
	point tempPoint;
	int address;
	int data;
	int next;
	for (int i = 0; i < n; i++) {
		cin >> address >> data >> next;
		tempPoint.address = address;
		tempPoint.data = data;
		tempPoint.next = next;
		points.push_back(tempPoint);
	}

	vector<point> beforeChangePoints;
	int tempAddress = firstPointAddress;
	vector<bool> flag;
	for (int i = 0; i < points.size(); i++) {
		flag.push_back(false);
	}
	while (true) {
		for (int i = 0; i < points.size(); i++) {
			if (flag[i]) {
				continue;
			}
			if (points[i].address == tempAddress) {
				beforeChangePoints.push_back(points[i]);
				flag[i] = true;
				tempAddress = points[i].next;
				break;
			}
		}
		if (tempAddress == -1) {
			break;
		}
	}

	int index = 0;
	firstPointAddress = beforeChangePoints[k - 1].address;
	vector<point> tempFirstPointAddresses;
	for (int i = 2 * k; i <= beforeChangePoints.size(); i += k) {
		tempFirstPointAddresses.push_back(beforeChangePoints[i - 1]);
	}
	int count = 0;
	while (index + k <= beforeChangePoints.size()) {
		if (index + 2 * k <= beforeChangePoints.size()) {
			beforeChangePoints[index].next = tempFirstPointAddresses[count].address;
		} else {
			if (index + k == beforeChangePoints.size()) {
				beforeChangePoints[index].next = -1;
			} else {
				beforeChangePoints[index].next = beforeChangePoints[index + k].address;
			}
		}
		for (int i = index + 1; i < index + k; i++) {
			beforeChangePoints[i].next = beforeChangePoints[i - 1].address;
		}
		count++;
		index = index + k;
	}

	vector<point> afterChangePoints;
	tempAddress = firstPointAddress;
	vector<bool> flag2;
	for (int i = 0; i < beforeChangePoints.size(); i++) {
		flag2.push_back(false);
	}
	while (true) {
		for (int i = 0; i < beforeChangePoints.size(); i++) {
			if (flag2[i]) {
				continue;
			}
			if (beforeChangePoints[i].address == tempAddress) {
				afterChangePoints.push_back(beforeChangePoints[i]);
				flag2[i] = true;
				tempAddress = beforeChangePoints[i].next;
				break;
			}
		}
		if (tempAddress == -1) {
			break;
		}
	}

	for (int i = 0; i < afterChangePoints.size(); i++) {
		if (i != afterChangePoints.size() - 1) {
			printf("%05d %d %05d\n", afterChangePoints[i].address, afterChangePoints[i].data, afterChangePoints[i].next);
		} else {
			printf("%05d %d %d\n", afterChangePoints[i].address, afterChangePoints[i].data, afterChangePoints[i].next);
		}
	}
}

C++解题报告：

思路二：对思路一的改进，用一个大小为100000的数组来保存节点

address为i的值保存在数组中索引为i的位置，这样我们就可以用while循环来得到一个顺序的链表，节省大量时间。

时间复杂度是O(n)，其中n为输入链表中的节点个数。空间复杂度是O(100000)。

C++代码：

#include<iostream>
#include<vector>

using namespace std;

struct point {
	int address;
	int data;
	int next;
};

int main() {

	int firstPointAddress;
	int n;
	int k;

	cin >> firstPointAddress >> n >> k;

	point points[100000];
	point tempPoint;
	int address;
	int data;
	int next;
	for (int i = 0; i < n; i++) {
		cin >> address >> data >> next;
		tempPoint.address = address;
		tempPoint.data = data;
		tempPoint.next = next;
		points[address] = tempPoint;
	}

	vector<point> beforeChangePoints;
	int tempAddress = firstPointAddress;

	while (true) {
		beforeChangePoints.push_back(points[tempAddress]);
		tempAddress = points[tempAddress].next;
		if (tempAddress == -1) {
			break;
		}
	}

	int index = 0;
	firstPointAddress = beforeChangePoints[k - 1].address;
	vector<point> tempFirstPointAddresses;
	for (int i = 2 * k; i <= beforeChangePoints.size(); i += k) {
		tempFirstPointAddresses.push_back(beforeChangePoints[i - 1]);
	}
	int count = 0;
	while (index + k <= beforeChangePoints.size()) {
		if (index + 2 * k <= beforeChangePoints.size()) {
			beforeChangePoints[index].next = tempFirstPointAddresses[count].address;
		} else {
			if (index + k == beforeChangePoints.size()) {
				beforeChangePoints[index].next = -1;
			} else {
				beforeChangePoints[index].next = beforeChangePoints[index + k].address;
			}
		}
		for (int i = index + 1; i < index + k; i++) {
			beforeChangePoints[i].next = beforeChangePoints[i - 1].address;
		}
		count++;
		index = index + k;
	}

	point points2[100000];
	
	for (int i = 0; i < beforeChangePoints.size(); i++) {
		points2[beforeChangePoints[i].address] = beforeChangePoints[i];
	}

	vector<point> afterChangePoints;
	tempAddress = firstPointAddress;

	while (true) {
		afterChangePoints.push_back(points2[tempAddress]);
		tempAddress = points2[tempAddress].next;
		if (tempAddress == -1) {
			break;
		}
	}

	for (int i = 0; i < afterChangePoints.size(); i++) {
		if (i != afterChangePoints.size() - 1) {
			printf("%05d %d %05d\n", afterChangePoints[i].address, afterChangePoints[i].data, afterChangePoints[i].next);
		} else {
			printf("%05d %d %d\n", afterChangePoints[i].address, afterChangePoints[i].data, afterChangePoints[i].next);
		}
	}
}

C++解题报告：

思路三：在翻转过程中完全不考虑next指针的指向，最后统一处理

思路一和思路二的复杂之处在于，每次翻转分链表的时候就在考虑每一个节点next指向何处。其实完全没有必要，我们可以先把各个节点按要输出的顺序摆好，最后让其每个节点的next指向下一个节点，最后一个节点则指向-1即可。

时间复杂度是O(n)，其中n为输入链表中的节点个数。空间复杂度是O(100000)。

C++代码：

#include<iostream>
#include<vector>

using namespace std;

struct point {
	int address;
	int data;
	int next;
};

int main() {

	int firstPointAddress;
	int n;
	int k;

	cin >> firstPointAddress >> n >> k;

	point points[100000];
	point tempPoint;
	int address;
	int data;
	int next;
	for (int i = 0; i < n; i++) {
		cin >> address >> data >> next;
		tempPoint.address = address;
		tempPoint.data = data;
		tempPoint.next = next;
		points[address] = tempPoint;
	}

	vector<point> beforeChangePoints;
	int tempAddress = firstPointAddress;

	while (true) {
		beforeChangePoints.push_back(points[tempAddress]);
		tempAddress = points[tempAddress].next;
		if (tempAddress == -1) {
			break;
		}
	}
	vector<point> afterChangePoints;
	int index = 0;
	while (index + k <= beforeChangePoints.size()) {
		for (int i = index + k - 1; i >= index; i--) {
			afterChangePoints.push_back(beforeChangePoints[i]);
		}
		index = index + k;
	}
	for (int i = index; i < beforeChangePoints.size(); i++) {
		afterChangePoints.push_back(beforeChangePoints[i]);
	}
	for (int i = 0; i < afterChangePoints.size() - 1; i++) {
		afterChangePoints[i].next = afterChangePoints[i + 1].address;
	}
	afterChangePoints[afterChangePoints.size() - 1].next = -1;

	for (int i = 0; i < afterChangePoints.size(); i++) {
		if (i != afterChangePoints.size() - 1) {
			printf("%05d %d %05d\n", afterChangePoints[i].address, afterChangePoints[i].data, afterChangePoints[i].next);
		} else {
			printf("%05d %d %d\n", afterChangePoints[i].address, afterChangePoints[i].data, afterChangePoints[i].next);
		}
	}
}

C++解题报告：

清風逐尘乀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PTA1025 反转数组（启发式思路）
01-20
题目分析：本题难点在于链表节点的地址并非是对象的存储地址，而是认为给定的数字地址，所以本题的关键在于将给定的节点“串”在一起，然后通过翻转和遍历解决问题。 解题思路：构建结构体数组存储数据（足够大的数组），利用数组本身的连续性将节点串接（此时非有序），然后遍历数组，按照数字地址确定链表节点的先后顺序，按先后顺序将链表节点的地址依次存入另一数组之中（此时指针的先后顺序就是链表节点的先后顺序），然后利用函数reverse进行翻转，最后输出。 代码如下： #include #include #include #include using namespace std; const int N=1000
data-structures-and-algorithms:C ++中的数据结构和算法
03-30
数据结构和算法
1025 反转链表
最新发布
2303_76295261的博客
10-04 207
给定一个常数 K 以及一个单链表 L，请编写程序将 L 中每 K 个结点反转。例如：给定 L 为 1→2→3→4→5→6，K 为 3，则输出应该为 3→2→1→6→5→4；如果 K 为 4，则输出应该为 4→3→2→1→5→6，即最后不到 K 个元素不反转。每个输入包含 1 个测试用例。每个测试用例第 1 行给出第 1 个结点的地址、结点总个数正整数 N (≤105)、以及正整数 K (≤N)，即要求反转的子链结点的个数。结点的地址是 5 位非负整数，NULL 地址用 −1 表示。其中Address。
1025.反转链表（附三指针法）
T-T
07-13 623
反转链表是一道很经典的题目，曾经在微软面试题中出现过。本篇主要详细讲解三指针法，话不多说我们先来看下这道题目： 给定一个常数 K 以及一个单链表 L，请编写程序将 L 中每 K 个结点反转。例如：给定 L 为 1→2→3→4→5→6，K 为 3，则输出应该为 3→2→1→6→5→4；如果 K 为 4，则输出应该为 4→3→2→1→5→6，即最后不到 K 个元素不反转。 输入格式： 每个输入包...
1025 反转链表 (25分)
wulila的博客
06-14 241
1025 反转链表 (25分) 给定一个常数 K 以及一个单链表 L，请编写程序将 L 中每 K 个结点反转。例如：给定 L 为 1→2→3→4→5→6，K 为 3，则输出应该为 3→2→1→6→5→4；如果 K 为 4，则输出应该为 4→3→2→1→5→6，即最后不到 K 个元素不反转。 输入格式： 每个输入包含 1 个测试用例。每个测试用例第 1 行给出第 1 个结点的地址、结点总个数正整数 N (≤10​5​​)、以及正整数 K (≤N)，即要求反转的子链结点的个数。结点的地址是 5 位非负整数，NU
Data-Structures-and-Algorithms-[removed]用JavaScript实现的数据结构和算法
05-23
数据结构和算法JavaScript 用JavaScript实现的数据结构和算法
TypeScript-Data-Structures-and-Algorithms:TypeScript数据结构和算法库
03-29
来源**该项目来自我的研究，来自许多作者和指导者，其中包括Robert Sedgewick，Kevin Wayne，Aditya Bhargava 排序合并排序：自上而下| 自下而上快速排序：即将推出，2种，3种方式的变体搜寻中二进制搜索：T或-1的...
js-data-structures-and-algorithms：从0到1学习JavaScript数据结构与算法
02-05
JavaScript数据结构与算法本仓库内容根据哔哩哔哩哩视频整理的学习笔记，视频教程讲的特别好，配合本仓库的代码测试环境来练习，学习效果更佳，欢迎同学们Star和叉子。推荐大家按照目录结构的顺序来学习，由浅入深，...
Data-Structures-and-Algorithms-in-[removed]用JavaScript实现的数据结构和算法
03-07
JavaScript中的数据结构和算法可视化数据结构和算法 数据结构大批哈希表链表单链表双链表堆使用链表使用数组队列使用链表使用堆栈二进制搜索树（BST） 演算法数组中的TwoPairsSum 反转字符串第一个重复出现的字符...
反转链表C实现
06-14
反转链表C实现
PAT——1025 反转链表
Jamaple的博客
03-01 107
给定一个常数 K 以及一个单链表 L，请编写程序将 L 中每 K 个结点反转。例如：给定 L 为 1→2→3→4→5→6，K 为 3，则输出应该为 3→2→1→6→5→4；如果 K 为 4，则输出应该为 4→3→2→1→5→6，即最后不到 K 个元素不反转。
【PAT乙级】1025 反转链表
Weber Zhou 的博客
12-19 721
PAT 乙级(Basic Level) Practice --- 《1025 反转链表》 c语言解题代码
PAT 乙级 1024 科学计数法
l_d_x的博客
03-30 301
科学计数法是科学家用来表示很大或很小的数字的一种方便的方法，其满足正则表达式 [+-][1-9].[0-9]+E[+-][0-9]+，即数字的整数部分只有 1 位，小数部分至少有 1 位，该数字及其指数部分的正负号即使对正数也必定明确给出。 现以科学计数法的格式给出实数A，请编写程序按普通数字表示法输出A，并保证所有有效位都被保留。 输入格式： 每个输入包含 1 个测试用例，即一个以科学计数法表示的实数A。该数字的存储长度不超过 9999 字节，且其指数的绝对值不超过 9999。 输出格...
PAT 乙级 1025 反转链表 (25)（25 分）
宝付支的博客
08-14 565
1025 反转链表 (25)（25 分） 给定一个常数K以及一个单链表L，请编写程序将L中每K个结点反转。例如：给定L为1→2→3→4→5→6，K为3，则输出应该为3→2→1→6→5→4；如果K为4，则输出应该为4→3→2→1→5→6，即最后不到K个元素不反转。 输入格式： 每个输入包含1个测试用例。每个测试用例第1行给出第1个结点的地址、结点总个数正整数N(&lt;= 10^5^)、以及正...
1025 反转链表（附详细注释，逻辑分析）
kngines
08-13 177
写在前面 实现思路 结构体封装数据 根据order重新排序 k区间值迭代翻转 n整除k，则最后地址输出"-1" 非整除，最后剩余区间，原序输出。最后地址输出"-1" 题目有难度，区间边界值、实现方案费时间 测试用例 input: 00100 6 4 00000 4 99999 00100 1 12309 68237 6 -1 33218 3 00000 99999 5 682...
pat1025反转链表
脚踏实地，仰望星空
02-19 586
1025. 反转链表 (25) 时间限制 300 ms 内存限制 65536 kB 代码长度限制 8000 B 判题程序 Standard 作者 CHEN, Yue 给定一个常数K以及一个单链表L，请编写程序将L中每K个结点反转。例如：给定L为1→2→3→4→5→6，K为3
C语言PAT刷题 - 1025 反转链表
扶酒劝斜阳的博客
10-25 786
并非大佬，仅仅分享自己在PAT刷题过程中的解题思路，希望能对遇到问题的朋友有所帮助。若有错漏，欢迎指正，也欢迎大家分享更好的方法。
data structures and algorithms in java 2nd 编程作业
09-14
《Java数据结构与算法（第二版）》是一本专注于介绍Java中数据结构和算法的教材。它主要包含理论知识和编程实践，通过学习这本教材，读者可以掌握Java编程中常用的数据结构和算法，并且能够应用到实际项目开发中。 该教材的编程作业是为了帮助读者巩固所学的知识，并且提供实践机会。这些作业通常涉及到应用到实际场景中的数据结构和算法，读者需要通过编写Java代码来解决特定的问题。 在这些编程作业中，读者需要运用所学的知识来构建和操作各种数据结构，比如链表、栈、队列、二叉树等。同时，还需要使用各种算法来实现数据的查找、排序、插入、删除等操作。通过完成这些作业，读者能够更好地理解数据结构和算法的运作原理，并且提高自己的编程实践能力。 总之，通过完成《Java数据结构与算法（第二版）》的编程作业，读者能够巩固所学的知识，提高编程实践能力，并且能够更好地应用数据结构和算法解决实际问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值