C语言PAT刷题 - 1025 反转链表

扶酒劝斜阳

于 2022-10-25 22:40:55 发布

阅读量816

点赞数 1

分类专栏： C语言PAT刷题(乙级) 文章标签： c语言

本文链接：https://blog.csdn.net/qq_59586512/article/details/127522788

版权

C语言PAT刷题(乙级) 专栏收录该内容

34 篇文章 41 订阅

订阅专栏

作者的话：若有朋友复制代码去PAT试着运行遇到问题的：
1.可能是格式问题，可以先把从本站复制的代码粘贴到记事本，再把记事本里的代码复制，然后粘贴到PAT的代码区，提交本题回答，应该就可以了；
2.可能是注释原因，PAT有时候检测到注释会编译错误，所以可以先把注释删了，再进行提交回答；
3.可能是作者当初根据题目写出来的代码仍存在一些疏漏，而恰好当时的测试机制没那么完善，没检测出问题。后面测试机制有所更新，故出现问题，若有相关需要的可以评论区留言或私信作者，我看到的话会去再查一下疏漏之处，然后更新文章。

一、题目描述
给定一个常数 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 (≤10⁵)、以及正整数 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

二、解题思路
读题：
//数组是连续的空间，连续的存放各个元素的值
//链表是不连续的，每个元素可以看成一个结构体类型，一个是数据，一个是下一个元素的地址
//所以遍历链表就是先找第一个元素，得到数据，然后根据第一个元素中存储的下一个元素地址去找下一个元素，再获取下一个元素的数据，以此类推
//由输入输出样例可知，所谓的反转，就是在n个结点中每k个结点进行逆序，再和后面的结点相连，不到k个结点不参与反转，并且反转后结点存储的当前地址不改变，数据也不改变，只改变当前节点中存储的下一个节点的地址
思路：
0.标准C源程序框架
1.定义结构体类型Link，模拟链表结构，存储数据、当前地址、下一个元素的地址（真正的链表好像不储存当前地址，而且好像是使用容器实现的，不太了解）；
2.定义需要的变量并接收数据；
3.找到链表首节点，将其内容与数组首元素的内容进行交换；
4.根据首节点中存储的下一个节点的地址，找到下一个节点，将他与link[2]互换，以此类推；
5.将链表根据反转后的顺序打印相应内容。n/k是几，就说明有几组子链节点反转，一轮循环代表处理一组要反转的子链节点；
6.上面处理的是经历过反转的内容，若n%k!=0，则还有部分元素因为不到k没有经历反转，按原顺序输出。

三、具体实现
0.标准C源程序框架

#include <stdio.h>
int main()
{
    return 0;
}

1.定义结构体类型Link，模拟链表结构，存储数据、当前地址、下一个元素的地址（真正的链表好像不储存当前地址，而且好像是使用容器实现的，不太了解）；

struct Link
{
    char cur[6];
    int data;
    char next[6];
};

2.定义需要的变量并接收数据；

    char first[6];//存储首结点地址
    int n;//存储结点总个数
    int k;//存储要求反转的子链节点的个数
    int i = 0, j = 0, p = 0;// 循环变量
    struct Link link[100000];//存储链表的每个节点的内容
    struct Link temp;
    scanf("%s%d%d", first, &n, &k);//接收第一行的数据——首结点地址 结点总个数 要求反转的子链节点的个数
    //接收后面的N行数据 —— 结点地址 该结点保存的整数数据 下一结点的地址
    for (i = 0; i < n; i++)
    {
        scanf("%s%d%s", link[i].cur, &link[i].data, link[i].next);
    }

3.找到链表首节点，将其内容与数组首元素的内容进行交换；

    //找到链表首节点，将其内容与数组首元素的内容进行交换
    for (i = 0; i < n; i++)
    {
        j = 0;
        while (link[i].cur[j] != '\0' && first[j] != '\0')
        {
            if (link[i].cur[j] != first[j])   break;
            j++;
        }
        if (link[i].cur[j] == '\0' && first[j] == '\0')
        {
            temp = link[i];
            link[i] = link[0];
            link[0] = temp;
            break;
        }
    }

4.根据首节点中存储的下一个节点的地址，找到下一个节点，将他与link[2]互换，以此类推；

    //此时link[0]存储的是首节点内容
    //接下来根据首节点中存储的下一个节点的地址，找到下一个节点，将他与link[2]互换，以此类推
    for (i = 0; i <= n - 2; i++)//数组总共有n个元素，要使其按节点顺序排列，就要让每个元素去到自己该去的位置
    {
        for (j = i + 1; j < n; j++)
        {
            p = 0;
            while (link[i].next[p] != '\0' && link[j].cur[p] != '\0')
            {
                if (link[i].next[p] != link[j].cur[p])   break;
                p++;
            }
            if (link[i].next[p] == '\0' && link[j].cur[p] == '\0')
            {
                temp = link[j];
                link[j] = link[i + 1];
                link[i + 1] = temp;
                break;
            }
        }
        //下一句是帮我搞定测试点6的宝贝代码
        if (link[i].next[p] != '\0') { n--;i--;  }//如果循环出来link[i].next[p]依然不等于'\0'，说明剩下的元素并不和之前的结点相连，属于无效结点，输出时应省去
    }

5.将链表根据反转后的顺序打印相应内容。n/k是几，就说明有几组子链节点反转，一轮循环代表处理一组要反转的子链节点；

    //此时的link数组把链表结点的内容按结点顺序存储在各元素中，link[0]就是首节点，link[i]即第i+1个结点
    //接下来将链表根据反转后的顺序打印相应内容
    for (p = 0; p < n / k; p++)//n/k是几，就说明有几组子链节点反转，一轮循环代表处理一组要反转的子链节点
    {
        for (i = p * k + k - 1; i > p * k; i--)
        {
            printf("%s %d %s\n", link[i].cur, link[i].data, link[i - 1].cur);
        }
        if (p + 1 < n / k)
            printf("%s %d %s\n", link[i].cur, link[i].data, link[(p + 1) * k + k - 1].cur);
        else
        {
            if (n % k != 0)
            {
                printf("%s %d %s\n", link[i].cur, link[i].data, link[p * k + k].cur);
            }
            else
                printf("%s %d %s", link[i].cur, link[i].data, "-1");
        }

    }

6.上面处理的是经历过反转的内容，若n%k!=0，则还有部分元素因为不到k没有经历反转，按原顺序输出。

    //上面处理的是经历过反转的内容，若n%k!=0，则还有部分元素因为不到k没有经历反转，按原顺序输出
    n %= k;
    i = 0;
    while (n--)
    {
        printf("%s %d %s", link[p * k + i].cur, link[p * k + i].data, link[p * k + i].next);
        if(n>0)     printf("\n");
        i++;
    }

四、测试数据
输入样例1：
00100 6 4
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218
输出样例1：
00000 4 33218
33218 3 12309
12309 2 00100
00100 1 99999
99999 5 68237
68237 6 -1
输入样例2：（当结点集合的开头和中间有无效结点时能否正确处理）（测试点6）
00001 6 3
00009 9 -1
00001 1 00002
00002 2 00003
00003 3 00004
00008 8 -1
00004 4 -1
输出样例2：
00003 3 00002
00002 2 00001
00001 1 00004
00004 4 -1
输入样例3：（当出现结点地址为空地址时无效结点时能否正确处理）
00001 5 3
-1 -1 -1
00001 1 00002
00002 2 00003
00003 3 00004
00004 4 -1
输出样例3：
（很多人说这种情况下-1为当前地址的元素不应该输出，并说这个是测试点6过不去的原因，但是我之前试了很多次，发现把这个改好还是过不了测试点6，最后没管这个，转而去实现样例2倒是能过去，所以至少到目前为止，样例3这种情况输出当前地址为-1的元素也没事，后面会不会加这种情况的测试数据就不知道了，不过反正也好改，你在接收数据的时候接收到当前地址为-1的元素时用后面元素将其覆盖就好，即在接收的循环里加这句if(link[i].cur[0]==‘-’){ n–;i–; }，我测试过了，也是正确的）
00003 3 00002
00002 2 00001
00001 1 00004
00004 4 -1
-1 -1 -1
输入样例4：（当出现无效结点时能否正确处理）
00001 5 3
00001 1 00002
00008 8 00009
00002 2 00003
00003 3 00004
00004 4 -1
输出样例4：
00003 3 00002
00002 2 00001
00001 1 00004
00004 4 -1
五、全部代码

#include <stdio.h>
struct Link
{
    char cur[6];
    int data;
    char next[6];
};
int main()
{
    char first[6];//存储首结点地址
    int n;//存储结点总个数
    int k;//存储要求反转的子链节点的个数
    int i = 0, j = 0, p = 0;// 循环变量
    struct Link link[100000];//存储链表的每个节点的内容
    struct Link temp;
    scanf("%s%d%d", first, &n, &k);//接收第一行的数据——首结点地址 结点总个数 要求反转的子链节点的个数
    //接收后面的N行数据 —— 结点地址 该结点保存的整数数据 下一结点的地址
    for (i = 0; i < n; i++)
    {
        scanf("%s%d%s", link[i].cur, &link[i].data, link[i].next);
    }
    //找到链表首节点，将其内容与数组首元素的内容进行交换
    for (i = 0; i < n; i++)
    {
        j = 0;
        while (link[i].cur[j] != '\0' && first[j] != '\0')
        {
            if (link[i].cur[j] != first[j])   break;
            j++;
        }
        if (link[i].cur[j] == '\0' && first[j] == '\0')
        {
            temp = link[i];
            link[i] = link[0];
            link[0] = temp;
            break;
        }
    }
    //此时link[0]存储的是首节点内容
    //接下来根据首节点中存储的下一个节点的地址，找到下一个节点，将他与link[2]互换，以此类推
    for (i = 0; i <= n - 2; i++)//数组总共有n个元素，要使其按节点顺序排列，就要让每个元素去到自己该去的位置
    {
        for (j = i + 1; j < n; j++)
        {
            p = 0;
            while (link[i].next[p] != '\0' && link[j].cur[p] != '\0')
            {
                if (link[i].next[p] != link[j].cur[p])   break;
                p++;
            }
            if (link[i].next[p] == '\0' && link[j].cur[p] == '\0')
            {
                temp = link[j];
                link[j] = link[i + 1];
                link[i + 1] = temp;
                break;
            }
        }
        //下一句是帮我搞定测试点6的宝贝代码
        if (link[i].next[p] != '\0') { n--;i--;  }//如果循环出来link[i].next[p]依然不等于'\0'，说明剩下的元素并不和之前的结点相连，属于无效结点，输出时应省去
    }
    
    //此时的link数组把链表结点的内容按结点顺序存储在各元素中，link[0]就是首节点，link[i]即第i+1个结点
    //接下来将链表根据反转后的顺序打印相应内容
    for (p = 0; p < n / k; p++)//n/k是几，就说明有几组子链节点反转，一轮循环代表处理一组要反转的子链节点
    {
        for (i = p * k + k - 1; i > p * k; i--)
        {
            printf("%s %d %s\n", link[i].cur, link[i].data, link[i - 1].cur);
        }
        if (p + 1 < n / k)
            printf("%s %d %s\n", link[i].cur, link[i].data, link[(p + 1) * k + k - 1].cur);
        else
        {
            if (n % k != 0)
            {
                printf("%s %d %s\n", link[i].cur, link[i].data, link[p * k + k].cur);
            }
            else
                printf("%s %d %s", link[i].cur, link[i].data, "-1");
        }

    }
    //上面处理的是经历过反转的内容，若n%k!=0，则还有部分元素因为不到k没有经历反转，按原顺序输出
    n %= k;
    i = 0;
    while (n--)
    {
        printf("%s %d %s", link[p * k + i].cur, link[p * k + i].data, link[p * k + i].next);
        if(n>0)     printf("\n");
        i++;
    }
    return 0;
}

六、优化代码
其实有很多可以优化的，不过算法和数据结构我没学过，仅限于了解过一点基础知识，解这道题也是用数组模拟链表进行处理，这次的代码写的自己也有点晕。而且为了弄测试点6网上查了好多别人对测试点6的看法和代码，帮助不大。自己也去调试了很久，心态都崩了，弄出来之后无心继续研究了，以后有空再弄这个。想简化代码量、加快程序运行速度的朋友，可以网上多找几个大佬的代码，都写的很好。