根据有向图的广度优先搜索遍历算法
信息学竞赛中的广度优先搜索算法
信息学竞赛中的广度优先搜索算法广度优先搜索（Breadth-First Search，BFS）是一种常用的图搜索算法，广泛应用于信息学竞赛中。
本文将介绍广度优先搜索算法的原理、应用场景以及实现方法。
一、算法原理广度优先搜索算法是一种基于队列的搜索算法，通过逐层扩展搜索的方式，从起始节点开始，依次遍历其邻接节点，然后依次遍历邻接节点的邻接节点，直到找到目标节点或遍历完所有节点为止。
该算法的基本过程如下：1. 创建一个队列，并将起始节点加入队列；2. 从队列中取出首个节点，并标记为已访问；3. 遍历该节点的邻接节点，若未被标记为已访问，则将其加入队列；4. 重复步骤2和步骤3，直到队列为空或找到目标节点。
广度优先搜索算法可以用来解决一些与图相关的问题，比如最短路径问题、连通性问题等。
二、应用场景广度优先搜索算法在信息学竞赛中有广泛的应用，以下是一些常见的应用场景。
1. 连通性问题：判断图中两个节点是否连通。
通过广度优先搜索，可以从起始节点开始遍历图，找到目标节点即可判断其连通性。
2. 最短路径问题：找到两个节点之间的最短路径。
广度优先搜索每一层的遍历都是从起始节点到目标节点的可能最短路径，因此可以通过记录路径长度和路径信息，找到最短路径。
3. 迷宫问题：求解迷宫中的最短路径。
迷宫可以看作是一个图，起始位置为起始节点，终点位置为目标节点，通过广度优先搜索可以找到迷宫中的最短路径。
4. 可达性问题：判断一个节点是否可达其他节点。
通过广度优先搜索，可以从起始节点开始遍历图，标记所有可达节点，然后判断目标节点是否被标记。
三、实现方法广度优先搜索算法的实现可以使用队列来辅助完成。
以下是一个基于队列的广度优先搜索算法的伪代码示例：```BFS(start, target):queue = [start] // 创建一个队列，并将起始节点加入队列visited = set() // 创建一个集合，用于标记已访问的节点while queue is not emptynode = queue.pop(0) // 从队列中取出首个节点visited.add(node) // 标记节点为已访问if node == targetreturn True // 找到目标节点，搜索结束for neighbor in node.neighbors // 遍历节点的邻接节点if neighbor not in visitedqueue.append(neighbor) // 将邻接节点加入队列return False // 队列为空，未找到目标节点```四、总结广度优先搜索算法在信息学竞赛中是一种常用的算法，它通过逐层遍历的方式，能够快速的找到目标节点或解决与图相关的问题。
广度优先搜索的原理及应用是什么
广度优先搜索的原理及应用是什么1. 原理广度优先搜索（Breadth-First Search, BFS）是一种图的遍历算法，它从图的起始顶点开始，逐层地向外探索，直到找到目标顶点或者遍历完整个图。
通过利用队列的数据结构，广度优先搜索保证了顶点的访问顺序是按照其距离起始顶点的距离递增的。
广度优先搜索的基本原理如下：1.选择一个起始顶点，将其加入一个待访问的队列（可以使用数组或链表实现）。
2.将起始顶点标记为已访问。
3.从队列中取出一个顶点，访问该顶点，并将其未访问过的邻居顶点加入队列。
4.标记访问过的邻居顶点为已访问。
5.重复步骤3和步骤4，直到队列为空。
广度优先搜索保证了先访问距离起始点近的顶点，然后才访问距离起始点远的顶点，因此可以用来解决一些问题，例如最短路径问题、连通性问题等。
2. 应用广度优先搜索在计算机科学和图论中有着广泛的应用，下面是一些常见的应用场景：2.1 最短路径问题广度优先搜索可以用来找出两个顶点之间的最短路径。
在无权图中，每条边的权值都为1，那么从起始顶点到目标顶点的最短路径就是通过广度优先搜索找到的路径。
2.2 连通性问题广度优先搜索可以用来判断两个顶点之间是否存在路径。
通过从起始顶点开始进行广度优先搜索，如果能够找到目标顶点，就说明两个顶点是连通的；如果搜索完成后仍然未找到目标顶点，那么两个顶点之间就是不连通的。
2.3 图的遍历广度优先搜索可以用来遍历整个图的顶点。
通过从起始顶点开始进行广度优先搜索，并在访问每个顶点时记录下访问的顺序，就可以完成对整个图的遍历。
2.4 社交网络分析广度优先搜索可以用来分析社交网络中的关系。
例如，在一个社交网络中，可以以某个人为起始节点，通过广度优先搜索找出与该人直接或间接连接的人，从而分析人际关系的密切程度、社区结构等。
2.5 网络爬虫广度优先搜索可以用来实现网络爬虫对网页的抓取。
通过从初始网页开始，一层层地向外发现新的链接，并将新的链接加入待抓取的队列中，从而实现对整个网站的全面抓取。
离散数学有向图常用算法思路概述
离散数学有向图常用算法思路概述离散数学是数学的一个分支，研究离散对象及其性质。
在离散数学中，有向图是一种常见的离散结构，它由一组节点（顶点）和一组有向边（弧）组成。
有向图在计算机科学、网络分析和运筹学等领域中具有广泛的应用。
针对有向图，有许多常用的算法思路可以帮助解决各种问题。
在本文中，我们将概述离散数学中常用的有向图算法思路。
一、深度优先搜索（DFS）深度优先搜索是一种常见的图搜索算法，用于遍历有向图。
它从图中的一个节点开始，沿着路径一直前进，直到无法继续，然后回溯到前一个节点继续搜索。
深度优先搜索可以用于检测环路、寻找连通分量以及生成拓扑排序等。
该算法的思路可以用以下伪代码表示：```DFS(节点v):标记节点v为已访问对于v的每个邻接节点u:如果u未被访问:递归调用DFS(u)```二、广度优先搜索（BFS）广度优先搜索是另一种用于遍历有向图的常见算法。
与深度优先搜索不同，广度优先搜索从源节点开始，首先遍历源节点的邻接节点，然后依次遍历它们的邻接节点，直到遍历完所有可达节点。
广度优先搜索可以用于寻找最短路径、检测连通性以及解决迷宫问题等。
该算法的思路可以用以下伪代码表示：```BFS(源节点s):创建一个空队列Q标记源节点s为已访问并入队while Q非空:取出队首节点v对于v的每个未被访问的邻接节点u:标记u为已访问并入队```三、拓扑排序拓扑排序是一种特殊的有向图排序算法，用于将有向无环图（DAG）中的所有节点排序为线性序列。
拓扑排序的思想是通过不断删除图中入度为0的节点，并更新相关节点的入度值，直到所有节点都被排序。
拓扑排序可以用于任务调度、依赖关系分析等场景。
该算法的思路可以用以下伪代码表示：TopologicalSort(有向图G):创建一个空队列Q和空列表L初始化所有节点的入度将所有入度为0的节点入队while Q非空:取出队首节点v并加入Lfor v的每个邻接节点u:更新u的入度值if u的入度变为0:将u入队```四、最短路径算法最短路径算法用于找到两个节点之间的最短路径。
第7章图的深度和广度优先搜索遍历算法
和树的遍历类似，我们希望从图中某顶点出发对图中每个顶点访问一次，而且只访问 一次，这一过程称为图的遍历(traversing graph)。 本节介绍两种遍历图的规则：深度优先搜索和广度优先搜索。 这两种方法既适用于无向图，也适用于有向图。
7.3.1 深度优先搜索遍历 一．思路： 从图中某一点（如A）开始，先访问这一点，然后任选它的一个邻点（如V0） 访问，访问完该点后，再任选这个点V0的一个邻点 （ 如 W ）访问，如此向 纵深方向访问。直到某个点没有其他未访问的邻点为止，则返回到前一个点。 再任选它的另一个未访问过的邻点 （ 如X ）继续重复上述过程的访问，直到全 部点访问完为止。 图(a)的遍历的结果:V1V2V4V8V5V3V6V7 或V1V3V7V6V2V5V8V4
p
v0 w x v 1
V
0
v 2
V
0
typedef struct {VEXNODE adjlist［MAXLEN］; // 邻接链表表头向量 int vexnum, arcnum; // 顶点数和边数 int kind; // 图的类型 }ADJGRAPH;
W W
X
X
7.3.2 广度优先搜索遍历 一.思路：
V
0
A V
0
W W
XXΒιβλιοθήκη 二．深度优先搜索算法的文字描述： 算法中设一数组visited，表示顶点是否访问过的标志。数组长度为 图的顶点数，初值均置为0，表示顶点均未被访问，当Vi被访问过，即 将visitsd对应分量置为1。将该数组设为全局变量。 { 确定从G中某一顶点V0出发，访问V0； visited［V0］ = 1； 找出G中V0的第一个邻接顶点->w； while (w存在) do { if visited［w］ == 0 继续进行深度优先搜索； 找出G中V0的下一个邻接顶点->w；} }
数据结构课设——有向图的深度、广度优先遍历及拓扑排序
数据结构课设——有向图的深度、⼴度优先遍历及拓扑排序任务：给定⼀个有向图，实现图的深度优先, ⼴度优先遍历算法，拓扑有序序列，并输出相关结果。
功能要求：输⼊图的基本信息，并建⽴图存储结构（有相应提⽰），输出遍历序列，然后进⾏拓扑排序，并测试该图是否为有向⽆环图，并输出拓扑序列。
按照惯例，先上代码，注释超详细：#include<stdio.h>#include<stdlib.h>#include<malloc.h>#pragma warning(disable:4996)#define Max 20//定义数组元素最⼤个数（顶点最⼤个数）typedef struct node//边表结点{int adjvex;//该边所指向结点对应的下标struct node* next;//该边所指向下⼀个结点的指针}eNode;typedef struct headnode//顶点表结点{int in;//顶点⼊度char vertex;//顶点数据eNode* firstedge;//指向第⼀条边的指针，边表头指针}hNode;typedef struct//邻接表（图）{hNode adjlist[Max];//以数组的形式存储int n, e;//顶点数，边数}linkG;//以邻接表的存储结构创建图linkG* creat(linkG* g){int i, k;eNode* s;//边表结点int n1, e1;char ch;g = (linkG*)malloc(sizeof(linkG));//申请结点空间printf("请输⼊顶点数和边数：");scanf("%d%d", &n1, &e1);g->n = n1;g->e = e1;printf("顶点数：%d 边数：%d\n", g->n, g->e);printf("请输⼊顶点信息（字母）：");getchar();//因为接下来要输⼊字符串，所以getchar⽤于承接上⼀条命令的结束符for (i = 0; i < n1; i++){scanf("%c", &ch);g->adjlist[i].vertex = ch;//获得该顶点数据g->adjlist[i].firstedge = NULL;//第⼀条边设为空}printf("\n打印顶点下标及顶点数据：\n");for (i = 0; i < g->n; i++)//循环打印顶点下标及顶点数据{printf("顶点下标：%d 顶点数据：%c\n", i, g->adjlist[i].vertex);}getchar();int i1, j1;//相连接的两个顶点序号for (k = 0; k < e1; k++)//建⽴边表{printf("请输⼊对<i,j>（空格分隔）：");scanf("%d%d", &i1, &j1);s = (eNode*)malloc(sizeof(eNode));//申请边结点空间s->adjvex = j1;//边所指向结点的位置，下标为j1s->next = g->adjlist[i1].firstedge;//将当前s的指针指向当前顶点上指向的结点g->adjlist[i1].firstedge = s;//将当前顶点的指针指向s}return g;//返回指针g}int visited[Max];//标记是否访问void DFS(linkG* g, int i)//深度优先遍历{eNode* p;printf("%c ", g->adjlist[i].vertex);visited[i] = 1;//将已访问过的顶点visited值改为1p = g->adjlist[i].firstedge;//p指向顶点i的第⼀条边while (p)//p不为NULL时（边存在）{if (visited[p->adjvex] != 1)//如果没有被访问DFS(g, p->adjvex);//递归}p = p->next;//p指向下⼀个结点}}void DFSTravel(linkG* g)//遍历⾮连通图{int i;printf("深度优先遍历;\n");//printf("%d\n",g->n);for (i = 0; i < g->n; i++)//初始化为0{visited[i] = 0;}for (i = 0; i < g->n; i++)//对每个顶点做循环{if (!visited[i])//如果没有被访问{DFS(g, i);//调⽤DFS函数}}}void BFS(linkG* g, int i)//⼴度优先遍历{int j;eNode* p;int q[Max], front = 0, rear = 0;//建⽴顺序队列⽤来存储，并初始化printf("%c ", g->adjlist[i].vertex);visited[i] = 1;//将已经访问过的改成1rear = (rear + 1) % Max;//普通顺序队列的话，这⾥是rear++q[rear] = i;//当前顶点（下标）队尾进队while (front != rear)//队列⾮空{front = (front + 1) % Max;//循环队列，顶点出队j = q[front];p = g->adjlist[j].firstedge;//p指向出队顶点j的第⼀条边while (p != NULL){if (visited[p->adjvex] == 0)//如果未被访问{printf("%c ", g->adjlist[p->adjvex].vertex);visited[p->adjvex] = 1;//将该顶点标记数组值改为1rear = (rear + 1) % Max;//循环队列q[rear] = p->adjvex;//该顶点进队}p = p->next;//指向下⼀个结点}}}void BFSTravel(linkG* g)//遍历⾮连通图{int i;printf("⼴度优先遍历：\n");for (i = 0; i < g->n; i++)//初始化为0{visited[i] = 0;}for (i = 0; i < g->n; i++)//对每个顶点做循环{if (!visited[i])//如果没有被访问过{BFS(g, i);//调⽤BFS函数}}}//因为拓扑排序要求⼊度为0，所以需要先求出每个顶点的⼊度void inDegree(linkG* g)//求图顶点⼊度{eNode* p;int i;for (i = 0; i < g->n; i++)//循环将顶点⼊度初始化为0{g->adjlist[i].in = 0;}for (i = 0; i < g->n; i++)//循环每个顶点{p = g->adjlist[i].firstedge;//获取第i个链表第1个边结点指针while (p != NULL)///当p不为空（边存在）{g->adjlist[p->adjvex].in++;//该边终点结点⼊度+1p = p->next;//p指向下⼀个边结点}printf("顶点%c的⼊度为：%d\n", g->adjlist[i].vertex, g->adjlist[i].in);}void topo_sort(linkG *g)//拓扑排序{eNode* p;int i, k, gettop;int top = 0;//⽤于栈指针的下标索引int count = 0;//⽤于统计输出顶点的个数int* stack=(int *)malloc(g->n*sizeof(int));//⽤于存储⼊度为0的顶点for (i=0;i<g->n;i++)//第⼀次搜索⼊度为0的顶点{if (g->adjlist[i].in==0){stack[++top] = i;//将⼊度为0的顶点进栈}}while (top!=0)//当栈不为空时{gettop = stack[top--];//出栈,并保存栈顶元素（下标）printf("%c ",g->adjlist[gettop].vertex);count++;//统计顶点//接下来是将邻接点的⼊度减⼀，并判断该点⼊度是否为0p = g->adjlist[gettop].firstedge;//p指向该顶点的第⼀条边的指针while (p)//当p不为空时{k = p->adjvex;//相连接的顶点（下标）g->adjlist[k].in--;//该顶点⼊度减⼀if (g->adjlist[k].in==0){stack[++top] = k;//如果⼊度为0，则进栈}p = p->next;//指向下⼀条边}}if (count<g->n)//如果输出的顶点数少于总顶点数，则表⽰有环{printf("\n有回路！\n");}free(stack);//释放空间}void menu()//菜单{system("cls");//清屏函数printf("************************************************\n");printf("* 1.建⽴图 *\n");printf("* 2.深度优先遍历 *\n");printf("* 3.⼴度优先遍历 *\n");printf("* 4.求出顶点⼊度 *\n");printf("* 5.拓扑排序 *\n");printf("* 6.退出 *\n");printf("************************************************\n");}int main(){linkG* g = NULL;int c;while (1){menu();printf("请选择：");scanf("%d", &c);switch (c){case1:g = creat(g); system("pause");break;case2:DFSTravel(g); system("pause");break;case3:BFSTravel(g); system("pause");break;case4:inDegree(g); system("pause");break;case5:topo_sort(g); system("pause");break;case6:exit(0);break;}}return0;}实验⽤图:运⾏结果：关于深度优先遍历 a.从图中某个顶点v 出发，访问v 。
图的各种算法(深度、广度等)
vex next 4 p
3
2 ^
2
^
5
5 5 4 3 2 1 0 ^
^
4 ^
top
4
输出序列：6 1
1 2 3 4 5 6
in link 0 2 ^ 1 0 2 0
vex next 4 p
3
2 ^
2
^
5
5 5 4 3 2 1 0 ^
^
4 ^
top 4
输出序列：6 1
1 2 3 4 5 6
in link 0 2 ^ 1 0 2 0
c a g b h f d e
a
b h c d g f
e
在算法中需要用定量的描述替代定性的概念
没有前驱的顶点 入度为零的顶点 删除顶点及以它为尾的弧 弧头顶点的入度减1
算法实现
以邻接表作存储结构 把邻接表中所有入度为0的顶点进栈 栈非空时，输出栈顶元素Vj并退栈；在邻接表中查找 Vj的直接后继Vk，把Vk的入度减1；若Vk的入度为0 则进栈 重复上述操作直至栈空为止。若栈空时输出的顶点个 数不是n，则有向图有环；否则，拓扑排序完毕
^
4
^
top
输出序列：6 1 3 2 4
1 2 3 4 5 6
in link 0 0 ^ 0 0 0 0
vex next 4
3
2 ^
2
^
5
5 5 4 3 2 1 0 ^ p
^
4
^topBiblioteka 5输出序列：6 1 3 2 4
1 2 3 4 5 6
in link 0 0 ^ 0 0 0 0
vex next 4
w2 w1 V w7 w6 w3
算法设计：深度优先遍历和广度优先遍历
算法设计：深度优先遍历和广度优先遍历实现深度优先遍历过程1、图的遍历和树的遍历类似，图的遍历也是从某个顶点出发，沿着某条搜索路径对图中每个顶点各做一次且仅做一次访问。
它是许多图的算法的基础。
深度优先遍历和广度优先遍历是最为重要的两种遍历图的方法。
它们对无向图和有向图均适用。
注意：以下假定遍历过程中访问顶点的操作是简单地输出顶点。
2、布尔向量visited[0．．n-1]的设置图中任一顶点都可能和其它顶点相邻接。
在访问了某顶点之后，又可能顺着某条回路又回到了该顶点。
为了避免重复访问同一个顶点，必须记住每个已访问的顶点。
为此，可设一布尔向量visited[0．．n-1]，其初值为假，一旦访问了顶点Vi之后，便将visited[i]置为真。
--------------------------深度优先遍历(Depth-First Traversal)1．图的深度优先遍历的递归定义假设给定图G的初态是所有顶点均未曾访问过。
在G中任选一顶点v为初始出发点(源点)，则深度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后依次从v出发搜索v的每个邻接点w。
若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。
若此时图中仍有未访问的顶点，则另选一个尚未访问的顶点作为新的源点重复上述过程，直至图中所有顶点均已被访问为止。
图的深度优先遍历类似于树的前序遍历。
采用的搜索方法的特点是尽可能先对纵深方向进行搜索。
这种搜索方法称为深度优先搜索(Depth-First Search)。
相应地，用此方法遍历图就很自然地称之为图的深度优先遍历。
2、深度优先搜索的过程设x是当前被访问顶点，在对x做过访问标记后，选择一条从x出发的未检测过的边(x，y)。
若发现顶点y已访问过，则重新选择另一条从x出发的未检测过的边，否则沿边(x，y)到达未曾访问过的y，对y访问并将其标记为已访问过；然后从y开始搜索，直到搜索完从y出发的所有路径，即访问完所有从y出发可达的顶点之后，才回溯到顶点x，并且再选择一条从x出发的未检测过的边。
广度优先搜索算法利用广度优先搜索解决的最短路径问题
广度优先搜索算法利用广度优先搜索解决的最短路径问题广度优先搜索算法（BFS）是一种图算法，用于解决最短路径问题。
其主要思想是从起始节点开始，不断扩展和访问其邻居节点，直到找到目标节点或者遍历完所有节点。
BFS算法可以用于解决许多问题，其中包括最短路径问题。
下面将介绍广度优先搜索算法的基本原理及其应用于最短路径问题的具体步骤。
同时，通过示例来进一步说明算法的执行过程和实际应用。
一、广度优先搜索算法原理广度优先搜索算法是一种层次遍历的算法，它从起始节点开始，按照距离递增的顺序，依次遍历节点。
在遍历的过程中，任意两个节点之间的距离不超过2，因此，BFS算法可以用于求解最短路径问题。
二、广度优先搜索算法的具体步骤1. 创建一个队列，用于存储待访问的节点。
2. 将起始节点放入队列中，并将其标记为已访问。
3. 当队列不为空时，执行以下步骤：a. 从队列中取出一个节点。
b. 访问该节点，并根据需求进行相应操作。
c. 将该节点的所有未访问过的邻居节点放入队列中，并将它们标记为已访问。
d. 重复步骤a~c，直到队列为空。
4. 完成以上步骤后，如果找到目标节点，则算法终止；否则，表示目标节点不可达。
三、广度优先搜索算法在最短路径问题中的应用最短路径问题是指从一个节点到另一个节点的最短路径，其长度可以通过广度优先搜索算法得到。
考虑以下示例：假设有一个迷宫，迷宫由多个格子组成，其中一些格子是墙壁，不可通过，而其他格子可以自由通行。
任务是找到从起始格子到达目标格子的最短路径。
利用广度优先搜索算法解决最短路径问题的具体步骤如下：1. 创建一个队列，并将起始格子放入队列中。
2. 将起始格子标记为已访问。
3. 当队列不为空时，执行以下步骤：a. 从队列中取出一个格子。
b. 如果该格子是目标格子，则算法终止。
c. 否则，获取该格子的邻居格子，并将未访问过的邻居格子放入队列中。
d. 将该格子的邻居格子标记为已访问。
e. 重复步骤a~d，直到队列为空。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
( 1 ) A.abecdf B.acfebd C.acebfd D.acfdeb
( 2 ) A.abcedf B.abcefd C.abedfc D.acfdeb
a
b
c
e
d
f
图7-13
• 16. 采用链接矩阵时,遍历图时的顶点所需时间为 （ ），采用链接表时，遍历图的顶点所需时间
C.链接表
Байду номын сангаас
D.十字链表
• 7.对一个具有n个顶点的图,采用链接矩
D 阵表示则该矩阵的大小为（
）
A.n
B.(n-1)2
C.(n+1)2
D.n2
• 8.设连通图G的顶点数为n,则G的生成树
A 的边数为（ ）
A.n-1 B.n C.2n D.2n-1
• 9.N个顶点的无向图的链接表中结点总数
D 最多有（
A.线性图
B.无向完全图
C.无向图
D.简单图
A • 4.具有4个顶点的无向完全图有（ ）条边。
A.6 B.12 C.16 D.20
• 5.G是一个非连通无向图,共有28条边，
D 则该图至少有（ ）个顶点。
A.6 B.7 C.8 D.9
C • 6.存储稀疏图的数据结构常用的是（ ）
A.链接矩阵 B.三元组
D.v5,v4,v6,v3,v2
2 12
3
6
57
5
6
图7-17
• 23. 在一个有n个顶点的无向网中,有
B ( nlo2gn)条边，则应该选用 ( )
算法来求这个网的最小生成树，从而 使计算时间较少。
A.Prim B.Kruskal
• 24.关键路径是事件结点网络中的（A）
A.从源点到汇点的最长路径 B.从源点到汇点的最短路径 C.最长回路 D.最短回路
C • 25. 正确的AOE网而言,必须是（
3^
• 20. 已知有8个顶点值为A,B，C，D，E，F， G，H的无向图，其邻接矩阵的存储结构 如图7-15所示（见下页）。由此结构，从 A顶点开始深度优先搜索遍历，得到的顶
B 点序列是（ ）。
A. A B C D G H F E B. A B C D G F H E C. A B G H F E C D D. A B F H E G D C
图7-15
• 21. 已知一个图如图7-16（见下页）所示,
在该图的最小生成树中各条边上权值之和
C 为（
），在该图的最小生成树中，
G 从顶点V1到顶点V6的路径为（
）
A.31 B.38 C.36 D.43
E.v1,v3.v6
F.v1,v4,v6
G.v1,v5,v4,v6 H.v1,v4,v3,v6
A.中序遍历 B.先序遍历
C. 后序遍历 D.按层遍历
• 19. 已知一有向图的链接表存储结构如图 7-14（见下页）所示。
• （1）根据有向图的深度优先搜索遍历算 法,从顶点V1出发，所得到的顶点序列是
（ C ）。
A.v1,v2,v3,v5,v4 B.v1,v2,v3,v4,v5
C.v1,v2,v3,v5,v4 D.v1,v4,v3,v5,v2
B E 为（ ）（注：设图有n个顶点，e条边）
A.O(n)
B.O(n2) C.O(e)
D.O(n*e) E.O(n+e)
• 17. 采用链接表存储的图的深度优先搜
索遍历算法类似于二叉树的（ B ）
A.中序遍历 B. 先序遍历
C. 后序遍历 D.按层遍历
• 18. 采用链接表存储的图的广度优先搜
索遍历算法类似于二叉树的（ D ）
010
可以看出,该图共
B 有（ ）个顶点。如果是有向图，
该图共有（
F）条弧；如果是有
向图，则共有（
G）条边。
A.9
B.3
C.6 D.1
E.5
F.4
G.2 H.0
• 12.在有向图的链接表存储结构中,顶
C 点V在表结点中出现的次数是（ ）
A.顶点v的度
B.顶点v的出度
C.顶点v的入度
D.依附于顶点v的边
E. A B E H F G D C F. A B E H G F C D
A B CDE F GH A0 1 0 1 0 0 0 0 B1 0 1 0 1 1 1 0 C0 1 0 1 0 0 0 0 D1 0 1 0 0 0 1 0 E0 1 0 0 0 0 0 1 F0 1 0 0 0 0 1 1 G0 1 0 1 0 1 0 1 H0 0 0 0 1 1 1 0
1 8
12
2
5
15
5
20
10
6
3
4
8
4
6
9
图7-16
• 22. 已知一个图如图7-17所示,则依据迪
杰斯特拉算法将按照（ ）B顶点次序依
次求出从顶点V1到其余各顶点的最短 路径。
A.v2,v5,v4,v6,v3 B.v2,v5,v4,v3,v6
C.v2,v3,v5,v4,v1
13 15 10 4
图练习
一、选择题
C • 1. 一个有n个顶点的无向图最多有（ ）条 边。 A. n B. n(n-1) C.n(n-1)/2 D.2n
• 2. 具有6个顶点的无向图至少应有（ 能确保是一个连通图。
A .5 B.6 C.7 D.8
A ）条边才
• 3.具有n个顶点且每一对不同的顶点之间都有一
B 条边的图被称为（ ）
）个。
A.2n B.n C.n/2 D.n(n-1)
• 10.对于一个具有n个顶点和e条边的无向图,
若采用链接表表示，则表向量的大小为
A （ ），所有顶点链接表的结点总数为
G （ ）。
A.n
B.n+1
C.n-1 D.2n
E.e/2
F.e
G.2e H.n+e
010
• 11.从链接矩阵
A
101
• 13. 在用链接表表示图的情况下,建立
A 图的算法的时间复杂度为（
）
A.O(n+e)
B.O(n2)
C.O(n*e)
D.O(n3)
• 14. 用DFS遍历一个无环有向图,并在 DFS算法退栈返回时，打印出相应的
顶点，则输出的顶点序列是（ A ）。
A.逆拓扑有序的
B.拓扑有序的
C.无序的
• 15.已知一个图如图7-13所示,若从顶点a出发按 深度优先搜索法进行遍历，则可能得到的是一
• （2）根据有向图的广度优先搜索遍历算 法，从顶点V1出发，所得到的顶点序列
是（ B ）。
A.v1,v2,v3,v5,v4 B.v1,v3,v2,v4,v5
C.v1,v2,v3,v5,v4 D.v1,v4,v3,v5,v2
0 v1
2
1
1 v2 ^
2 v3
3
4^
3 v4 ^
4 v5
1
3^
图7-14