复旦大学信息科学学院数据结构试卷解析

一、总体概述：

1.环境变量（？）：

时间：2023-2024年春季学期

教师：徐跃东（徐老师真的亚撒西我好喜欢徐老师（小声））

课程学分：2（荣誉班是3分）

2.总体难度：

比较简单。总的来说，把课程的每个章节的PPT学明白完全搞懂就足以完成期末考试的大部分内容了。徐老师的PPT的最后部分的难度是leetcode的median难度，考试不太会达到，甚至连附加题我认为顶多算是leetcode的easy难度，所以如果未来看到这篇文章的学弟学妹们只是抱着想在这门课程中拿到好的成绩的心态的话，吃透PPT,吃透PPT,吃透PPT！如果要学明白的话这个博主就给不出什么针对性的建议了，可能靠自己刷leetcode并且把PPT课后的题目搞定会有所帮助。关于怎么学我可能在本试卷的最后会再啰嗦两句。

3.主题思想：

徐老师说过，这张卷子不可能出的太像算法的竞赛题，否则如果大家都不会的话就会导致没有办法给分。因此必须是出的比较基础考察对于整体的一个把握。从这个角度来看的话这张卷子出的很漂亮，完全达到了徐老师的预想。

4.为什么是我来做这份卷子？

我们数学科学学院有一个传统：如果前辈能够有对后辈有利的知识或者内容，那么一定会在我们自己的平台上公开。因为这样，当面对我们不会的题目的时候；当我们在深夜写不完第二天要交的作业但是脑子已经动不起来的时候；当我们在考试之前望着厚厚的一本书不知道该做什么的时候，他们是我们的指路明灯。小时候的我无数次看着那一座座伟岸的灯塔，心生向往：什么时候我也能成为这样一座灯塔呢？

当我选择了信息科学学院的数据结构，图像处理与机器视觉这两门课程的时候，我惊讶的发现，尽管这几门课已经比我的学龄都久了，他们又是这样的经典，凭什么没有真题？？我信息学院的朋友也跟我说她拼尽全力询问也没找到，这时，考前的我就下定了决心：我来做那个指路的灯塔。

5.免责声明：

这份卷子是回忆版。虽然我已经在第一时间就回忆了出来还找同学对了一下，但是仍然可能有纰漏。一些题目的具体细节可能已经磨灭，但相信博主，考点一定是对的。另外，标准答案是真的仅供参考，并且可能不全，这有一定的记忆模糊的因素在，请更多参考题目而非答案。

那么接下来，开始吧。

二、试卷：

Part1：线性表与链表：

1.（8分（似乎））给你一个升序的链表，请把其中的重复的元素去掉输出一个新的链表。给出代码如下：

typedef struct Node {
    int data;         // 数据域
    struct Node* next; // 指针域
} Node;

typedef struct array {
    int number;
    Node a[100];
}Array;

void erase_duplicate(Array& a) {

}

请补齐上面这段代码，似的输出满足下面的例子：

输入：1->2->2->3->4->5

输出：1->2->3->4->5。

解答：

void erase_duplicate(Array& a) {
    int num = a.number;
    int save = a.start->data;
    Node* p = a.start->next;
    Node* q = a.start;
    Node* temp = a.start;
    while (p!= nullptr) {
        if (p->data != save) {
            p = p->next;
            q = q->next;
        }
        else {
            temp = p->next;
            free(p);
            q->next = temp;
            p = temp;
        }
    }

}

解析：

这道题简单来说就是一个链表的去重，实际上是比较简单的送分题

Part 2：栈和队列：

2.根据下面的代码写出输出内容：

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

#define MAX 100

// 栈结构体
typedef struct {
    char items[MAX];
    int top;
} Stack;

// 初始化栈
void initStack(Stack *s) {
    s->top = -1;
}

// 检查栈是否为空
int isEmpty(Stack *s) {
    return s->top == -1;
}

// 检查栈是否已满
int isFull(Stack *s) {
    return s->top == MAX - 1;
}

// 入栈
void push(Stack *s, char c) {
    if (isFull(s)) {
        printf("Stack is full\n");
        return;
    }
    s->items[++(s->top)] = c;
}

// 出栈
char pop(Stack *s) {
    if (isEmpty(s)) {
        printf("Stack is empty\n");
        return '\0';
    }
    return s->items[(s->top)--];
}

int main() {
    Stack s;
    initStack(&s);

    char str[] = "Hello";
    int len = strlen(str);

    // 将字符串中的字符逐个压入栈中
    for (int i = 0; i < len; i++) {
        push(&s, str[i]);
    }

    // 逐个弹出栈中的字符并输出
    while (!isEmpty(&s)) {
        char c = pop(&s);
        printf("%c", c);
    }

    return 0;
}

（2）：

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

#define MAX 100

// 队列结构体
typedef struct {
    char items[MAX];
    int front;
    int rear;
} Queue;

// 初始化队列
void initQueue(Queue *q) {
    q->front = -1;
    q->rear = -1;
}

// 检查队列是否为空
int isEmpty(Queue *q) {
    return q->front == -1;
}

// 检查队列是否已满
int isFull(Queue *q) {
    return (q->rear + 1) % MAX == q->front;
}

// 入队
void enqueue(Queue *q, char c) {
    if (isFull(q)) {
        printf("Queue is full\n");
        return;
    }
    if (isEmpty(q)) {
        q->front = 0;
    }
    q->rear = (q->rear + 1) % MAX;
    q->items[q->rear] = c;
}

// 出队
char dequeue(Queue *q) {
    if (isEmpty(q)) {
        printf("Queue is empty\n");
        return '\0';
    }
    char item = q->items[q->front];
    if (q->front == q->rear) {
        q->front = -1;
        q->rear = -1;
    } else {
        q->front = (q->front + 1) % MAX;
    }
    return item;
}

int main() {
    Queue q;
    initQueue(&q);

    char str[] = "Hello";
    int len = strlen(str);

    // 将字符串中的字符逐个入队
    for (int i = 0; i < len; i++) {
        enqueue(&q, str[i]);
    }

    // 逐个出队并输出
    while (!isEmpty(&q)) {
        char c = dequeue(&q);
        printf("%c", c);
    }

    return 0;
}

题目解析：

简单来说这道题就是考虑把字符串进栈之后出栈是什么顺序，以及进队出队的顺序。主要是FIFO和FILO，所以答案很简单就是olleH和Hello。

3.一共回答四个小题（9分）：

（1）对于一个循环队列其队满指标是什么？

答案：rear->next->next = head

即对于队列来说留下一个空位置用来区别空队和满队。

（2）栈怎么插入元素？

答案：stack[top++] = data;

即考虑栈的头指针要随着插入元素上移一位。

（3）链队怎么插入元素p？

答案：rear->next = p;p->next = nullptr;

（4）ABCDABD的next数组长什么样子？

答案：{-1,0,0,0,0,1,2}

这里主要考虑的是KMP算法中的next数组，据徐老师所说本来想考nextval数组后来放弃了。

Part 3：树:

4.（1）给出这棵树的前序遍历和后序遍历，请画出这棵树是什么样子&：

前序遍历：ABHJKLIMNOCDFGE

后序遍历：KLJHMNOIBGFDECA

答案：

这道题卡了作者非常久的时间。究其原因是作者习惯性的以为这道题是二叉树而不是多叉树，所以在面对MNO这里的时候陷入了困惑。还好老师发现了很多人也陷入了困惑，喊了一句这只是说了树，才让作者搞明白了怎么做。

（2）并查集：

现在给定1，2，3，4，5，6，7，8，9，10这十个不同的节点，现在给你一张表，请画出未经历过路径压缩的树的样子：

（1-2）（2-5）（3-4）（7-3）（7-9）（2-7）（6-10）

请画出路径压缩过的树的样子：

解析：这里没有答案是因为并查集作者也没记住具体数据，但是考点就是并查集的合并，然后没有经过路径压缩后形成的树如何拼接，以及路径压缩过的树和没有经历过路径压缩的树分别都是什么样子。这里需要学生们详细了解内容，要求复习到位。

Part4：图

1.Prim方法做最小生成树：

样例：这里我拿一道PPT上的题目举例子：

写出每一次操作把哪些顶点放入了已经被连接到的集合之中，能够选取的有哪些边，选取哪个最短，可以理解为从头到尾让你人工完成PRIM算法生成最小生成树的过程，所以这里一定要搞明白算法是什么。

2.最短路径：

类似于这张PPT，按照这个格式从头到尾推一下dijkstra算法怎么完成的最短路径的推导。考试还提供一种使用BFS+Dijkstra算法进行的最短路径推导，但是由于作者本人没有完全理解老师想干啥，于是这里给出一个标准答案。

3.Bellman Ford算法：

（1）第一次计算结果：

这是一开始的图片，一次更新之后这张图是什么样子：

答案如上。

（2）：为什么BF算法只要经历V-1轮就足够了？

答案：因为对于BF算法来说，每一次都能确定一个最短路径。所以如果经历V-1轮那么除了一开始的点之外的其他点都已经确定了一条最短路径，算法就结束了

（3）怎么判断是否有负权环？

答案：如果有负权环那么在经历了V-1轮的时候就应该已经确定了最短距离，这个时候如果第V轮仍然有距离变动那么说明一定存在负权环。

Part 5：排序：

题目（1）：堆排序：怎么建立堆排序的树？时间空间复杂度是多少？

如图，首先把这棵树搭起来，时间复杂度是O(n)

题目（2）进行一次更新应该怎么做？时间复杂度是多少？

如图，从#node/2开始看有哪些元素不符合大根堆的定义，根据书上给的方式调整整棵树。时间复杂度更新是O(logn)。这块建议研究一下书上的内容。

Part 6：查找：

对于二叉搜索树：

如果删除了50整棵树是什么样子？

答案：

 要删除某一个节点P，请给出完整的代码：

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

typedef struct TreeNode {
    int key;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

// 创建新节点
TreeNode* createNode(int key) {
    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
    newNode->key = key;
    newNode->left = newNode->right = NULL;
    return newNode;
}

// 查找最小值节点
TreeNode* findMin(TreeNode* node) {
    TreeNode* current = node;
    while (current && current->left != NULL) {
        current = current->left;
    }
    return current;
}

// 删除节点
TreeNode* deleteNode(TreeNode* root, int key) {
    if (root == NULL) return root;

    // 找到要删除的节点
    if (key < root->key) {
        root->left = deleteNode(root->left, key);
    } else if (key > root->key) {
        root->right = deleteNode(root->right, key);
    } else {
        // 找到要删除的节点
        // 情况1：节点没有子节点
        if (root->left == NULL && root->right == NULL) {
            free(root);
            root = NULL;
        }
        // 情况2：节点只有一个右子节点
        else if (root->left == NULL) {
            TreeNode* temp = root;
            root = root->right;
            free(temp);
        }
        // 情况3：节点只有一个左子节点
        else if (root->right == NULL) {
            TreeNode* temp = root;
            root = root->left;
            free(temp);
        }
        // 情况4：节点有两个子节点
        else {
            TreeNode* temp = findMin(root->right);
            root->key = temp->key;
            root->right = deleteNode(root->right, temp->key);
        }
    }
    return root;
}

// 中序遍历
void inorderTraversal(TreeNode* root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("%d ", root->key);
        inorderTraversal(root->right);
    }
}

这道题是压轴的难题，所以比较有难度，写不出来也无所谓。作者空着了但是成绩还是第三名，所以不会也无所谓。

Part 7:附加题：

（1）现在给定一张图P，请问经过顶点A的最小环路是什么样的？请画出汇点-源点图。

答案：简单来说，把A重复画两遍，一个A在最左边，一个A在最右边，画出中间的路线图。

（2）应该用什么算法？

答：第一次从A开始之后使用最短路径的Dijkstra算法再次回到A算出最小环路。

三、写在最后：

以上就是这份卷子的内容了。作者是在计算机科学学院夏令营结束之后回忆并书写了这份试卷。从此之后，作者希望不会有人在数据结构考试之前苦恼的询问：谁有上一届的卷子真题啊——接受了他人这么多的亮光，这一次，我也可以做一做那个提着灯的老人（；最后祝愿所有使用并研究清楚这份卷子的孩子们取得好成绩！

如发现有错误想要勘误，欢迎联系！