广东财经大学考研初试数据结构历年真题分类参考答案：图

W_F
87 阅读6分钟

选择题

[2024年第7题]. C

[2023年第7题]. B

[2022年第10题]. D

[2021年第11题]. B

[2021年第12题]. A

[2020年第8题]. D

[2020年第9题]. C

[2019年第5题]. A

[2019年第10题]. D

填空题

[2021年第2题]. 邻接表 邻接矩阵

[2021年第9题]. 9 n

[2021年第10题]. n 2e

名词解释

[2022年第4题]. 一个连通图的生成树包含图的所有顶点（假设顶点数为n），但只有构成一颗树的n-1条边，若再去掉一条边，那么树就会变得非连通；若增加一条边，则必然存在环路。一个连通图的所有生成树中，边的权值之和最小的那颗生成树就是最小生成树。

[2022年第5题]. 若一个有向图中没有环路，那么该图就被称为有向无环图。

[2022年第6题]. 在带权有向图中，即有向边表示活动的网，顶点表示事件，边上的权值表示该活动的开销（例如：活动持续的时间），称之为用边表示活动的网，即AOE网。在AOE网中，只有一个顶点入度为0，该点即为源点，只有一个出度为0的点，即汇点，从源点到汇点的路径可能有多条，所有路径中带权路径长度最大的路径即为关键路径。

[2022年第9题]. 在图的一种存储结构中，用一个一维数组存储图中的顶点信息，用一个二维数组存储图中边的信息，存储顶点之间邻接关系的二维数组称为邻接矩阵。

[2020年第10题]. 在带权有向图中，即有向边表示活动的网，顶点表示事件，边上的权值表示该活动的开销（例如：活动持续的时间），称之为用边表示活动的网，即AOE网。

简答题

[2023年第3题].

（1）、

DataStructure-GDEF_PostGraduate_Exam_2023_2_3_(1) .png

（2）、v1,v2,v6,v3,v5,v4

（3）、v6,v2,v1,v3,v5,v4

对于题目“从顶点v6开始按顶点存储顺序逆向遍历”的理解：
理解1：对于每个结点，对它的边结点进行逆序访问，比如v6作为起始结点，v6->v2->v1->v3->v5->v4（应该是这个，根据《考研指导》，由于一个顶点有多个邻结点，因此，存在着如何选择下一个结点的问题）

理解2：对于每个结点，对它的边结点进行顺序访问，比如v6作为起始结点，v6及相邻结点BFS结束后，再对v5，v4...进行BFS，v6->v1->v2->v3->v5->v4

理解3：对于每个结点，对它的边结点进行顺序访问，但是下一轮BFS的起始顶点是v6的最后一个边结点，比如v6作为起始结点，下一轮BFS起始顶点是v2，v6->v1->v2->v3->v5->v4

[2022年第5题].

（1）、0，1，2，5，4，3

（2）、0，1，4，3，2，5

[2021年分析计算题第2题].

（1）、

（2）、

（3）、15

[2020年第3题].

（1）、

012345
0011100
1100010
2100010
3100001
4011000
5000100

（2）、注：由于一个图的邻接矩阵表示是唯一的，所以其广度优先生成树也是唯一的。但邻接表存储表示不唯一，所以其广度优先生成树也是不唯一的。

[2020年第4题].

（1）

（2）、26

[2019年综合应用题第3题].

（1）

012345
0011100
1100010
2100010
3100001
4011000
5000100

（2）

（3）见上图。

（4）栈，队列。

[2019年综合应用题第4题].

（1）AC、DF、BE、CF、BC

（2）AC、CF、FD、BC、BE

（3）因为按照Kruskal求出的MST已经包含了图中最小的4条边，以及一条除了4条最小的边之外的最小边之一的边BC，因此MST唯一。

（4）当带权图中任意两条边的权值都不相同时，MST唯一。

综合分析题

[2024年第1题].

shapes at 25-06-06 17.13.12.png

[2023年第2题].

（1）、无向图。

shapes at 25-06-06 17.00.49.png

（2）、使用邻接矩阵表示，

//创建基于该存储结构上相应的数据结构
typedef struct G {
    int arr[6][6]; 
} G;

//为G中，p1和p2两个顶点之间添加边
void addEdge(G &g, char p1, char p2, int val) {
	//如何为p1与对应的数据下标建立映射关系
    G.arr[p1-'A'][p2-'A']=val;
    G.arr[p2-'A'][p1-'A']=val;
}

G create() {
	G g;
   	addEdge(g, 'A', 'B', 5);
    addEdge(g, 'A', 'C', 2);
    addEdge(g, 'A', 'D', 4);
    addEdge(g, 'B', 'C', 7);
    addEdge(g, 'B', 'E', 3);
    addEdge(g, 'C', 'D', 5);
    addEdge(g, 'C', 'E', 8);
    addEdge(g, 'C', 'F', 3);
    addEdge(g, 'D', 'F', 6);
    addEdge(g, 'E', 'F', 1);
}

（3）、Prim算法或者Kruskal算法。因为在本题中将修建高速路段的问题抽象为无向图的问题，城市即对应无向图中的一个顶点，修建高速路段费用即为无向图的边的权值，题目要求修建的高速路段需要连接所有城市，且保证总的修建费用最少，那么无向图的最小生成树即可满足上述要求，最小生成树可以保证连通所有顶点且总的权值最小。

（4）、13

编程题

[2022年第2题].

bool existCycle(Graph g, int vexNum) {
    bool onPath[] = {false};	//记录当前路径已经过的顶点，默认均未访问
    for (int i = 0; i <= vexNum - 1; i++) {
        bool existCycle = dfs(g, i, onPath);
        if (existCycle) return true;
    }
    return false;
}

bool dfs(Graph g, int from, bool onPath[]) {
    if (onPath[from]) return true; //说明点from已经被访问，现在又访问，说明图中存在环
    onPath[from] = true;
    for (int i = 0; i <= 与g的from顶点相邻的边节点数 - 1; i++) { //遍历与g的from节点相邻的边节点
        int to = g.at(from).at(i); 
        if (dfs(g, to, onPath)) return true;
    }
    onPath[from] = false;   //精髓代码：从from节点开始的所有路径已访问完毕
    return false;
}

[2021年第2题].

void dfsByStackImpl(AMIndGraph &g, bool *visited, int N) {
    std::stack<int> stack;
    for (int start_node = 0; start_node < N; ++start_node) {
        if (!visited[start_node]) {
            stack.push(start_node);
            while (stack.size() > 0) {
                int ele = stack.top();
                stack.pop();
                if (!visited[ele]) {
                    visited[ele] = true;
                    printf("%c", g.vexes[ele]);
                    for (int j = g.vexNum - 1; j >= 0; j--) {
                        if (g.matrix[ele][j] == 1 && !visited[j]) {
                            stack.push(j);
                        }
                    }
                }
            }
        }
    }
}

[2019年第3题].

int dfs(ALGraph G, int vrootNodeIdx, int j, bool *isVisit) {
    if (vrootNodeIdx == j) return 1;
    isVisit[vrootNodeIdx] = true;
    ArcNode *ptr = G.vexList[vrootNodeIdx].firstarc;
    if (ptr == NULL) return 0;
    while (ptr != NULL) { //递归访问vrootNodeIdx的相邻节点
        if (!isVisit[ptr->i]) {
            int flag = dfs(G, ptr->i, j, isVisit);
            if (flag == 1) return 1;
        }
        ptr = ptr->nextarc;
    }
    return 0;
}

int exist_path_DFS(ALGraph G, int i, int j) {
    bool isVisit[G.vexNum];
    for (int idx = 0; idx < G.vexNum; idx++) {
        isVisit[idx] = false;
    }
    return dfs(G, i, j, isVisit);
}
avatar
文章
阅读
粉丝