BUPT2018级计算机院OJ习题与个人解答[链表一 ][附加测试样例]

最新推荐文章于 2024-04-15 20:29:18 发布

Fantomeo

最新推荐文章于 2024-04-15 20:29:18 发布

阅读量2k

点赞数 3

分类专栏： C OJ 文章标签： C BUPT OJ SCS

本文链接：https://blog.csdn.net/weixin_43270122/article/details/88702952

版权

C 同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

1 篇文章 0 订阅

订阅专栏

Name: The Answer Of OJ Of BUPT SCS[LinkList 1][附加测试样例]

Author: Chengmin Zhang

Date: 2019-03-21 WED

Title: 链表一

测试样例下载（点击下方蓝字）

OJ测试样例下载

Questions List:

A.实验11_4_初识链表
B.实验11_10_链表排序
C.实验11_11_链表匹配
D.实验11_13_链表交换

A.实验11_4_初识链表

运行时间限制: 1000 运行内存限制: 65536
参考答案运行时间: 5 参考答案运行内存: 796

题目描述:

已知一个正整数序列，个数未知，但至少有一个元素，你的任务是建立一个单链表,并使用该链表存储这个正整数序列，然后统计这个序列中元素的最大值与最小值，
计算序列全部元素之和。正整数的输入用 -1作为结束标志，注意-1不算这个正整数序列中的元素（不要统计 -1）。

输入与输出要求:

输入一个正整数序列，正整数序列元素的个数未知，但以输入“-1”结束，输入“-1”前至少输入一个正整数。
序列中的元素范围在1—999999999之间。输出三个正整数，即最大值、最小值、所有元素之和。
数据最多的测试用例节点数在1000这个数量级，所有整数可以用int型存储。请注意输入输出格式。

输入样例

1 4 99 21 50 61 32 4 -1

输出样例

The maximum,minmum and the total are:99 1 272

参考代码

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

// 1 Define the Node struct (the Body of the LinkList)
typedef struct Node {
    int number;
    struct Node *next;
} Node;

// 2 Define the LinkList struct (the Head of the LinkList)
// Including the headPtr and the length of linkList
typedef struct LinkList {
    struct Node *next;
    int length;
} LinkList;

// 3 InitTheLinkList
// FunctionName: InitTheLinkList
// ParameterList: LinkList *linkList
// ReturnValue: void
void InitTheLinkList(LinkList *linkList) {
    linkList->length = 0;
    Node *headNode = (Node *)malloc(sizeof(Node));
    linkList->next = headNode;
    headNode->number = 0;
    headNode->next = NULL;
}

// 4 Input Array Thourgh scanf(!!USING THE Iterative Method!!)
// FunctionName: InputLinkListByScanf
// ParameterList: LinkList *linkList, Node *lastNode
// ReturnValue: Node *newlastNode (if input equals -1 then return NULL)
// Explaination: The number input will be set in the end of linkList
Node *InputLinkListByScanf(LinkList *linkList, Node *lastNode) {
    Node *newlastNode = (Node *)malloc(sizeof(Node));
    newlastNode->next = NULL;
    scanf("%d", &newlastNode->number);
    if (newlastNode->number == -1) {
        return NULL;
    } else {
        lastNode->next = newlastNode;
        linkList->length += 1;
        InputLinkListByScanf(linkList, newlastNode);
    }
}

// 5 Print the LinkList
// FunctionName: PrintLinkList
// ParameterList: LinkList *linkList
// ReturnValue: void
void PrintLinkList(LinkList *linkList) {
    Node *node = linkList->next;
    node = node->next;
    if (node == NULL) {
        printf("The linkList is empty!\n");
        linkList->length = 0;
        return;
    }
    for (int i = 0; i < linkList->length; i++) {
        printf("%d ", node->number);
        node = node->next;
    }
}

// 6 Return the MAX MIN SUM of LinkList
// FunctionName: TheMAXMINSUMofLinkList
// ParameterList: LinkList *linkList
// ReturnValue: int *array
int *TheMAXMINSUMofLinkList(LinkList *linkList) {
    int *theReturnArray = (int *)malloc(sizeof(int) * 3);
    for (int i = 0; i < 3; i++)
        theReturnArray[i] = 0;
    Node *node = linkList->next;
    node = node->next;
    if (node == NULL) {
        printf("The linkList is empty!\n");
        linkList->length = 0;
        return theReturnArray;
    }
    theReturnArray[1] = node->number;
    for (int i = 0; i < linkList->length; i++) {
        if (node->number > theReturnArray[0]) {
            theReturnArray[0] = node->number;
        }
        if (node->number < theReturnArray[1]) {
            theReturnArray[1] = node->number;
        }
        theReturnArray[2] += node->number;
        node = node->next;
    }
    return theReturnArray;
}

// 7 Clear the LinkList
// FunctionName: ClearLinkList
// ParameterList: LinkList *linkList
// ReturnValue: void
void ClearLinkList(LinkList *linkList) {
    Node *node = linkList->next;
    node = node->next;
    Node *nextNode;
    while (node) {
        nextNode = node->next;
        free(node);
        node = nextNode;
    }
    free(linkList->next);
}

// 0 int main
int main() {
    LinkList linkList;
    InitTheLinkList(&linkList);
    InputLinkListByScanf(&linkList, linkList.next);
    // PrintLinkList(&linkList);
    int *theReturn = TheMAXMINSUMofLinkList(&linkList);
    printf("The maximum,minmum and the total are:%d %d %d\n", theReturn[0],
           theReturn[1], theReturn[2]);
    ClearLinkList(&linkList);
    return 0;
}

B.实验11_10_链表排序

题目描述运行时间限制: 1000 运行内存限制: 65536
参考答案运行时间: 6 参考答案运行内存: 792

问题描述：

问题描述：已知一个正整数组成的无序序列，个数未知，但至少有一个元素，你的任务是建立一个单链表，并使用该链表存储这个正整数序列，然后将这个链表进行排序，使得排序后的链表为递增序列。
正整数的输入用-1作为结束标志，注意-1不算这个正整数序列中的元素（不要统计-1）。
在排序的过程中，你可以自己选择排序算法（冒泡排序、选择排序等），但必须是通过修改结点的指针域来进行排序，而不是对结点的数据域进行修改。程序结束后要释放所有节点占据的空间。

输入与输出要求：

输入一个元素个数未知的正整数序列，以输入“-1”结束，输入“-1”前至少输入一个正整数。输出经过排序后的链表，每个元素后有一个空格，注意最后一个元素后只有换行符。
数据最多的测试用例节点数在1000这个数量级，所有整数可以用int型存储。请注意输入输出格式。

输入样例

49 38 65 97 76 13 27 49 -1

输出样例

The new list is:13 27 38 49 49 65 76 97

参考代码

#include <stdio.h>
#include <stdlib.h>
// 1 Define the Node struct (the Body of the LinkList)
typedef struct Node {
    int number;
    struct Node *next;
} Node;

// 2 Define the LinkList struct (the Head of the LinkList)
// Including the headPtr and the length of linkList
typedef struct LinkList {
    struct Node *next;
    int length;
} LinkList;

// 3 InitTheLinkList
// FunctionName: InitTheLinkList
// ParameterList: LinkList *linkList
// ReturnValue: void
void InitTheLinkList(LinkList *linkList) {
    linkList->length = 0;
    Node *headNode = (Node *)malloc(sizeof(Node));
    linkList->next = headNode;
    headNode->number = 0;
    headNode->next = NULL;
}

// 4 Input Array Thourgh scanf(!!USING THE Iterative Method!!)
// FunctionName: InputLinkListByScanf
// ParameterList: LinkList *linkList, Node *lastNode
// ReturnValue: Node *newlastNode (if input equals -1 then return NULL)
// Explaination: The number input will be set in the end of linkList
Node *InputLinkListByScanf(LinkList *linkList, Node *lastNode) {
    Node *newlastNode = (Node *)malloc(sizeof(Node));
    newlastNode->next = NULL;
    scanf("%d", &newlastNode->number);
    if (newlastNode->number == -1) {
        return NULL;
    } else {
        lastNode->next = newlastNode;
        linkList->length += 1;
        InputLinkListByScanf(linkList, newlastNode);
    }
}

// 5 Print the LinkList
// FunctionName: PrintLinkList
// ParameterList: LinkList *linkList
// ReturnValue: void
void PrintLinkList(LinkList *linkList) {
    Node *node = linkList->next;
    node = node->next;
    if (node == NULL) {
        printf("The linkList is empty!\n");
        linkList->length = 0;
        return;
    }
    for (int i = 0; i < linkList->length; i++) {
        printf("%d ", node->number);
        node = node->next;
    }
    putchar('\n');
}

// 6 Sort The Linklist with Bubble Sort
// FunctionName: SortLinklist
// ParameterList: LinkList *linkList
// ReturnValue: void
void SortLinklist(LinkList *linkList, Node *theFrontOfStartNode, int *sortTime,
                  int *turns) {
    if (*sortTime > linkList->length - *turns - 1) {
        return;
    }
    Node *currentNode1 = theFrontOfStartNode->next;
    Node *currentNode2 = currentNode1->next;
    if (currentNode1->number > currentNode2->number) {
        currentNode1->next = currentNode2->next;
        currentNode2->next = currentNode1;
        theFrontOfStartNode->next = currentNode2;
    }
    *sortTime += 1;
    SortLinklist(linkList, theFrontOfStartNode->next, sortTime, turns);
}

// 7 Clear the LinkList
// FunctionName: ClearLinkList
// ParameterList: LinkList *linkList
// ReturnValue: void
void ClearLinkList(LinkList *linkList) {
    Node *node = linkList->next;
    node = node->next;
    Node *nextNode;
    while (node) {
        nextNode = node->next;
        free(node);
        node = nextNode;
    }
    free(linkList->next);
}

// 0 int main
int main() {
    LinkList linkList;
    InitTheLinkList(&linkList);
    InputLinkListByScanf(&linkList, linkList.next);
    for (int i = 0; i < linkList.length; i++) {
        int j = 1;
        SortLinklist(&linkList, linkList.next, &j, &i);
    }
    printf("The new list is:");
    PrintLinkList(&linkList);
    ClearLinkList(&linkList);
    return 0;
}

C.实验11_11_链表匹配

运行时间限制: 1000 运行内存限制: 65536
参考答案运行时间: 5 参考答案运行内存: 796

题目描述：

问题描述：已知两个由正整数组成的无序序列A、B，每个序列的元素个数未知，但至少有一个元素。你的任务是判断序列B是否是序列A的连续子序列。假设B是“1
9 2 4 18”，A是“33 64 1 9 2 4 18 7”，B是A的连续子序列；假设B是“1 9 2 4 18”，A是“33 1 9
64 2 4 18 7”，B不是A的连续子序列。

要求：

建立两个单链表A、B用于存储两个正整数序列，然后按照题目的要求，判断链表B是否是链表A的连续子序列。正整数的输入用-1作为结束标志，注意-1不算这个正整数序列中的元素（不要统计-1）。在程序结束前要释放链表A、B中的所有节点。

输入与输出要求：

依次输入两个乱序的正整数序列A、B，序列中元素个数未知，但每个序列至少有一个元素，并以输入“-1”结束，每个序列占一行。如果序列B是序列A的连续子序列，则输出“ListB is the sub sequence of ListA.”，否则输出“ListB is not the sub sequence of ListA.”。数据最多的测试用例节点数在100这个数量级，所有整数可以用int型存储。请注意输入输出格式。

输入样例

Sample 1:
5 4 3 2 1 -1
3 2 1 -1
Sample 2:
1 2 3 4 5 6 7 8 9 -1
1 2 3 4 5 6 7 8 0 -1

输出样例

Sample 1: ListB is the sub sequence of ListA.
Sample 2: ListB is not the sub sequence of ListA.

参考代码

#include <stdio.h>
#include <stdlib.h>
// 1 Define the Node struct (the Body of the LinkList)
typedef struct Node {
    int number;
    struct Node *next;
} Node;

// 2 Define the LinkList struct (the Head of the LinkList)
// Including the headPtr and the length of linkList
typedef struct LinkList {
    struct Node *next;
    int length;
} LinkList;

// 3 InitTheLinkList
// FunctionName: InitTheLinkList
// ParameterList: LinkList *linkList
// ReturnValue: void
void InitTheLinkList(LinkList *linkList) {
    linkList->length = 0;
    Node *headNode = (Node *)malloc(sizeof(Node));
    linkList->next = headNode;
    headNode->number = 0;
    headNode->next = NULL;
}

// 4 Input Array Thourgh scanf(!!USING THE Iterative Method!!)
// FunctionName: InputLinkListByScanf
// ParameterList: LinkList *linkList, Node *lastNode
// ReturnValue: Node *newlastNode (if input equals -1 then return NULL)
// Explaination: The number input will be set in the end of linkList
Node *InputLinkListByScanf(LinkList *linkList, Node *lastNode) {
    Node *newlastNode = (Node *)malloc(sizeof(Node));
    newlastNode->next = NULL;
    scanf("%d", &newlastNode->number);
    if (newlastNode->number == -1) {
        return NULL;
    } else {
        lastNode->next = newlastNode;
        linkList->length += 1;
        InputLinkListByScanf(linkList, newlastNode);
    }
}

// 5 Print the LinkList
// FunctionName: PrintLinkList
// ParameterList: LinkList *linkList
// ReturnValue: void
void PrintLinkList(LinkList *linkList) {
    Node *node = linkList->next;
    node = node->next;
    if (node == NULL) {
        printf("The linkList is empty!\n");
        linkList->length = 0;
        return;
    }
    for (int i = 0; i < linkList->length; i++) {
        printf("%d ", node->number);
        node = node->next;
    }
    putchar('\n');
}

// 6 LinkList Matching
// FunctionName: LinkListMatching
// ParameterList: LinkList *linkList1, LinkList *linkList2
// ReturnValue: int (1||0)
int LinkListMatching(LinkList *linkList1, LinkList *linkList2) {
    if (linkList1->length < linkList2->length) {
        return 0;
    }
    Node *standNodeOfL1 = linkList1->next->next;
    for (int i = 0; i < linkList1->length - linkList2->length + 1; i++) {
        Node *currentNodeOfL2 = linkList2->next->next;
        Node *currentNodeOfL1 = standNodeOfL1;
        for (int j = 0; j < linkList2->length; j++) {
            if (currentNodeOfL2->number != currentNodeOfL1->number) {
                break;
            } else {
                currentNodeOfL2 = currentNodeOfL2->next;
                currentNodeOfL1 = currentNodeOfL1->next;
            }
        }
        if (currentNodeOfL2 == NULL) {
            return 1;
        } else {
            standNodeOfL1 = standNodeOfL1->next;
        }
    }
    return 0;
}

// 7 Clear the LinkList
// FunctionName: ClearLinkList
// ParameterList: LinkList *linkList
// ReturnValue: void
void ClearLinkList(LinkList *linkList) {
    Node *node = linkList->next;
    node = node->next;
    Node *nextNode;
    while (node) {
        nextNode = node->next;
        free(node);
        node = nextNode;
    }
    free(linkList->next);
}

// 0 int main
int main() {
    LinkList linkList1, linkList2;
    InitTheLinkList(&linkList1);
    InitTheLinkList(&linkList2);
    InputLinkListByScanf(&linkList1, linkList1.next);
    InputLinkListByScanf(&linkList2, linkList2.next);
    LinkListMatching(&linkList1, &linkList2) == 1
        ? printf("ListB is the sub sequence of ListA.\n")
        : printf("ListB is not the sub sequence of ListA.\n");
    ClearLinkList(&linkList1);
    ClearLinkList(&linkList2);
    return 0;
}

D.实验11_13_链表交换

题目描述运行时间限制: 1000 运行内存限制: 65536
参考答案运行时间: 4 参考答案运行内存: 740

问题描述：

问题描述：问题描述：已知一个正整数序列，序列元素个数未知，但至少有两个元素，你的任务是建立一个单链表用于存储这个正整数序列。然后实现交换此链表中任意指定的两段，第一段为[s1,t1]，第二段[s2,t2]。s1、t1、s2、t2代表链表的第几个节点，且满足s1<=t1，s2<=t2，t1<s2，s2一定小于等于链表节点的总个数。正整数的输入用-1作为结束标志，注意-1不算这个正整数序列中的元素（不要统计-1）。最后将链表的全部节点释放。

输入与输出要求：

输入一个正整数序列，以输入“-1”结束，序列中元素个数未知，但输入“-1”前至少输入两个正整数。然后是四个整数，即为s1、t1、s2、t2。输出经过处理后的新链表，每个元素后有一个空格，注意最后一个元素后只有换行符。数据最多的测试用例节点数在100这个数量级，所有整数可以用int型存储。请注意输入输出格式。

输入样例

1 2 3 4 5 6 7 8 9 10 -1
1 1 4 7

输出样例

The new list is:4 5 6 7 2 3 1 8 9 10

参考代码

#include <stdio.h>
#include <stdlib.h>
// 1 Define the Node struct (the Body of the LinkList)
typedef struct Node {
    int number;
    struct Node *next;
} Node;

// 2 Define the LinkList struct (the Head of the LinkList)
// Including the headPtr and the length of linkList
typedef struct LinkList {
    struct Node *next;
    int length;
} LinkList;

// 3 InitTheLinkList
// FunctionName: InitTheLinkList
// ParameterList: LinkList *linkList
// ReturnValue: void
void InitTheLinkList(LinkList *linkList) {
    linkList->length = 0;
    Node *headNode = (Node *)malloc(sizeof(Node));
    linkList->next = headNode;
    headNode->number = 0;
    headNode->next = NULL;
}

// 4 Input Array Thourgh scanf(!!USING THE Iterative Method!!)
// FunctionName: InputLinkListByScanf
// ParameterList: LinkList *linkList, Node *lastNode
// ReturnValue: Node *newlastNode (if input equals -1 then return NULL)
// Explaination: The number input will be set in the end of linkList
Node *InputLinkListByScanf(LinkList *linkList, Node *lastNode) {
    Node *newlastNode = (Node *)malloc(sizeof(Node));
    newlastNode->next = NULL;
    scanf("%d", &newlastNode->number);
    if (newlastNode->number == -1) {
        return NULL;
    } else {
        lastNode->next = newlastNode;
        linkList->length += 1;
        InputLinkListByScanf(linkList, newlastNode);
    }
}

// 5 Print the LinkList
// FunctionName: PrintLinkList
// ParameterList: LinkList *linkList
// ReturnValue: void
void PrintLinkList(LinkList *linkList) {
    Node *node = linkList->next;
    node = node->next;
    if (node == NULL) {
        printf("The linkList is empty!\n");
        linkList->length = 0;
        return;
    }
    for (int i = 0; i < linkList->length; i++) {
        printf("%d ", node->number);
        node = node->next;
    }
    putchar('\n');
}

// 6 Exchange the part of the LinkList
// FunctionName: ExchangePartOfLinkList
// ParameterList: LinkList *linkList
// ReturnValue: void
void ExchangePartOfLinkList(LinkList *linkList) {
    int range[4];
    scanf("%d%d%d%d", &range[0], &range[1], &range[2], &range[3]);
    Node *node[4];
    int j = 0;
    Node *currentNode = linkList->next;
    for (int i = 0; i < range[3] + 1; i++) {
        if (i == range[0] - 1 || i == range[1] || i == range[3]) {
            node[j] = currentNode;
            j += 1;
        }
        currentNode = currentNode->next;
    }
    currentNode = node[1];
    for (int i = 0; i < range[2] - range[1] - 1; i++) {
        currentNode = currentNode->next;
    }
    node[3] = currentNode;
    Node *savedNode = node[0]->next;
    node[0]->next = node[3]->next;
    node[3]->next = savedNode;
    savedNode = node[2]->next;
    node[2]->next = node[1]->next;
    node[1]->next = savedNode;
}

// 7 Clear the LinkList
// FunctionName: ClearLinkList
// ParameterList: LinkList *linkList
// ReturnValue: void
void ClearLinkList(LinkList *linkList) {
    Node *node = linkList->next;
    node = node->next;
    Node *nextNode;
    while (node) {
        nextNode = node->next;
        free(node);
        node = nextNode;
    }
    free(linkList->next);
}

// 0 int main
int main() {
    LinkList linkList1;
    InitTheLinkList(&linkList1);
    InputLinkListByScanf(&linkList1, linkList1.next);
    ExchangePartOfLinkList(&linkList1);
    printf("The new list is:");
    PrintLinkList(&linkList1);
    ClearLinkList(&linkList1);
    return 0;
}

Fantomeo

关注

3
点赞
踩
9

收藏

觉得还不错? 一键收藏
1
评论
BUPT2018级计算机院OJ习题与个人解答[链表一 ][附加测试样例]

Name: The Answer Of OJ Of BUPT SCSAuthor: Chengmin ZhangDate: 2019-03-21 WEDTitle: 链表一Questions List:A.实验11_4_初识链表B.实验11_10_链表排序C.实验11_11_链表匹配D.实验11_13_链表交换A.实验11_4_初识链表运行时间限制: 1000 运行内存限制...
复制链接

扫一扫