PAT 乙级 1025.反转链表 C++/Java

给定一个常数

输入格式：

每个输入包含 1 个测试用例。每个测试用例第 1 行给出第 1 个结点的地址、结点总个数正整数

接下来有

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

分析：

1. 用结构体来保存链表结点的 Address Data Next，用大数组存储每一个链表结点，而且数组的下标对应链表结点的地址

2. 将数组中的结点，按顺序保存到一个新数组 orderList ,这样还可以删除掉多余的结点

3. 对 orderList 中的结点进行反转，每K个结点就反转一次，不到K的就不反转

4. 将剩余没有反转的结点压入 revList

5. 修改 revList 中结点的next值，只需要 revList[i].next = revList[i + 1].address ，注意不要越界

6. 输出（注意输出格式）

反转链表的思路：

用数组 revList 保存反转后的链表，最后输出也是对这个数组进行操作

假定 orderList 长度为 size = 7 ，顺序为 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 ，每 K = 2 个结点就反转1次

令 temp = K - 1 = 1

for 循环，从 i = temp = 1开始，一直到 temp - K + 1 = 0，这部分的内容压入 revList ，然后 temp += K，如果temp >= size时结束循环

文字模拟一次：

temp = K - 1 = 2

当 temp < size = 7 时循环：

　　 i = temp = 1; i > temp -K = -1; --i 将 orderList[i = 1, 0] 压入 revList

　　//　　 revList 的内容： 2 - > 1

　　更新 temp 的值：temp += K　　// temp = 1 + 2 = 3

i = temp = 3; i > temp -K = 1; --i 将 orderList[i = 3, 2] 压入 revList

　　//　　 revList 的内容： 2 -> 1 -> 4 -> 3

　　更新 temp 的值：temp += K　　// temp = 3 + 2 = 5

　　 i = temp = 5; i > temp -K = 1; --i 将 orderList[i = 5, 4] 压入 revList

　　//　　 revList 的内容： 2 -> 1 -> 4 -> 3 -> 6 -> 5

　　更新 temp 的值：temp += K　　// temp = 5 + 2 = 7

　　temp 不满足 temp < size ，退出循环

将剩余没有反转的结点压入 revList ，我们怎么知道哪里没有反转呢？

最后一次反转的时候，i 是从 temp = 5开始反转的，i = 5, i = 4这两个结点反转。

也就是说，temp + 1往后的结点就是没有反转的

需要注意的是：退出循环的时候，temp += K，所以我们要从下标为 temp + 1 - K的结点开始压入 revList

关于输出格式：

用 printf("%05d", address) 输出地址

C++实现：

#include <iostream>
#include <vector>
#include <string>
#include <cstdio>
#include <string>
#include <algorithm>
#include <stack>
#include <map>
#include <queue>
#include <unordered_set>
#include <unordered_map>

using namespace std;

typedef struct Node {
    int address;
    int data;
    int next;
}Node;

Node arr[100005];

int main() {
    int first, N, K;
    cin >> first >> N >> K;


    Node tempNode;
    for (int i = 0; i < N; ++i) {
        cin >> tempNode.address >> tempNode.data >> tempNode.next;
        arr[tempNode.address] = tempNode;
    }

    vector<Node> orderList;
    vector<Node> revList;

    int p = first;
    while (p != -1) {
        orderList.push_back(arr[p]);
        p = arr[p].next;
    }

    int size = orderList.size();    // 有效结点的个数
    int temp = K - 1;
    while (temp < size) {
        // 反转链表的结点
        for (int i = temp; i > temp - K; --i) {
            revList.push_back(orderList[i]);
        }
        temp += K;    // 更新temp的值，每K个反转一次，不足K个就结束循环
    }

    // 将剩余的结点按顺序压入revList
    for (int i = temp + 1 - K; i < size; ++i) {
        revList.push_back(orderList[i]);
    }

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

    // 输出最后一个结点
    printf("%05d %d %d", revList[size - 1].address, revList[size - 1].data, -1);
    cout << endl;
    system("pause");
    return 0;
}

Java实现：

来源：https://www.cnblogs.com/47Pineapple/p/12258207.html

标签

链表

temp