PAT之静态链表

已于 2023-10-27 17:59:23 修改
阅读量356 收藏 1
点赞数 1
分类专栏： # PAT甲级（C++） 文章标签： PAT 链表
于 2020-07-26 23:13:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vuscity/article/details/106402837
版权

文章目录

模板

（1）典型示例

输入：
（The address of a node is a 5-digit nonnegative integer, and NULL is represented by −1.）

  • the first line ：
    the address of the first node, and a positive N (≤ 1 0 5 10^5 105​​ ) which is the total number of nodes.
  • N lines：
    Address Key Next
00100 5		
99999 -7 87654
23854 -15 00000
87654 15 -1
00000 -15 99999
00100 21 23854

即，00100 -> 23854 -> 00000 -> 99999 -> 87654 -> -1

（2）代码模板

#include<cstdio>

using namespace std;

const int N = 100000+10;    // 10^5

typedef struct{
    int adress;
    int data;
    int next;
    bool flag;      //是否是链表上的结点 （其它结点 = false）
    int order;      // 链表中结点的序号【从0开始】（其它结点 = N）
    /*  ... ...    */

}Node;

Node nodes[N];
int real_n=0;  //真正链表中的结点个数

int main(){
    // 初始化
    for(int i=0; i<N; i++){
        nodes[i].order = N;
    }
    // 输入
    int f_ad, n;
    scanf("%d%d", &f_ad, &n);
    int ad, data, next;
    for(int i=0; i<n; i++){
        scanf("%d%d%d", &ad, &data , &next);
        nodes[ad] = {ad, data, next};
    }
    // 设置flag order
    for(int i=f_ad; i!=-1; i=nodes[i].next){
        nodes[i].flag = true;
        nodes[i].order = real_n;
        real_n++;
    }
 	/*  ... ...    */
	// 输出
	printf("%05d %d %05d", nodes[i].adress, nodes[i].data， nodes[i].next);
    return 0;
}

1032（25：两个链表求公共结点）

（1）题目
两个链表求公共结点

代码：

#include<cstdio>

using namespace std;

const int N = 100000+10;

struct Node{
    char data;
    int next;
    bool flag;      // 是否是第一个链表中的元素
}nodes[N];

int main(){
    int ad1, ad2, n;
    scanf("%d %d %d", &ad1, &ad2, &n);
    int ad, next;
    char data;
    for(int i=0; i<n; i++){
        scanf("%d %c %d", &ad, &data, &next);
        nodes[ad] = {data, next, false};
    }
    // 遍历第一个链表
    for(int i=ad1; i!=-1; i=nodes[i].next){
        nodes[i].flag = true;
    }
    // 遍历第二个链表
    for(int i=ad2; i!=-1; i=nodes[i].next){
        if(nodes[i].flag){
            printf("%05d", i);
            return 0;
        }
    }
    printf("-1");
    return 0;
}

（3）小结

  • 全局变量的默认值
    int /int * /char /bool /double 默认值均是0
    char* /string 默认值为空（长度=0），char[i] 默认值是0
  • 链表结点：flag标志 很关键
  • struct 用{}赋值（struct没有构造函数）
    node[ad].data = data; node[ad].next = next; node[ad].flag = false;
    相当于
    nodes[ad] = {data, next, false};
  • 如何遍历一个链表
    for(int i=ad1; i!=-1; i=nodes[i].next){...}
  • 输出
    return 0 提前结束；
    最后输出 一般没有\n；

1052（25：链表排序）

（1）题目
链表排序

（2）代码

#include<cstdio>
#include<algorithm>

using namespace std;

const int N = 100000+10;

struct Node{
    int adress;
    int data;
    int next;
    bool flag;  //是否是链表的结点
}nodes[N];


// 前：flag=true, data小
bool cmp(Node no1, Node no2){
    if(no1.flag == no2.flag){
        return no1.data < no2.data;
    }else{
        return no1.flag > no2.flag;
    }
}

int main(){
    int ad, n;
    scanf("%d%d", &n, &ad);
    int ad2, data2, next2;
    for(int i=0; i<n; i++){
        scanf("%d%d%d", &ad2, &data2 , &next2);
        nodes[ad2] = {ad2, data2, next2, false};        // 所输入的结点不一定在链表中
    }
    int real_n = 0;     //真正链表中的结点个数
    // 遍历
    for(int i=ad; i!=-1; i=nodes[i].next){
        nodes[i].flag = true;
        real_n++;
    }
    // sort
    if(!real_n){
        printf("0 -1");
    }else{
        sort(nodes, nodes+N, cmp);
        printf("%d %05d\n", real_n, nodes[0].adress );		//不再是输入的ad
        for(int i=0; i<real_n; i++){
            printf("%05d %d ", nodes[i].adress, nodes[i].data);
            if(i!=real_n-1){
                printf("%05d\n", nodes[i+1].adress);
            }else{
                printf("-1");
            }
        }
    }

    return 0;
}

（3）小结

  • 审题：
    输入：where N is the total number of nodes in memory
    输出： where N is the total number of nodes in the list
  • 链表结点：
    flag 必有，因为（所输入的结点不一定在链表中， flag 和 real_n才是真的）
    初始化：flag=false
    从队头遍历：flag=true
  • 链表排序
    链表结点：增加adress（不再以nodes[i]的下标为地址）
    先按 flag 排（flag=true在前）， 再按 data 排（data小的在前）
    最后输出前n个结点
  • 边界： n=0

1074（25：链表反转（间隔k ））

（1）题目

链表反转（间隔k ）

（2）代码

#include<cstdio>
#include<algorithm>

using namespace std;

const int N = 100000+10;

struct Node{
    int adress;
    int data;
    int next;
    bool flag;  //是否是链表的结点
    int order;   // 链表中结点的序号
}nodes[N];

// 前：flag=true, order小
bool cmp(Node no1, Node no2){
    if(no1.flag == no2.flag){
        return no1.order < no2.order;
    }{
        return no1.flag > no2.flag;
    }
}

void out_reverse(int start, int stop, int last){
    for(int i=stop; i>=start; i--){
        printf("%05d %d ", nodes[i].adress, nodes[i].data);
        if(i==start){
            if(last==-1){
                printf("-1");
            }else{
                printf("%05d\n", nodes[last].adress);
            }
        }else{
            printf("%05d\n", nodes[i-1].adress);
        }
    }
}

int main(){
    for(int i=0; i<N; i++){
        nodes[i].order = N;
    }
    int ad, n, k;
    scanf("%d%d%d", &ad, &n, &k);
    int ad2, data2, next2;
    for(int i=0; i<n; i++){
        scanf("%d%d%d", &ad2, &data2 , &next2);
        nodes[ad2] = {ad2, data2, next2, false};
    }
    int real_n = 0;     //真正链表中的结点个数
    // 遍历
    for(int i=ad; i!=-1; i=nodes[i].next){
        nodes[i].flag = true;
        nodes[i].order = real_n;
        real_n++;
    }
    // sort
    sort(nodes, nodes+N, cmp);
    int inter = real_n / k;
    if(real_n % k==0){
        // 正好分完
        for(int i=0; i<=inter-1; i++){
            if(i!=inter-1){
                out_reverse(i*k, i*k + k-1, (i+2)*k-1);
            }else{
                out_reverse(i*k, i*k + k-1, -1);
            }
        }
    }else{
        // 有剩下
        if(inter<1){
            for(int i=0; i<real_n; i++){
                printf("%05d %d ", nodes[i].adress, nodes[i].data);
                if(i==real_n-1){
                    printf("-1");
                }else{
                    printf("%05d\n", nodes[i+1].adress);
                }
            }
        }else{
            for(int i=0; i<=inter-1; i++){
                if(i!=inter-1){
                    out_reverse(i*k, i*k + k-1, (i+2)*k-1);
                }else{
                    out_reverse(i*k, i*k + k-1, (i+1)*k);
                }
            }
            for(int i=(inter-1)*k+k; i<real_n; i++){
                printf("%05d %d ", nodes[i].adress, nodes[i].data);
                if(i==real_n-1){
                    printf("-1");
                }else{
                    printf("%05d\n", nodes[i+1].adress);
                }
            }
        }
    }

    return 0;
}

（3）小结

  • 链表结点
    只要之后打乱结点，就要增加adress成员（如之后sort）
    与结点在链表中的序号有关，就要增加order成员
  • 测评：答案部分正确
    情况1：边界
    情况2：改写测试用例，测试各种情况的枝节

1097（25：删除链表上的重复数据）【非满分】

（1）题目

1097 删除链表上的重复数据

（2）代码

#include<cstdio>
#include<algorithm>

using namespace std;

const int N = 100000+10;

struct Node{
    int adress;
    int data;
    int next;
    int order;      //序号
    int keep;  //=0：在链表中，保留，=1：在链表中，移除，=N,不在链表中
}nodes[N];

int abso[N];  //绝对值=i, abso[i]=1，链表中已有

// 前：keep小,order小
bool cmp(Node no1, Node no2){
    if(no1.keep==no2.keep){
        return no1.order < no2.order;
    }else{
        return no1.keep < no2.keep;
    }
}

int main(){
    for(int i=0; i<N; i++){
        nodes[i].keep = N;
        nodes[i].order = N;
    }
    int ad, n;
    scanf("%d%d", &ad, &n);
    int ad2, data2, next2;
    for(int i=0; i<n; i++){
        scanf("%d%d%d", &ad2, &data2 , &next2);
        nodes[ad2] = {ad2, data2, next2};
    }
    int real_n = 0;     //真正链表中的结点个数
    // 遍历
    for(int i=ad; i!=-1; i=nodes[i].next){
        nodes[i].order = real_n;
        if(abso[abs(nodes[i].data)]==1){
            nodes[i].keep = 1;
        }else{
            abso[abs(nodes[i].data)]=1;
            nodes[i].keep = 0;
        }
        real_n++;
    }
    // remove
    sort(nodes, nodes+N, cmp);
    int remove_first=real_n;        // 第一个移除的结点序号
    for(int i=0; i<real_n; i++){
        if(nodes[i].keep==1){
            remove_first = i;
            break;
        }
    }
    for(int i=0; i<remove_first; i++){
        printf("%05d %d ", nodes[i].adress, nodes[i].data);
        if(i!=remove_first-1){
            printf("%05d\n", nodes[i+1].adress);
        }else{
            printf("-1\n");
        }
    }
    for(int i=remove_first; i<real_n; i++){
        printf("%05d %d ", nodes[i].adress, nodes[i].data);
        if(i!=real_n-1){
            printf("%05d\n", nodes[i+1].adress);
        }else{
            printf("-1\n");
        }
    }


    return 0;
}

（3） 小结

  • 静态链表的算法设计
    设计struct的成员，灵活结合sort()

1133（25：拆分链表）

（1）题目

拆分链表

（2）代码

#include<cstdio>
#include<algorithm>
#include<vector>

using namespace std;

const int N = 100000+10;    // 10^5

typedef struct{
    int adress;
    int data;
    int next;
    bool flag;      //是否是链表上的结点 （其它结点 = false）
    int order;      // 链表中结点的序号【从0开始】（其它结点 = N）
    /*  ... ...    */

}Node;

Node nodes[N];
int real_n=0;  //真正链表中的结点个数

bool cmp(Node node1, Node node2){
    return node1.order < node2.order;
}


int main(){
    // 初始化
    for(int i=0; i<N; i++){
        nodes[i].order = N;
    }
    // 输入
    int f_ad, n, k;
    scanf("%d%d%d", &f_ad, &n, &k);
    int ad, data, next;
    for(int i=0; i<n; i++){
        scanf("%d%d%d", &ad, &data , &next);
        nodes[ad] = {ad, data, next};
    }
    // 设置flag order
    for(int i=f_ad; i!=-1; i=nodes[i].next){
        nodes[i].flag = true;
        nodes[i].order = real_n;
        real_n++;
    }
 	/*  ... ...    */
    sort(nodes, nodes+N, cmp);
    vector<Node> vect;
    for(int i=0; i<real_n; i++){
        if(nodes[i].data<0){
            vect.push_back(nodes[i]);
        }
    }
    for(int i=0; i<real_n; i++){
        if(nodes[i].data>=0 && nodes[i].data<=k){
            vect.push_back(nodes[i]);
        }
    }
    for(int i=0; i<real_n; i++){
        if(nodes[i].data>k){
            vect.push_back(nodes[i]);
        }
    }
    for(int i=0; i<real_n; i++){
        if(i==real_n-1){
            vect[i].next = -1;
            printf("%05d %d %d", vect[i].adress, vect[i].data, vect[i].next);
        }else{
            vect[i].next = vect[i+1].adress;
            printf("%05d %d %05d\n", vect[i].adress, vect[i].data, vect[i].next);
        }
    }
    return 0;
}
vuscity
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PAT A 1074 B 1025（甲级 乙级）—— 静态链表的使用
CrazyOnes的博客
09-06 549
1074 Reversing Linked List（25 分） 作者: CHEN, Yue 单位: 浙江大学 时间限制: 400 ms 内存限制: 64 MB 代码长度限制: 16 KB Given a constant K and a singly linked list L, you are supposed to reverse the links of every K ele...
PAT反转链表 (25分)（静态链表）
Rex的博客
03-07 226
反转链表 (25分)（静态链表） 此处题目链接 题目： 给定一个常数 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 个结点的...
【PAT乙级】链表类题目的套路总结
Welcome_To_CJ's_Blog
03-01 308
思路 我们可以采用结构体的方法定义静态链表，但是在算法考试中，考虑到程序运行速度和代码简洁程度，我们通常使用两个数组data[]、next[]来表示当前结点存放的值和当前结点的下一个结点的地址值，当前结点的地址值作为数组下标（类似散列表映射的思想）；同时我们还需要定义一个数组list[]来根据不同要求的顺序存放的当前结点的地址值……听起来可能有点绕口。到那时这种方法确实能大大减少代码量，建议经过几次的认真揣摩和实践去掌握这种定义方式。 步骤 定义三个数组、输入三种值 int data[maxn], n
PAT Basic Level 1075 链表元素分类（静态链表）
在森林里麋了鹿
04-17 145
题目链接：点击查看 题目描述： 给定一个单链表，请编写程序将链表元素进行分类排列，使得所有负值元素都排在非负值元素的前面，而 [0, K] 区间内的元素都排在大于 K 的元素前面。但每一类内部元素的顺序是不能改变的。例如：给定链表为 18→7→-4→0→5→-6→10→11→-2，K 为 10，则输出应该为 -4→-6→-2→7→0→5→10→18→11。 输入输出格式： 每个输入包含一个测试用例。每个测试用例第 1 行给出：第 1 个结点的地址；结点总个数，即正整数N (≤10​5​​)；以及正
静态链表的应用--PAT B1025
jelly的博客
12-06 225
1025 反转链表 （25 分） 给定一个常数 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 个结点的地址、结点总个数正整数...
静态链表
iczfy585的博客
02-23 423
静态链表什么是静态链表？静态链表的应用1.结点的定义2.初始化3.链表的建立4.排序5.解题 什么是静态链表？ 大家都知道对于链表来说，构成链表的结点在内存中不是连续存放的。与之相对的是数组，数组元素在内存中是连续存放的。此外，链表的大小是可以动态改变的，而数组的大小在程序运行过程中是固定不变的。在一些程序设计题目中，结点的数目比较小，或是给出了结点的地址的话。就可以用静态链表来实现。所谓的静...
codeup|PAT A1032 Sharing（静态链表）
weixin_43340821的博客
03-20 58
Description 给定连个单词，判断两个单词相同后缀的位置。 Input 第一行start1 start2 N，其中start1第一个单词地址，start2为第二个单词地址，N为一共N个节点。 Sample Input 1: 11111 22222 9 67890 i 00002 00010 a 12345 00003 g -1 12345 D 67890 00002 n 00003 22222 B 23456 11111 L 00001 23456 e 67890 00001 o 00010 Sam
【PAT b1025】【静态链表】
lyx_2016的博客
12-15 141
Ahhhh回来啦！最近可能集中做一波题www 之前去浅尝辄止了半天别的，现在学不下去了再回来做做题TvT 在看程杰老师的《大话数据结构》以及胡凡老师的《算法笔记上级训练实战指南》，想多做点题巩固一下我相当于没有的数据结构基础。【p.s.大话数据结构真的讲的通俗易通，程杰老师是用好几个生动的例子来分布讲解一个数据结构，我之前想的是能不能把数据结构具象化、模拟化，串成一个完整的情景和故事讲出来，还是有点难quq】 这道题的题意很简单，链表节点信息是由一个五位数构成的地址、数据以及下一个节点的地址构成的。要求是给
TS协议之PAT（节目关联表）
08-03
PAT（Program Association Table，节目关联表）是TS协议中的关键组成部分，用于建立节目（频道）与节目映射表（PMT，Program Map Table）之间的关联。PAT与PMT成对出现，共同构成了TS数据解析的基础。 PAT数据结构...
pat甲级单词pat甲级单词pat甲级单词
最新发布
06-12
pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词...
实验六PAT和静态NAT组合.pdf
10-09
实验六的主题是PAT（Port Address Translation，端口地址转换）和静态NAT（Network Address Translation）的组合应用。PAT是一种网络地址转换技术，它允许多个内部网络设备共享一个公共IP地址，通过分配不同的端口号...
PAT乙级练习题_1025“反转链表”_python解题
01-20
原题 给定一个常数 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，即最后不到 ...
PAT乙级题解.pdf
04-19
PAT题解分享，超级详细
2020春季线上PAT甲级比赛经验（必看！！！）、155题目分类
vuscity的博客
07-26 7738
PAT题目分类
vuscity的博客
07-26 1891
文章目录PAT水题（27）逻辑题（13）数学问题（14）线性结构（5）静态链表（5）STL（29）string（11）vector（2）set（4）stack（1）queue（2）map（6）查找（16）hash（10）线性结构（5）排序（20）算法/技巧（16）贪心（6）动态规划（5）two pointers二分（3）树状数组（1）红黑树（1）图（17）遍历（4）图论（5）最短路径（7）拓扑排序（1）最小生成树关键路径 / 最长路径树（25）一般树（7）二叉树（6）完全二叉树（1）二叉查找树 BST（4）
PAT之树：一般树、二叉树、完全二叉树、二叉搜索树、二叉平衡树、并查集
vuscity的博客
07-13 951
文章目录模板二叉树-模板树-模板完全二叉树1110（25）代码小结 模板 二叉树-模板 输入： 9 7 8 - - - - - - 0 1 2 3 4 5 - - - - 代码： #include<cstdio> #include<string> #include<iostream> #include<queue> using namespace std; const int N=100; typedef struct Node{ int data;
PAT之水题：逻辑题、数学问题（素数、多项式、分数、大整数、进制转换）
vuscity的博客
07-26 854
文章目录1008代码1093代码 1008 代码 题目： 电梯（数组） 代码： #include<cstdio> using namespace std; const int N=110; int main(){ int a[N]; int n; scanf("%d", &n); for(int i=1; i<=n; i++){ scanf("%d", &a[i]); } int total=0;
PAT之图：遍历、最短路径dijkstra
vuscity的博客
07-26 784
系列中：所有顶点出现 且 仅1次；V1在V2的前面，则v1到V2必有路径。（1）一个或两个测试点 段错误： N小了，数组要开大点。满足条件，则删除gra[v][i]的边，visit[v]陷进，N到底为多大（最多顶点数），题目说 的是。（2）多个测试点 段错误：写的代码数组越界。最多1000条，N应该至少2000。所有顶点visit[]=1。（1）求最短路径（1条）
c++反转链表pat
05-26
以下是使用C++实现反转链表的代码，可以用于PAT等面试/编程练习。 ```c++ #include <iostream> using namespace std; struct ListNode { int val; ListNode* next; ListNode(int x) : val(x), next(NULL) {} }; ListNode* reverseList(ListNode* head) { ListNode* prev = NULL; ListNode* curr = head; while (curr != NULL) { ListNode* next = curr->next; curr->next = prev; prev = curr; curr = next; } return prev; } int main() { // 构造链表 1->2->3->4->5 ListNode* head = new ListNode(1); head->next = new ListNode(2); head->next->next = new ListNode(3); head->next->next->next = new ListNode(4); head->next->next->next->next = new ListNode(5); // 反转链表 ListNode* newHead = reverseList(head); // 输出反转后的链表 while (newHead != NULL) { cout << newHead->val << ' '; newHead = newHead->next; } cout << endl; return 0; } ``` 输出结果为： ``` 5 4 3 2 1 ``` 其中，`reverseList` 函数实现了链表的反转，使用了三个指针，分别指向当前节点、前一个节点和后一个节点。在循环中不断更新这三个指针，直到遍历完整个链表。 在 `main` 函数中，我们构造了一个链表，并调用 `reverseList` 函数将其反转，然后输出反转后的链表。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值