PAT Basic 1025 反转链表

1025 反转链表

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

解题思路

通过元素的首尾地址连接为一个链表 规律就是前一个元素的尾地址是链表中下一个元素的尾地址，就按照的这个规律将链表元素排序， 排序完成后一定要按要求反转，题目要求的是每k个元素反转(这一点不细看也会错，我一开始就没注意到)，如果出现多余的元素就不反转。

错误分析

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
using namespace std;
struct node{
    string beg, en;
    int data;
};
int main(){
    string s;
    int n ,k, t = 0;
    cin >> s >> n >> k;
    vector<node> v(n), vt;
    for(int i = 0; i < n; i++){
        cin >> v[i].beg >> v[i].data >> v[i].en;
    }
    while(s != "-1"){
        for(int i = 0; i < v.size(); i++){
            if(v[i].beg == s){
                vt.push_back(v[i]);
                s = v[i].en;
                break;
            }
        }
    }
    for(int i = 1; i <= vt.size() / k; i++){
        reverse(vt.begin() + k * (i - 1), vt.begin() + k * i);
    }
    for(int i = 0; i < vt.size(); i++){
        printf("%s %d %s\n", vt[i].beg.c_str(), vt[i].data, vt[i].en.c_str());
    }
    return 0;
}

貌似很轻松解决了~ 提交一看

以上的其实存在错误 运行的话 就4 分 还有一个超时~ 看看输出结果

每个结点的尾部地址，并不是下一个的首部地址，而是原来位置下一节点的首部地址，这是需要更正 每个结点的尾部地址，在反转后添加一下代码来更改尾部地址：

    for(int i = 0; i < vt.size() - 1; i++){
            vt[i].en = vt[i + 1].beg;
    }
    vt[vt.size() - 1].en = "-1";

更改后

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
using namespace std;
struct node{
    string beg, en;
    int data;
};
int main(){
    string s;
    int n ,k, t = 0;
    cin >> s >> n >> k;
    vector<node> v(n), vt;
    for(int i = 0; i < n; i++){
        cin >> v[i].beg >> v[i].data >> v[i].en;
    }
    while(s != "-1"){
        for(int i = 0; i < v.size(); i++){
            if(v[i].beg == s){
                vt.push_back(v[i]);
                s = v[i].en;
                break;
            }
        }
    }
    for(int i = 1; i <= vt.size() / k; i++){
        reverse(vt.begin() + k * (i - 1), vt.begin() + k * i);
    }
    for(int i = 0; i < vt.size() - 1; i++){
            vt[i].en = vt[i + 1].beg;
    }
    vt[vt.size() - 1].en = "-1";
    for(int i = 0; i < vt.size(); i++){
        printf("%s %d %s\n", vt[i].beg.c_str(), vt[i].data, vt[i].en.c_str());
    }
    return 0;
}

依然存在问题， 超时，这个方法麻烦的地方在于通过地址给链表排序，两重循环时间复杂度高 肯定在出现大量数据时就会超时，解决此问题就会全部AC啦

解题代码

更改踩了不少坑看看那些问题

1. 每k个元素反转，
2. 反转后 每个结点的尾部地址改正
3. 排序链表元素两重循环会超时

总结：做题一定要注意细节，注意细节，细节,否则会错的很惨，也浪费时间，不注意细节这样的感觉就是： 说你不会吧， 按照思路可以写出来，自己编译那个例子还过了，说你会吧，一提交还是好多错??

好，回到这道题：将结构体类型改为int，添加一个数组保存每个结构体信息，index[首地址] = 包含此首地址的结构体，这样将address data next就联系起来通过一次循环完成排序。

代码如下：

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
using namespace std;
struct node{
    int  beg, data, en;
};
int main(){
    int n ,k, ibeg;
    cin >> ibeg >> n >> k;
    vector<node> v(n), vt;
    node index[100000] = {0};
    for(int i = 0; i < n; i++){
        cin >> v[i].beg >> v[i].data >> v[i].en;
        index[v[i].beg] = v[i];
    }
    while(ibeg != -1){
        vt.push_back(index[ibeg]);
        ibeg = index[ibeg].en;
    }
    for(int i = 1; i <= vt.size() / k; i++){
        reverse(vt.begin() + k * (i - 1), vt.begin() + k * i);
    }
    for(int i = 0; i < vt.size() - 1; i++){
            vt[i].en = vt[i + 1].beg;
    }
    vt[vt.size() - 1].en = -1;
    for(int i = 0; i < vt.size() - 1; i++){
        printf("%05d %d %05d\n", vt[i].beg, vt[i].data, vt[i].en);
    }
    printf("%05d %d -1", vt[vt.size() - 1].beg, vt[vt.size() - 1].data);
    return 0;
}