1025 反转链表 (25 分) PAT乙级 C++/Python版-优快云博客

本文链接：https://blog.youkuaiyun.com/q839219286/article/details/90642863

1025 反转链表 (25 分) PAT (Basic Level) Practice （中文）

给定一个常数 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 表示。

接下来有 N 行，每行格式为：

Address Data Next

其中 Address 是结点地址，Data 是该结点保存的整数数据，Next 是下一结点的地址。

输出格式：

对每个测试用例，顺序输出反转后的链表，其上每个结点占一行，格式与输入相同。

输入样例：

00100 6 4
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218

输出样例：

00000 4 33218
33218 3 12309
12309 2 00100
00100 1 99999
99999 5 68237
68237 6 -1

作者: CHEN, Yue

单位: 浙江大学

时间限制: 400 ms

内存限制: 64 MB

代码长度限制: 16 KB

分析：

输入的节点信息，并不是按链表顺序输入的。这意味着必须将输入信息存起来。
有可能存在“虚假节点”，即该节点并不在实际所求的链表上。
由于题目没有交代若该链表是空链表时如何输出，可以认为链表至少有一个节点。
每凑够K个节点来一轮逆置，但最后若凑不够K个则不逆置！所以要预判数量。
注意输出的地址要凑足5位数，除了-1外。

解题思路：

直接映射哈希法存储节点：由分析1，且有效地址是不超过5位数的非负整数，用长度为100000的数组A[]存储节点。
用顺序表模拟链表：用数组link[]按链表的顺序存储输入所代表的链表，但只存储<address,data>，因为可以用下标遍历而不需要next。（反正都用了哈希存储，空间复杂度不可能＜O(N)了）
在顺序表(link[])中完成逆置：每凑够K个节点来一轮逆置，逆置操作用双指针迭代交换完成，最后不足K个节点跳出。
将link[]模拟的链表打印出来：注意链表长度不一定为N，要以实际记录的长度为准，可以在link[]末端插入地址-1作为哨兵。

Python3版本：（有超时）

因为最近在学Python，所以一开始就上手Python代码，如下：

#1025 反转链表 (25 分)
link=[None]*100000  #add最大99999
head,N,K=map(int,input().split(' '))
for i in range(N):
    add,data,next=map(int,input().split(' '))
    link[add]=[data,next]
T,p=[],head
while -1!=p:
    if None==link[p]:break
    #print(p,*node)
    T.append(["%05d"%(p) ,link[p][0]])
    p=link[p][1]
for j in range(K-1,len(T),K):
    i=j-K+1
    while i<j:
        T[i],T[j]=T[j],T[i]
        i+=1
        j-=1
T.append(['-1'])
for i in range(len(T)-1):
    print("%s %d %s"%(T[i][0],T[i][1],T[i+1][0]))

Python的优点是代码简洁，但因为其是解释型程序，当代码有大量循环语句和输入输出时，那就坑了。如果有大佬能用Python版本AC的，请赐教。

C++版本（AC）

和上面的Python解法完全一样，只因为输入输出快了，所以能AC。

//1025 反转链表 (25 分)
#include <stdio.h>
#include<map>
using namespace std;
pair<int, int> A[100000];	//0~99999   A[]=<data,next>
int main(){
	int head, N, K;
	scanf("%d %d %d", &head, &N, &K);
	pair<int, int> *link = new pair<int, int>[N+1];	//用顺序表模拟链表
	while (N-- > 0) {
		int p, data, next;
		scanf("%d %d %d", &p, &data, &next);
		A[p] = { data,next };	//直接映射哈希存储：p为关键词
	}
	int len = 0;	//link数组（代表链表）的有效长度
	while (-1 != head) {
		link[len++] = { head,A[head].first };	//={add,data}
		head = A[head].second;					//=next
	}
	for (int step = K; step <= len; step+=K) {	//每凑足K个逆置
		for (int i = step - K, j = step - 1; i < j; i++, j--) {
			swap(link[i], link[j]);	//交换
		}
	}
	for (int i = 0; true; ) {
		printf("%05d %d ", link[i].first, link[i].second);
		if (++i<len) 
			printf("%05d\n", link[i].first);
		else{	//是最后一个
			printf("-1\n"); break;
		} 
	}
	return 0;
}

其实没比Python版本长多少，所以此题不适合用Python。