<PTA>Reversing Linked List

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$ ($\le 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

题目大意是给定N组数据，每组数据包括地址，数据以及下一组数据的地址，如果某一组数据是最后一组，则它的下一组数据地址用-1表示。给定K <=N, 表示每K个数据逆置一次，现在让你输出逆置后的数据。

代码如下：

#include<iostream>
#include<unordered_map>
#include<algorithm>
using namespace std;
struct Node{
    int data;
    int next_address;
};
typedef struct Node LNode;
int m[100010]; // 最多有99999个元素
int main(){

    unordered_map<int, LNode> map;
    int first, N, K; // 第一个元素的地址，元素总数， 每次逆置的元素个数
    int address, data, next_address;
    cin >> first >> N >> K;
    while(N--){
        cin >> address >> data >> next_address;
        map[address].data = data;
        map[address].next_address = next_address;
    }
    int i = 0, j = first;
    while(j != -1){ // 将每个元素的地址放到数组m[]中
        m[i++] = j;
        j = map[j].next_address;
    }
    j = 0;
    while(j+K <= i){ 
            // 每隔K个元素逆置一次，由于reverse(begin, end)函数逆置的区间是[begin, end),所以循环的条件是j+K<=i
        reverse(&m[j], &m[j+K]);
        j = j+K;
    }

    for(j = 0; j < i-1; j++){
        printf("%05d %d %05d\n", m[j], map[m[j]].data, m[j+1]);
    }
    printf("%05d %d -1", m[j], map[m[j]].data);

    return 0;
}