PAT 乙級 1025.反轉鏈表 C++/Java

題目來源

給定一個常數 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 (≤)、以及正整數 K (≤)，即要求反轉的子鏈結點的個數。結點的地址是 5 位非負整數，NULL 地址用 − 表示。

接下來有 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

分析：

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實現：