天梯初级练习题目 6-51 ~ 6-57 含全部测试点

已于 2023-12-27 02:34:17 修改
阅读量859 收藏 22
点赞数 26
分类专栏： 天梯初级练习题目 文章标签： 算法 c语言
于 2023-12-27 01:12:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74431187/article/details/135234225
版权

6-51 逆序数据建立链表 分数 20

本题要求实现一个函数，按输入数据的逆序建立一个链表。

函数接口定义：

struct ListNode *createlist();

函数createlist利用scanf从输入中获取一系列正整数，当读到−1时表示输入结束。按输入数据的逆序建立一个链表，并返回链表头指针。链表节点结构定义如下：

struct ListNode {
    int data;
    struct ListNode *next;
};

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *createlist();

int main()
{
    struct ListNode *p, *head = NULL;

    head = createlist();
    for ( p = head; p != NULL; p = p->next )
        printf("%d ", p->data);
    printf("\n");

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 2 3 4 5 6 7 -1

输出样例：

7 6 5 4 3 2 1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

typedef struct ListNode list;
list* createlist()
{
    list* hd = malloc(sizeof(list));
    hd->next = NULL;
    int e;
    while(scanf("%d", &e), e != -1)
    {
        list* node = malloc(sizeof(list));
        node->data = e;
        node->next = hd->next;
        hd->next = node;
    }
    return hd->next;
}

6-52 链表拼接 分数 20

本题要求实现一个合并两个有序链表的简单函数。链表结点定义如下：

struct ListNode {
    int data;
    struct ListNode *next;
};

函数接口定义：

struct ListNode *mergelists(struct ListNode *list1, struct ListNode *list2);

其中list1和list2是用户传入的两个按data升序链接的链表的头指针；函数mergelists将两个链表合并成一个按data升序链接的链表，并返回结果链表的头指针。

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *createlist(); /*裁判实现，细节不表*/
struct ListNode *mergelists(struct ListNode *list1, struct ListNode *list2);
void printlist( struct ListNode *head )
{
     struct ListNode *p = head;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    struct ListNode  *list1, *list2;

    list1 = createlist();
    list2 = createlist();
    list1 = mergelists(list1, list2);
    printlist(list1);
    
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 3 5 7 -1
2 4 6 -1

输出样例：

1 2 3 4 5 6 7

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

typedef struct ListNode list;
list* mergelists(list* list1, list* list2)
{
    list* hd = malloc(sizeof(list)); hd->next = NULL;
    
    list* node1 = list1, *node2 = list2, *node = hd;
    while(node1 && node2)
    {
        if(node1->data < node2->data) node->next = node1, node1 = node1->next;
        else node->next = node2, node2 = node2->next;
        node = node->next;
    }
    while(node1) node->next = node1, node1 = node1->next, node = node->next;
    while(node2) node->next = node2, node2 = node2->next, node = node->next;
    node->next = NULL;
    return hd->next;
}

6-53 奇数值结点链表 分数 20

本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表。链表结点定义如下：

struct ListNode {
    int data;
    ListNode *next;
};

函数接口定义：

struct ListNode *readlist(); struct ListNode *getodd( struct ListNode **L );

函数readlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点的指针。

函数getodd将单链表L中奇数值的结点分离出来，重新组成一个新的链表。返回指向新链表头结点的指针，同时将L中存储的地址改为删除了奇数值结点后的链表的头结点地址（所以要传入L的指针）。

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *readlist();
struct ListNode *getodd( struct ListNode **L );
void printlist( struct ListNode *L )
{
     struct ListNode *p = L;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    struct ListNode *L, *Odd;
    L = readlist();
    Odd = getodd(&L);
    printlist(Odd);
    printlist(L);

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 2 2 3 4 5 6 7 -1

输出样例：

1 3 5 7 
2 2 4 6

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

typedef struct ListNode list;
list* readlist()
{
    int e;
    list* hd = NULL, *tail = NULL;
    while(scanf("%d", &e), e != -1)
    {
        list* node = malloc(sizeof(list));
        node->data = e;
        if(!hd) hd = tail = node;
        else
        {
            tail->next = node;
            tail = node;
        }
    }
    return hd;
}

list* getodd(list** L)
{
    list* ans = malloc(sizeof(list)); ans->next = NULL;
    list* odd = malloc(sizeof(list)); odd->next = *L;
    
    list* hd = *L, *nd = ans;
    for(list* node = hd, *pd = odd; node; )
    {
        if(node->data % 2)
        {
            nd->next = node;
            nd = nd->next;
            
            pd->next = node->next;
            node = node->next;
        }
        else
        {
            node = node->next;
            pd = pd->next;
        }
    }
    nd->next = NULL;
    *L = odd->next;
    return ans->next;
}

6-54 单链表结点删除 分数 20

本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中所有存储了某给定值的结点删除。链表结点定义如下：

struct ListNode {
    int data;
    ListNode *next;
};

函数接口定义：

struct ListNode *readlist();
struct ListNode *deletem( struct ListNode *L, int m );

函数readlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点的指针。

函数deletem将单链表L中所有存储了m的结点删除。返回指向结果链表头结点的指针。

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *readlist();
struct ListNode *deletem( struct ListNode *L, int m );
void printlist( struct ListNode *L )
{
     struct ListNode *p = L;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    int m;
    struct ListNode *L = readlist();
    scanf("%d", &m);
    L = deletem(L, m);
    printlist(L);

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

10 11 10 12 10 -1
10

输出样例：

11 12

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

typedef struct ListNode list;
list* readlist()
{
    int e;
    list* hd = NULL, *tail = NULL;
    while(scanf("%d", &e), e != -1)
    {
        list* node = malloc(sizeof(list));
        node->data = e;
        if(!hd) hd = tail = node;
        else tail->next = node, tail = node;
    }
    return hd;
}

list* deletem(list* L, int n)
{
    list* hd = malloc(sizeof(list)); hd->next = L;
    for(list* p = hd, *node = L; node;)
    {
        if(node->data == n)
        {
            list* temp = node;
            p->next = node->next;
            node = node->next;
            free(temp);
        }
        else
        {
            node = node->next;
            p = p->next;
        }
    }
    return hd->next;
}

6-55 链表逆置 分数 20

本题要求实现一个函数，将给定单向链表逆置，即表头置为表尾，表尾置为表头。链表结点定义如下：

struct ListNode {
    int data;
    struct ListNode *next;
};

函数接口定义：

struct ListNode *reverse( struct ListNode *head );

其中head是用户传入的链表的头指针；函数reverse将链表head逆置，并返回结果链表的头指针。

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *createlist(); /*裁判实现，细节不表*/
struct ListNode *reverse( struct ListNode *head );
void printlist( struct ListNode *head )
{
     struct ListNode *p = head;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    struct ListNode  *head;

    head = createlist();
    head = reverse(head);
    printlist(head);
    
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 2 3 4 5 6 -1

输出样例：

6 5 4 3 2 1

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

typedef struct ListNode list;
list* reverse(list* hd)
{
    list* p = NULL, *node = hd;
    while(node)
    {
        list* e = node->next;
        node->next = p;
        p = node, node = e;
    }
    return p;
}

6-56 统计专业人数 分数 15

本题要求实现一个函数，统计学生学号链表中专业为计算机的学生人数。链表结点定义如下：

struct ListNode {
    char code[8];
    struct ListNode *next;
};

这里学生的学号共7位数字，其中第2、3位是专业编号。计算机专业的编号为02。

函数接口定义：

int countcs( struct ListNode *head );

其中head是用户传入的学生学号链表的头指针；函数countcs统计并返回head链表中专业为计算机的学生人数。

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct ListNode {
    char code[8];
    struct ListNode *next;
};

struct ListNode *createlist(); /*裁判实现，细节不表*/
int countcs( struct ListNode *head );

int main()
{
    struct ListNode  *head;

    head = createlist();
    printf("%d\n", countcs(head));
    
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1021202
2022310
8102134
1030912
3110203
4021205
#

输出样例：

3

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

typedef struct ListNode list;
int countcs(list* head)
{
    int cnt = 0;
    for(list* node = head; node; node = node->next)
        if(node->code[1] == '0' && node->code[2] == '2') cnt ++;
    return cnt;
}

6-57 删除单链表偶数节点 分数 20

本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中偶数值的结点删除。链表结点定义如下：

struct ListNode {
    int data;
    struct ListNode *next;
};

函数接口定义：

struct ListNode *createlist();
struct ListNode *deleteeven( struct ListNode *head );

函数createlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点的指针。

函数deleteeven将单链表head中偶数值的结点删除，返回结果链表的头指针。

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *createlist();
struct ListNode *deleteeven( struct ListNode *head );
void printlist( struct ListNode *head )
{
     struct ListNode *p = head;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    struct ListNode *head;

    head = createlist();
    head = deleteeven(head);
    printlist(head);

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

1 2 2 3 4 5 6 7 -1

输出样例：

1 3 5 7

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

typedef struct ListNode list;
list* createlist()
{
    int e;
    list* hd = NULL, *tail = NULL;
    while(scanf("%d", &e), e != -1)
    {
        list* node = malloc(sizeof(list));
        node->data = e;
        if(!hd) hd = tail = node;
        else tail->next = node, tail = node;
    }
    return hd;
}

list* deleteeven(list* hd)
{
    list* ans = malloc(sizeof(list)); ans->next = hd;

    for(list* p = ans, *node = hd; node;)
        if(node->data % 2 == 0)
        {
            list* temp = node;
            p->next = node->next;
            node = node->next;
            free(temp);
        }
        else node = node->next, p = p->next;
    return ans->next;
}

我辈其实蓬蒿人
关注
  • 26
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
天梯赛编程练习GPLT-2022-exercises-main.zip
04-21
"天梯赛编程练习GPLT-2022-exercises-main.zip" 是一个包含编程练习的压缩文件，可能源自某次编程竞赛或训练活动。这个压缩包的核心是帮助参赛者或者学习者提升他们的编程技能，特别是针对“天梯赛”这种形式的竞赛...
2024年备战天梯赛刷题练习practice-master.zip
04-21
2024年备战天梯赛刷题练习practice-master.zip
天梯初级练习题目 6-41 ~ 6-50 含全部测试点
m0_74431187的博客
12-27 948
天梯初级练习题目
天梯初级练习题目 6-11 ~ 6-20 含全部测试点
m0_74431187的博客
12-27 972
天体初级练习题目
天梯初级练习题目 6-31 ~ 6-40 含全部测试点
m0_74431187的博客
12-27 928
天梯初级练习题目
天梯初级练习题目 7-61 ~ 7-70 含全部测试点
m0_74431187的博客
12-27 978
天梯初级练习题目
天梯初级练习题目 7-1 ~ 7-10 含全部测试点
m0_74431187的博客
12-27 770
天梯初级练习题目
天梯初级练习题目 7-11 ~ 7-20 含全部测试点
m0_74431187的博客
12-27 800
天梯初级练习题目
PTA 天梯赛练习题集 L2-003 月饼 测试点2，测试点3分析
qascetic的博客
07-04 1113
月饼是中国人在中秋佳节时吃的一种传统食品，不同地区有许多不同风味的月饼。现给定所有种类月饼的库存量、总售价、以及市场的最大需求量，请你计算可以获得的最大收益是多少。注意：销售时允许取出一部分库存。样例给出的情形是这样的：假如我们有 3 种月饼，其库存量分别为 18、15、10 万吨，总售价分别为 75、72、45 亿元。如果市场的最大需求量只有 20 万吨，那么我们最大收益策略应该是卖出全部 15 万吨第 2 种月饼、以及 5 万吨第 3 种月饼，获得 72 + 45/2 = 94.5（亿元）。输入格式：
计算机天梯赛pat练习集L1-(1~30题)
晨的博客
04-13 1593
文章目录：1、hello word2、打印沙漏3、个位数统计4、计算摄氏温度5、考试座位号6、连续因子7、念数字8、求整数段和9、N个数求和10、比较大小11、A-B12、计算指数13、计算阶乘和14、简单题15、和奥巴马一起画方块16、查验身份证17、到底有多二18、大笨钟19、谁先倒20、帅到没朋友21、重要的事情说三遍22、奇偶分家23、输出GPLT24、后天25、正整数A+B26、I LOVE GPLT27、出租28、判断素数29、是不是太胖了30、一帮一 1、hello word #include
团体程序设计天梯赛-练习集L1-011~L1-020
张小艾博客
04-12 1798
一个整数“犯二的程度”定义为该数字中包含2的个数与其位数的比值。如果这个数是负数，则程度增加0.5倍；如果还是个偶数，则再增加1倍。例如数字“-13142223336”是个11位数，其中有3个2，并且是负数，也是偶数，则它的犯二程度计算为：3/11*1.5*2*100%，约为81.82%。本题就请你计算一个给定整数到底有多二。 输入格式： 输入第一行给出一个不超过50位的整数N。 输出格式：...
小学语文1-6年级课文比喻句归纳整理.pdf
03-31
【比喻句知识点】 比喻句是小学语文学习中的一个重要概念，它是通过将两个不同的事物进行类比，以形象生动地表达作者的思想和情感。以下是对小学1-6年级课文比喻句的归纳整理及其相关知识点的详细解释： 1. **...
团体程序设计天梯赛-练习集 （L1-013 - L1-024
04-02
天梯赛题解合集 [团体程序设计天梯赛-练习集 （L1-013 - L1-024）](https://blog.csdn.net/weixin_45741872/article/details/137237660) [团体程序设计天梯赛-练习集 （L1-025 - L1-036）]...
PTA团体程序设计天梯赛-练习集.zip
04-21
"PTA团体程序设计天梯赛-练习集.zip" 是一个专门为编程爱好者和学习者准备的资源包，其中包含了丰富的编程题目和练习，旨在提升参与者的编程能力，特别是在团队合作和算法设计方面。"天梯赛"通常指的是一个逐步升级...
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 444
算法014：找到字符串中所有字母异位词
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 212
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
代码随想录算法训练营第三十二天
weixin_44791877的博客
07-14 227
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
树与二叉树
最新发布
2201_76027754的博客
07-15 770
树和二叉树
摩尔投票算法
qq_55846232的博客
07-14 471
摩尔投票算法的介绍以及相关例题的讲解

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值