PAT 1074 Reversing Linked List

1074 Reversing Linked List (25point(s))

Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 1→2→3→4→5→6, if K=3, then you must output 3→2→1→6→5→4; if K=4, you must output 4→3→2→1→5→6.

Input Specification:

Each input file contains one test case. For each case, the first line contains the address of the first node, a positive N (≤10​5​​) which is the total number of nodes, and a positive K (≤N) which is the length of the sublist to be reversed. The address of a node is a 5-digit nonnegative integer, and NULL is represented by -1.

Then N lines follow, each describes a node in the format:

Address Data Next

where Address is the position of the node, Data is an integer, and Next is the position of the next node.

Output Specification:

For each case, output the resulting ordered linked list. Each node occupies a line, and is printed in the same format as in the input.

Sample Input:

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

Sample Output:

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

 思路

数据结构可以选用“静态链表”，其中，静态链表的结点可以设置一个变量用于表示结点性质

结点性质一般用于表示结点是否在链表中、结点是否有效、或者反映结点在链表中的位置等等

结点性质可用于排序，把离散的静态链表结点变成连续存放，方便进行题目要求的操作。

 

就好像这一题，我们那可以用变量order来记录静态结点的序号，order初始化为MAXN，即数组大小，然后遍历链表结点的时候，把结点的order变量设置成0，1，2，3... maxn-1

这样，我们就可以“对order从小到大排序”，排序后，有效结点(即order<MAXN)都在前面，而且是按照链表的遍历顺序存放

这样的话，对于题目：每k个数翻一次，就容易处理多了，直接利用reverse()函数即可，需要注意的是，最后一个分段的数的个数可能不够k个，这时不需要翻转

当翻转后，我们把每个结点的后继地址修改一下就行

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<algorithm>
#include<string>
#include<map>
#include<unordered_map>
#include<string.h>
#include<vector>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define maxn 100010

struct Node {
	int addr;//记录结点地址，方便后面修改后继地址
	int data;
	int order;//结点性质
	int next;
	Node() {
		order = maxn;
	}
}node[maxn];

bool cmp(Node x, Node y) {
	return x.order < y.order;
}

int main() {
	int n, k, begin, addr, cnt;
	cin >> begin >> n >> k;
	for (int i = 0; i < n; i++) {
		scanf("%d", &addr);
		node[addr].addr = addr;
		scanf("%d %d", &node[addr].data, &node[addr].next);
	}
	//遍历一次链表，标记order
	int p = begin, order = 0;
	while (p!=-1) {
		node[p].order = order;
		p = node[p].next;
		order++;
	}
	n = order;

	sort(node, node + maxn, cmp);//把离散的静态链表连续化存储
	//每k个数翻转一次
	for (int i = 0; i < n; i += k) {
		if (i + k <= n) {
			reverse(node + i, node + i + k);
		}
	}
	//修改每个结点的后继地址
	int i;
	for (i = 0; i < n - 1; i++) {
		node[i].next = node[i + 1].addr;
	}
	node[n - 1].next = -1;
	//输出
	for (i = 0; i < n - 1; i++) {
		printf("%05d %d %05d\n", node[i].addr, node[i].data, node[i].next);
	}
	printf("%05d %d -1\n", node[n - 1].addr, node[n - 1].data);
	return 0;
}