采用连接表存储有向图-设计算法判断任意两个顶点间是否存在路径
判断两个顶点之间是否有路径
判断两个顶点之间是否有路径.txt心态决定状态，心胸决定格局，眼界决定境界。
当你的眼泪忍不住要流出来的时候，睁大眼睛，千万别眨眼，你会看到世界由清晰到模糊的全过程。
#include<stdio.h>#include<stdlib.h>#include<string.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0typedef int Status;#define MAX_NAME 5 /*顶点字符串的最大长度*/typedef int VRType;typedef char VertexType[MAX_NAME];#define MAX_VERTEX_NUM 20 /*最大顶点个数*/typedef struct ArcNode{int adjvex; /*该弧所指向的顶点的位置*/struct ArcNode *nextarc; /*指向下一条弧的指针*/}ArcNode; /*表结点*/typedef struct{VertexType data; /*顶点信息*/ArcNode *firstarc; /*第一个表结点的地址,指向第一条依附该顶点的弧(或边)的指针*/}VNode,AdjList[MAX_VERTEX_NUM];typedef struct{AdjList vertices;}ALGraph;int LocateVex(ALGraph G,VertexType u){ /*若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */int i;for(i=0;i<G.vexnum;++i)if(strcmp(u,G.vertices[i].data)==0)return i;return -1;}int FirstAdjVex(ALGraph G,int v){ /*返回第v个顶点的第一个邻接顶点的序号。
C++计算图任意两点间的所有路径
C++计算图任意两点间的所有路径基于连通图，邻接矩阵实现的图，⾮递归实现。
算法思想：设置两个标志位，①该顶点是否⼊栈，②与该顶点相邻的顶点是否已经访问。
A 将始点标志位①置1，将其⼊栈B 查看栈顶节点V在图中，有没有可以到达、且没有⼊栈、且没有从这个节点V出发访问过的节点C 如果有，则将找到的这个节点⼊栈，这个顶点的标志位①置1，V的对应的此顶点的标志位②置1D 如果没有，V出栈，并且将与v相邻的全部结点设为未访问，即全部的标志位②置0E 当栈顶元素为终点时，设置终点没有被访问过，即①置0，打印栈中元素，弹出栈顶节点F 重复执⾏B – E,直到栈中元素为空先举⼀个例⼦吧假设简单连通图如图1所⽰。
假设我们要找出结点3到结点6的所有路径，那么，我们就设结点3为起点，结点6为终点。
找到结点3到结点6的所有路径步骤如下：1、我们建⽴⼀个存储结点的栈结构，将起点3⼊栈，将结点3标记为⼊栈状态；2、从结点3出发，找到结点3的第⼀个⾮⼊栈没有访问过的邻结点1，将结点1标记为⼊栈状态，并且将3到1标记为已访问；3、从结点1出发，找到结点1的第⼀个⾮⼊栈没有访问过的邻结点0，将结点0标记为⼊栈状态，并且将1到0标记为已访问；4、从结点0出发，找到结点0的第⼀个⾮⼊栈没有访问过的邻结点2，将结点2标记为⼊栈状态，并且将0到2标记为已访问；5、从结点2出发，找到结点2的第⼀个⾮⼊栈没有访问过的邻结点5，将结点5标记为⼊栈状态，并且将2到5标记为已访问；6、从结点5出发，找到结点5的第⼀个⾮⼊栈没有访问过的邻结点6，将结点6标记为⼊栈状态，并且将5到6标记为已访问；7、栈顶结点6是终点，那么，我们就找到了⼀条起点到终点的路径，输出这条路径；8、从栈顶弹出结点6，将6标记为⾮⼊栈状态；9、现在栈顶结点为5，结点5没有⾮⼊栈并且⾮访问的结点，所以从栈顶将结点5弹出，并且将5到6标记为未访问；10、现在栈顶结点为2，结点2的相邻节点5已访问，6满⾜⾮⼊栈，⾮访问，那么我们将结点6⼊栈；11、现在栈顶为结点6，即找到了第⼆条路径，输出整个栈，即为第⼆条路径12、重复步骤8-11，就可以找到从起点3到终点6的所有路径；13、栈为空，算法结束。
作业4图 参考答案
作业4. 图非编程作业参考答案：1．已知带权无向图如图所示：(1). 根据普里姆（Prim）算法，求它的从顶点a出发的最小生成树(写出过程，即添加顶点、边次序)；(2). 根据克鲁斯卡尔（Kruskal）算法，求该图的最小生成树(写出过程，即添加边次序)。
普里姆（Prim）算法：aadaed2aced23acbed1234234克鲁斯卡尔（Kruskal）算法：acbedacbed1acbed12acbed123acbed12342. 已知带权有向图如图所示：(1). 画出该图的邻接矩阵存储结构；(2). 请写出该图的一个拓扑有序序列；(3). 求从顶点a到其余各顶点之间的最短路经及最短路经长度，并给出计算过程。
图G的一个拓扑序列：abdfecgh afbdecghabdfegch afbdegch2421∞∞∞⎢∞∞g02690301050280730∞∞∞∞⎡⎤⎢⎥∞∞∞∞∞⎢⎥⎢⎥∞∞∞∞∞∞⎢⎥∞∞∞∞∞∞⎢⎥⎢⎥∞∞∞∞∞⎢⎥∞∞⎥⎢⎥∞∞∞∞∞⎢⎥∞∞∞∞∞∞⎢⎥⎣⎦a b c d e f g habcdefh从a出发到其它顶点的最短路径及其计算过程：编程作业：请编写一个完整的程序，建立有向图的邻接表存储结构，并判断两顶点间是否有路径存在，要求：(1) 主函数功能：①从键盘读入有向图的顶点数、有向边数，调用函数CreateAdjList()建立邻接表；②在主函数中输出每个顶点的数据域及其所有邻接点；③从键盘读入两个顶点vs 、v t（ts ）的数据域，调用函数Path()判断其间是否存在路径；(2) CreateAdjList()：建立有向图邻接表。
功能：从键盘接收各顶点数据域及各条有向边所依附的顶点（如：“2,3”代表该边依附的两个顶点在表头数组中的下标为2和3），要求单链表中结点按数据域升序排序；(3) Path(): 判断两顶点间是否存在路径，如果存在，将打印该路径（若存在多条路径，打印其中一条即可）。
连通图中任意两顶点间所有路径的求取算法
路径并且输出路径和路径上的权值的和， 否则继续搜索。 (2) 将 源 点 （ start point):覽 于 梭 底 ， 源点 .(start point) 的标處 位 置 为 1;判断栈顶点的最先连接点是否入栈， 若未入栈则入栈
如 图 1 所示 。
2 相关知识
图中顶点用一个一维数组存储。图 中 每 个 顶 点 V i 的所有邻接 点构成一个线性泰3 ] 。
定 义 3. 路 径 ：设 倒 G ={ V ， E } 的 一 个 顶 .点 序 列 {uzvi。 ， ^ ， ....， v f v } 中 (％ __!， v j e E ， 1 在j 彡m ， 则称顶点u 到顶点v . 存在
福 建 电 脑
U J IA N C O M P U T E R DOI:10.16707 /j . cnki. fjpc .2017.12.007
连通图中任意两顶点间所有路径的求取算法
芏 军 ，田 波
( 铜 仁 学 院 大 数 据 学 院 铜 仁 贵 州 554300) 【 摘 要 】 连 通 图 中 任 意 两 顶 点 间 所 有 路 径 的 求 取 是 路 径 搜 索 （ path search )中的一■个重要问题。 通 过 采 用 邻 接 表 为存 储结构， 栈存储每轮搜索的路径， 而标志数组用来标志每一轮搜索过程中路径上的顶点是否被访问， 提出一种基于深度 优 先 的 求 取 任 意 两 顶 点 间 所 有 的 路 径 的 求 取 算 法 。分 析 表 明 ， 该算法空间复杂度和时间复杂度较低， 可 以 满足各 类 嵌入 式设备的要求， 具有较强的实际应用价值。 【 关键字】 连通图； 路径搜索； 栈;深 度 优 先
(0012)《数据结构》复习思考题答案(DOC)
（0012）《数据结构》复习思考题答案1：[论述题]1、算法的时间复杂度仅与问题的规模相关吗?2、下列程序段带标号语句的频度和时间复杂度。
( 1 ) I=0;while (I<N)&&(A[I]!=K)I++; //语句3return(I);( 2 ) n为不小于1的整数（设k的初值等于1）void pp ( int k){if (k==n) //语句1for (I=0; I语句2printf(a[I]); //语句3else{ for (I=k-1;I语句4a[I]=a[I]+I; //语句5pp(k+1); //语句6}}//pp3、常用的存储表示方法有哪几种?参考答案：1、不,事实上，算法的时间复杂度不仅与问题的规模相关，还与输入实例中的元素取值等相关，但在最坏的情况下，其时间复杂度就是只与求解问题的规模相关的。
我们在讨论时间复杂度时，一般就是以最坏情况下的时间复杂度为准的。
2、（1）这个算法完成在一维数组a[n]中查找给定值k的功能。
语句三的频度不仅与问题的规模n有关，还与输入实例中a的各元素取值以及k的取值相关，即与输入实例的初始状态复杂有关。
若a中没有与k相等的元素，则语句三的频度为n；若a中的第一个元素a[0]等于k，则语句三的频度是常数0。
在这种情况下，可用最坏情况下的时间复杂度作为时间复杂度。
在此例中即为O(n)。
这样做的原因是：最坏情况下的时间复杂度是在任何输入实例上运行时间的上界。
有时,也可能选择将算法的平均(或期望)时间复杂度作为讨论目标。
所谓的平均时间复杂度是指所有可能的输入实例以等概率出现的情况下算法的期望运行时间与问题规模的数量级的关系。
此例中，以k出现在任何位置的概率相同，都为1/n，则语句三的执行频度为[0+1+2+…+(n-1)]/n=(n-1)/2。
它决定了此程序段的平均时间复杂度的数量级为f(n)=n,记作O(n)。
（2）在计算包含调用语句的算法的语句频度时，需考虑到调用发生时在被调用算法中各语句的执行情况。
数据结构作业答案第章图作业答案
第7章 图 自测卷解答 姓名 班级一、单选题（每题1分，共16分） 前两大题全部来自于全国自考参考书！（ C ）1. 在一个图中，所有顶点的度数之和等于图的边数的 倍。
A ．1/2 B. 1 C. 2 D. 4 （B ）2. 在一个有向图中，所有顶点的入度之和等于所有顶点的出度之和的 倍。
A ．1/2 B. 1 C. 2 D. 4 （ B ）3. 有8个结点的无向图最多有 条边。
A ．14 B. 28 C. 56 D. 112 （ C ）4. 有8个结点的无向连通图最少有 条边。
A ．5 B. 6 C. 7 D. 8 （ C ）5. 有8个结点的有向完全图有 条边。
A ．14 B. 28 C. 56 D. 112 （B ）6. 用邻接表表示图进行广度优先遍历时，通常是采用 来实现算法的。
A ．栈 B. 队列C. 树D. 图 （ A ）7. 用邻接表表示图进行深度优先遍历时，通常是采用 来实现算法的。
A ．栈 B. 队列C. 树D. 图 （ ）8. 已知图的邻接矩阵，根据算法思想，则从顶点0出发按深度优先遍历的结点序列是（ D ）9. 已知图的邻接矩阵同上题8，根据算法，则从顶点0出发，按深度优先遍历的结点序列是A ． 0 2 4 3 1 5 6 B. 0 1 3 5 6 4 2 C. 0 4 2 3 1 6 5 D. 0 1 3 4 2 5 6 （ ）10. 已知图的邻接矩阵同上题8，根据算法，则从顶点0出发，按广度优先遍历的结点序列是A ． 0 2 4 3 6 5 1 B. 0 1 3 6 4 2 5 C. 0 4 2 3 1 5 6 D. 0 1 3 4 2 5 6 （建议：0 1 2 3 4 5 6） （ C ）11. 已知图的邻接矩阵同上题8，根据算法，则从顶点0出发，按广度优先遍历的结点序列是A ． 0 2 4 3 1 6 5 B. 0 1 3 5 6 4 2 C. 0 1 2 3 4 6 5 D. 0 1 2 3 4 5 6A ．0 2 4 3 1 5 6B. 0 1 3 6 5 4 2C. 0 4 2 3 1 6 5D. 0 3 6 1 5 4 2建议：先画出图，再深度遍历⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡0100011101100001011010110011001000110010011011110（ A ）12. 已知图的邻接表如下所示，根据算法，则从顶点0出发不是深度优先遍历的结点序列是A．0 1 3 2 B. 0 2 3 1C. 0 3 2 1D. 0 1 2 3（A）14. 深度优先遍历类似于二叉树的A．先序遍历 B. 中序遍历 C. 后序遍历 D. 层次遍历（D）15. 广度优先遍历类似于二叉树的A．先序遍历 B. 中序遍历 C. 后序遍历 D. 层次遍历（A）16. 任何一个无向连通图的最小生成树A．只有一棵 B. 一棵或多棵 C. 一定有多棵 D. 可能不存在（注，生成树不唯一，但最小生成树唯一，即边权之和或树权最小的情况唯一）二、填空题（每空1分，共20分）1. 图有邻接矩阵、邻接表等存储结构，遍历图有深度优先遍历、广度优先遍历等方法。
第7章自测题与答案
第7章图自测卷解答姓名班级题号一二三四五总分题分1620241030100得分一、单选题（每题1分，共16分）（C）1.在一个图中，所有顶点的度数之和等于图的边数的倍。
A．1/2B.1C.2D.4（B）2.在一个有向图中，所有顶点的入度之和等于所有顶点的出度之和的倍。
A．1/2B.1C.2D.4（B）3.有8个结点的无向图最多有条边。
A．14B.28C.56D.112（C）4.有8个结点的无向连通图最少有条边。
A．5B.6C.7D.8（C）5.有8个结点的有向完全图有条边。
A．14B.28C.56D.112（B）6.用邻接表表示图进行广度优先遍历时，通常是采用来实现算法的。
A．栈B.队列C.树D.图（A）7.用邻接表表示图进行深度优先遍历时，通常是采用来实现算法的。
A．栈B.队列C.树D.图（C）8.已知图的邻接矩阵，根据算法思想，则从顶点0出发按深度优先遍历的结点序列是01111011001001A．02431561000100B.0136542C.042316511001101011010D.03615420001101建议：01342561100010（D）9.已知图的邻接矩阵同上题8，根据算法，则从顶点0出发，按深度优先遍历的结点序列是A．0243156B.0135642C.0423165D.0134256（B）10.已知图的邻接矩阵同上题8，根据算法，则从顶点0出发，按广度优先遍历的结点序列是A．0243651B.0136425C.0423156D.0134256（建议：0123456）（C）11.已知图的邻接矩阵同上题8，根据算法，则从顶点0出发，按广度优先遍历的结点序列是A．0243165B.0135642C.0123465D.01234561（D）12.已知图的邻接表如下所示，根据算法，则从顶点0出发按深度优先遍历的结点序列是A．0132B.0231C.0321D.0123（A）13.已知图的邻接表如下所示，根据算法，则从顶点0出发按广度优先遍历的结点序列是A．0321B.0123C.0132D.0312（A）14.深度优先遍历类似于二叉树的A．先序遍历B.中序遍历C.后序遍历D.层次遍历（D）15.广度优先遍历类似于二叉树的A．先序遍历B.中序遍历C.后序遍历D.层次遍历（A）16.任何一个无向连通图的最小生成树A．只有一棵B.一棵或多棵C.一定有多棵D.可能不存在（注，生成树不唯一，但最小生成树唯一，即边权之和或树权最小的情况唯一）二、填空题（每空1分，共20分）1.图有邻接矩阵、邻接表等存储结构，遍历图有深度优先遍历、广度优先遍历等方法。
数据结构第7章图 自测卷答案
第7章 图 自测卷解答 姓名 班级一、单选题（每题1分，共16分） 前两大题全部来自于全国自考参考书！（ C ）1. 在一个图中，所有顶点的度数之和等于图的边数的 倍。
A ．1/2 B. 1 C. 2 D. 4 （B ）2. 在一个有向图中，所有顶点的入度之和等于所有顶点的出度之和的 倍。
A ．1/2 B. 1 C. 2 D. 4 （ B ）3. 有8个结点的无向图最多有 条边。
A ．14 B. 28 C. 56 D. 112 （ C ）4. 有8个结点的无向连通图最少有 条边。
A ．5 B. 6 C. 7 D. 8 （ C ）5. 有8个结点的有向完全图有 条边。
A ．14 B. 28 C. 56 D. 112 （B ）6. 用邻接表表示图进行广度优先遍历时，通常是采用 来实现算法的。
A ．栈 B. 队列C. 树D. 图 （ A ）7. 用邻接表表示图进行深度优先遍历时，通常是采用 来实现算法的。
A ．栈 B. 队列C. 树D. 图 （ ）8. 已知图的邻接矩阵，根据算法思想，则从顶点0出发按深度优先遍历的结点序列是（ D ）9. 已知图的邻接矩阵同上题8，根据算法，则从顶点0出发，按深度优先遍历的结点序列是A ． 0 2 4 3 1 5 6 B. 0 1 3 5 6 4 2 C. 0 4 2 3 1 6 5 D. 0 1 3 4 2 5 6 （ ）10. 已知图的邻接矩阵同上题8，根据算法，则从顶点0出发，按广度优先遍历的结点序列是A ． 0 2 4 3 6 5 1 B. 0 1 3 6 4 2 5 C. 0 4 2 3 1 5 6 D. 0 1 3 4 2 5 6 （建议：0 1 2 3 4 5 6） （ C ）11. 已知图的邻接矩阵同上题8，根据算法，则从顶点0出发，按广度优先遍历的结点序列是A ． 0 2 4 3 1 6 5 B. 0 1 3 5 6 4 2 C. 0 1 2 3 4 6 5 D. 0 1 2 3 4 5 6A ．0 2 4 3 1 5 6B. 0 1 3 6 5 4 2C. 0 4 2 3 1 6 5D. 0 3 6 1 5 4 2建议：0 1 3 4 2 5 6⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡0100011101100001011010110011001000110010011011110（ D ）12. 已知图的邻接表如下所示，根据算法，则从顶点0出发按深度优先遍历的结点序列是（ A ）13. 已知图的邻接表如下所示，根据算法，则从顶点0出发按广度优先遍历的结点序列是（ A ）14. 深度优先遍历类似于二叉树的A ．先序遍历 B. 中序遍历 C. 后序遍历 D. 层次遍历 （ D ）15. 广度优先遍历类似于二叉树的A ．先序遍历 B. 中序遍历 C. 后序遍历 D. 层次遍历 （ A ）16. 任何一个无向连通图的最小生成树A ．只有一棵 B. 一棵或多棵 C. 一定有多棵 D. 可能不存在 （注，生成树不唯一，但最小生成树唯一，即边权之和或树权最小的情况唯一）二、填空题（每空1分，共20分）1. 图有 邻接矩阵 、 邻接表 等存储结构，遍历图有 深度优先遍历 、 广度优先遍历 等方法。
《数据结构与算法设计》树-习题
• 已知二叉树 – 先序序列为：ABCDEF – 中序序列为：CBAEDF • 请画出该二叉树。
A
B
C E
D
F
9
A
D
10
• 已知二叉树 – 中序序列为：ABCEFGHD – 后序序列为：ABFHGEDC • 请画出该二叉树。 – 中序：LDR A – 后序：LRD A B C E F G H D A B F H G E D C
swap(b->rchild );
}
交换左右子树
15
• 请指出下列函数的功能
void preserve(BiTNode *b, ElemType a[], int n){
static int i = 0; if(b != NULL) { preserve(b->lChild, a,n); a[i++] = b->data;
preserve(b->rChild, a,n);
} }
得到二叉树b的中序遍历序列，结果放在数组a中
16
2005考研试题
根据______可以唯一地确定一棵二叉树。 A. 先序遍历和后序遍历 B. 先序遍历和层次遍历 C. 中序遍历和层次遍历 D. 中序遍历和后序遍历
D. 中序遍历和后序遍历
所有分支结点的度为2的二叉树称为正则二叉树，试 用二叉链表做存储结构，编写一递归函数int FormalTree(Bitree t)，判断二叉树是否为正则二叉树。 int FormalTree(Bitree t) { if (t == NULL) return 1; if ((t->lchild == NULL) && (t->rchild == NULL)) return 1; if ((t->lchild == NULL) || (t->rchild == NULL)) return 0; return (FormalTree(t->lchild)) && (FormalTree(t->rchild)); }
判别无向图中任意两个顶点之间是否存在长度为K的简单路径
目录一、问题描述 (2)二、设计思路 (2)三、测试用例设计 (3)四、详细设计 (3)五、调试分析 (5)六、心得体会 (8)七、参考文献 (10)八、附录 (10)九、课程设计评定表 (15)一、问题描述题目: 判别无向图中任意两个顶点之间是否存在长度为K的简单路径。
初始条件：（1）采用邻接表作为存储结构。
（2）编写程序判别无向图中任意给定的两个顶点之间是否存在一条长度为k的简单路径。
（3）测试用例自己设计。
注释：简单路径，即其顶点序列中不含有重现的顶点二、设计思路●存储结构设计1.采用邻接表作为无向图的存储结构，即顶点序列用一维数组描述，每个顶点所连接的边用单链表存储。
2.增设一个一维数组，用于存储搜索简单路径时所访问的节点。
●主要算法设计步骤：1.创建无向图CreateMGaph(MGraph &G)①输入无向图的顶点数、边数。
②给各个顶点命名，采用字符型编号。
③输入每条边所连接的两个顶点，即各顶点间的相通性初始化。
④每输入一条边，则判断其合法性：In(SList &L,char a)。
若输入的顶点对中出现了②中没有的新顶点，则提示相应的出错信息，重新输入一条新的边。
2. 打印出邻接表：void print(MGraph G)以每一个顶点为头指针，打印出与该顶点相邻的所有顶点。
然后换行，顺次打印下面的顶点及其相邻点。
3．搜索任意给出的两个顶点间是否存在长度为K的简单路径若搜索成功则返回成功标志，否则返回失败标志：int Search(MGraph G,int x,int y,int k)。
三．测试用例设计1.输入的顶点数：52.输入的边数;63.各顶点名称：A，B，C，D，E4.各条边所对应的顶点对：（A，D）（A，E）（D，E）（D，B）（C，B）（C，E）5.输入要寻找的顶点对及其简单路径长度分别为：（A，D），4四、详细设计4.1 存储结构说明4.1.1邻接表的存储表示#define MAX_VERTEX_NUM 20 //宏定义，最大顶点数typedef struct ArcNode{ //边表结点int adjvex;struct ArcNode *nextarc;}ArcNode;typedef struct VNode{ //头结点char data;ArcNode *firstarc;}VNode,AdjList[MAX_VERTEX_NUM];typedef struct{AdjList vertices;int n,e;}MGraph; //无向图4.1.2 标记访问过的顶点数组int visited[MAX_VERTEX_NUM]; //访问标志函数4.1.3 存储已访问过的顶点的数组int path[MAX_VERTEX_NUM];4.2 主要函数声明4.2.1 创建无向图void CreateMGaph(MGraph &G)4.2.2 寻找各个顶点的位置char GetValue(MGraph G,int i)4.2.3 判断新输入的顶点是否在图中int IsIn(MGraph G,char m)4.2.4 返回顶点的值char GetValue(MGraph G,int i)4.2.5 打印出邻接表void print(MGraph G)4.2.6 查找两顶点m，n之间是否存在长度为k的简单路径int Search(MGraph G,int x,int y,int k,int visited[],int path[],int d)4.3 主程序int main(){cout<<"--------------创建无向图------------"<<endl<<endl;CreateMGaph(G);cout<<"-----------打印邻接表----------------"<<endl<<endl;print(G);cout<<"----------------寻找长度为K的简单路径--------"<<endl<<endl;cout<<"寻找路径的两个顶点：";cin>>m>>n；cout<<"请输入想寻找的简单路径的长度：";cin>>k;Search(G,x,y,k,visited,path,-1)；return 0;}五、调试分析5.1 程序的运行与调试5.1.1 设计程序所应考虑的因素该程序所要执行的操作是比较简单的，但细到微处却有很多要考虑的因素，如果不面面俱到，考虑全面，则会使运行过程过于简单，程序的功能不够完美。
数据结构 所有章节测验 测验答案 慕课答案 UOOC优课 课后练习 深圳大学
数据结构章节测验数据结构第一章测验一、单选题 (共100.00分)1. 在数据结构概念中，数据的基本单位是（）A. 数据段B. 数据项C. 数据表D. 数据元素正确答案：D2. 在数据结构概念中，结构是描述（）A. 数据项的类型B. 数据元素之间的关系C. 数据成员的先后顺序D. 数据对象的取值范围正确答案：B3. 在算法设计中，要求算法便于理解和修改是属于算法要求的（）A. 正确性B. 可读性C. 健壮性D. 效率高正确答案：B4. 抽象数据类型ADT通过三方面描述，包括数据对象、数据操作和（）A. 数据范围B. 数据判断C. 数据关系D. 数据来源正确答案：C5. 以下关于算法的描述，哪个是正确的（）A. 算法可以没有输入B. 算法可以包含无限个执行步骤C. 算法可以没有输出D. 算法的每个步骤允许带有歧义的正确答案：A6. 在算法设计中，要求算法满足具体问题的需求是属于算法要求的（）A. 正确性B. 可读性C. 健壮性D. 效率高正确答案：A7. 抽象数据类型ADT通过三方面描述，包括数据关系、数据操作和（）A. 数据对象B. 数据来源C. 数据范围D. 数据判断正确答案：A8. 以下关于数据结构的描述，哪一个是正确的（）A. 数据原子是数据的最小独立单位B. 数据元素是数据的最小独立单位C. 一个数据项可以包含若干个数据元素D. 不能被计算机程序识别和处理的信息集合，不能称为数据正确答案：D9. 设n为问题规模，以下程序的时间复杂度为（）for (i=1; i<=10000; i++) for (j=1; j<=n; j++) a = a + 1;A. O(1)B. O(n)C. O(10000n)D. O(n2)正确答案：B10. 设n为问题规模，以下程序的时间复杂度为（） for (i=1; i< POW（2, n）; i++) //POW(x, y)函数表示x的y 次幂a = a+100;A. O(n)B. O(2n)C. O(n!)D. O(2n)正确答案：D数据结构第二章测验一、单选题 (共100.00分)1. 以下结构中，哪一个是属于逻辑结构（）A. 线性表B. 顺序表C. 单链表D. 循环链表正确答案：A2. 已知顺序表包含1000个数据，现在第88号位置插入新的数据，需要移动的数据个数为（）A. 88B. 87C. 912D. 913正确答案：D3. 若线性表最常用的操作是存取第i个元素及其后继的值,则最节省操作时间的存储结构是（）A. 单链表B. 双链表C. 单循环链表D. 顺序表正确答案：D4. 以下结构中，哪一个是属于物理结构（）A. 线性表B. 栈C. 单链表D. 队列正确答案：C5. 已知顺序表包含100个数据，现在要删除第99号位置的数据，需要移动的数据个数为（）A. 99B. 100C. 1D. 2正确答案：C6. 已知指针p指向单链表L的某个结点，判断p指向的结点是尾结点的条件是（）A. if (p->next>p)B. if (p->next==NULL)C. if (p->nextD. if (p->data==0)正确答案：B7. 以下描述哪个是正确的（）A. 线性表的数据元素的存储位置一定是连续的B. 顺序表的数据元素的存储位置一定是连续的C. 链表的数据元素的存储位置一定不是连续的D. 线性表的数据元素的存储位置一定不是连续的正确答案：B8. 已知顺序表包含100个数据，先在第15号位置插入1个新数据，接着删除第3号位置的数据，需要移动的数据总个数为（）A. 18B. 84C. 184D. 188正确答案：C9. 设某单链表包含10个结点，已知指针p指向第3个结点，指针q指向第4个结点，删除第4个结点的语句为（）A. p->next = q->next; free(q);B. q->next = p; free(p);C. p = q->next; free(p);D. q = p->next; free(q);正确答案：A10. 设某单链表包含10个结点，已知指针s指向一个新结点，指针p指向第4个结点，现在第4个结点之后插入这个新结点的两个语句为（）A. p->next = s; s->next = p->next;B. s->next = p->next; p->next = s;C. p->next = s->next; s->next = p;D. s->next = p; p->next = s->next;正确答案：B数据结构第三章测验一、单选题 (共100.00分)1. 以下结构中，哪一个是属于逻辑结构（）A. 顺序栈B. 链栈C. 队列D. 循环队列正确答案：C2. 已知栈S为空，数据1、2、3、4依次逐个进入栈S，则栈顶数据为（）A. 1B. 2C. 3D. 4正确答案：D3. 已知队列为空，数据1、2、3、4依次逐个进入队列，则出队的数据顺序为（）A. 1234B. 4321C. 1324D. 2413正确答案：A4. 栈的最大特点是（）A. 先进先出B. 后进先出C. 无限递归D. 有限递归正确答案：B5. 队列的最大特点是（）A. 先进先出B. 后进先出C. 无限递归D. 有限递归正确答案：A6. 已知栈包含10元素，其中存放在栈底是第1号元素，则第10号元素可以通过（）进行访问A. 栈底B. 栈中C. 栈尾D. 栈顶正确答案：D7. 以下描述正确的是（）A. 顺序栈可以直接访问栈内任意位置的元素，而链栈不可以B. 链栈可以直接访问栈内任意位置的元素，而顺序栈不可以C. 通过栈可以实现程序的递归算法D. 通过队列可以实现程序的递归算法正确答案：C8. 以下结构中，哪一个是属于物理结构（）A. 栈B. 队列C. 链队列D. 线性表正确答案：C9. 使用长度为10的数组实现循环队列，则该队列最多存储数据个数为（）A. 1B. 9C. 11.D.5正确答案：B10. 在队列中，允许插入的一端称为（）A. 队头B. 队中C. 队指针D. 队尾正确答案：D数据结构第四章测验一、单选题 (共100.00分)1. 以下结构中，哪一个是属于逻辑结构（）A. 顺序表B. 链栈C. 循环队列D. 串正确答案：D2. 以下哪一种是串在计算机中的常见表示方式（）A. 定长顺序B. 堆分配C. 块链D. 前三种都是正确答案：D3. 在数据结构中，串可以等同于（）的处理A. 整数串B. 浮点数串C. 字符串D. 多种类型的数组正确答案：C4. 以下哪一种是串匹配的常用算法（）A. 普里姆算法B. 克鲁斯卡尔算法C. KMP算法D. 关键路径算法正确答案：C5. 已知主串为abcbcaddabc，模式串为cad，假设串位置从1开始，则串匹配位置是（）A. 3B. 5C. 7D. 不存在正确答案：B6. 已知模式串为abaab，则next数组为（）A. 1122B. 22312C. 1212D. 1112正确答案：A7. 已知串S的内容为1+2+3，以下描述哪一个是正确的（）A. 串S的长度是6B. 串S的运算结果是6C. 整数1是串S的子串D. 符号+是串S的子串正确答案：D8. 以下描述哪一个是正确的（）A. 串是字符有限序列B. 串是整数、浮点数、字符等多种数据的有限序列C. 只包含空格的串称为空串D. 串只能使用顺序表存储正确答案：A9. 串的长度是指（）A. 串中包含不同字母的个数B. 串中所含字符的个数C. 串中包含不同字符的个数D. 串中包含非空格的字符的个数正确答案：B10. 串函数Sub(S, x, y)表示在串S中，从x位置开始，取出y个字符，串位置从1开始计算。
判断有向图中两点之间是否存在路径
#include<stdio.h>#include<stdlib.h>#include<conio.h>#define DL 30#define Max 50int flag=0;int visited[Max];typedef struct Edge//边、桥{int Vnum;//边上挂着要指向的点的编号struct Edge *next;//边和点的指针类型相同}Edge;typedef struct Vert//点{int VNO;//点序号char Vname[DL];//点名称Edge *head;//边和点的指针类型相同}Vert;typedef struct{Vert List[Max];//地图上最多有Max个点int num_vert;//点的个数int num_edge;//边的个数}Map;void CreateMap(Map *HF);void Print(Map *HF);void DFS(Map *HF,int i,int j);void Check(Map *HF);void ClearMap(Map *HF);void main(){Map *HF;HF=(Map *)malloc(sizeof(Map));CreateMap(HF);Print(HF);Check(HF);ClearMap(HF);}void CreateMap(Map *HF){int i,j;Edge *E;printf("输入图中，点的个数：");scanf("%d",&HF->num_vert);for(i=0;i<HF->num_vert;i++){printf("输入点.%d的名称：",i);scanf("%s",HF->List[i].Vname);HF->List[i].head=NULL;}printf("输入图中，边的个数：");scanf("%d",&HF->num_edge);for(i=0;i<HF->num_edge;i++){E=(Edge *)malloc(sizeof(Edge));printf("\t 第%d 条边：\n起点序号：",i+1);scanf("%d",&j);//起点printf("终点序号：");scanf("%d",&E->Vnum);//终点E->next=HF->List[j].head;HF->List[j].head=E;}}void Print(Map *HF){Edge *E=NULL;int i;for(i=0;i<HF->num_vert;i++){E=HF->List[i].head;if(E==NULL)printf("\n路径从%s 出发分别到达：",HF->List[i].Vname);else{printf("\n路径从%s 出发分别到达：",HF->List[i].Vname);while(E!=NULL){printf(" %s ",HF->List[E->Vnum].Vname);E=E->next;}}}}void DFS(Map *HF,int i,int j){Edge *p;visited[i]=1;p=HF->List[i].head;while(p!=NULL){if(visited[p->Vnum]==0){if(p->Vnum==j)flag=1;if(flag==1)return;DFS(HF,p->Vnum,j);}p=p->next;}return;}void Check(Map *HF){int i,j;for(i=0;i<=HF->num_vert;i++)visited[i]=0;printf("\n测试【任意两点间是否存在路径】\n");printf("输入起点序号");scanf("%d",&i);printf("输入终点序号");scanf("%d",&j);DFS(HF,i,j);if(flag==1)printf("%s→%s成功\n",HF->List[i].Vname,HF->List[j].Vname);if(flag==0)printf("%s→%s失败\n",HF->List[i].Vname,HF->List[j].Vname); }void ClearMap(Map *HF){int i;Edge *p,*q;for(i=0;i<HF->num_vert;i++){p=HF->List[i].head;while(p!=NULL){q=p->next;free(p);p=q;}}}。
习题12(图的应用)
习题12（图的应用）一、选择题1、下面（ B ）方法可以判断出一个有向图是否有环。
A）深度优先遍历 B）拓扑排序 C）求最短路径 D）求关键路径2、在图采用邻接表存储时，求最小生成树的 Prim 算法的时间复杂度为（ C ）A）O(n) B）O(n＋e) C）O(n*n) D）O(n*n*n) 3、在用邻接表表示图时，拓扑排序算法时间复杂度为（ B ）A）O(n) B）O(n＋e) C）O(n*n) D）O(n*n*n) 4、求解最短路径的Floyd算法的时间复杂度为（ D ）A）O(n) B）O(n＋e) C）O(n*n) D）O(n*n*n) 5、下面（ A ）算法适合构造一个稠密图G的最小生成树。
A） Prim算法 B）Kruskal算法 C）Floyd算法 D）Dijkstra算法6、最小生成树指的是（ C ）A）由连通网所得到的边数最少的生成树 B）由连通网所得到的顶点相对较少的生成树C）连通网中所有生成树中权值之和为最小的树 D）连通网的极小连通子图7、关键路径是事件结点网络中（ A ）A）从源点到汇点的最长路径 B）从源点到汇点的最短路径 C）最长回路 D）最短回路8、下列关于AOE网的叙述中，不正确的是（ B ）A）关键活动不按期完成就会影响整个工程的完成时间B）任何一个关键活动提前完成，那么整个工程将会提前完成C）所有的关键活动提前完成，那么整个工程将会提前完成D）某些关键活动提前完成，那么整个工程将会提前完成9、求图中一个顶点到其它各个顶点最短路径的算法是（ C ）A）Kruskal算法 B）Prim算法 C）Dijkstra算法 D）Floyd算法10、下面关于求关键路径的说法不正确的是（ C ）A）求关键路径是以拓扑排序为基础的B）事件的最早开始时间同以该事件为尾的弧的活动最早开始时间相同C）事件的最迟开始时间为以该事件为尾的弧的活动最迟开始时间与该活动的持续时间的差D）关键活动一定位于关键路径上11、下面叙述中不正确的是（ D ）(1) 求源点到其余顶点的Dijkstra最短路径算法中弧上权不能为负的原因是在实际应用中无意义；(2) 利用Dijkstra求每一对不同顶点之间的最短路径的算法时间是O(n3)；（图用邻接矩阵表示）(3) Floyd求每对不同顶点对的算法中允许弧上的权为负，但不能有权和为负的回路。
数据结构第7章-答案
一、单选题C01、在一个图中，所有顶点的度数之和等于图的边数的倍。
A)1/2 B)1 C)2 D)4B02、在一个有向图中，所有顶点的入度之和等于所有顶点的出度之和的倍。
A)1/2 B)1 C)2 D)4B03、有8个结点的无向图最多有条边。
A)14 B)28 C)56 D)112C04、有8个结点的无向连通图最少有条边。
A)5 B)6 C)7 D)8C05、有8个结点的有向完全图有条边。
A)14 B)28 C)56 D)112B06、用邻接表表示图进行广度优先遍历时，通常是采用来实现算法的。
A)栈 B)队列 C)树 D)图A07、用邻接表表示图进行深度优先遍历时，通常是采用来实现算法的。
A)栈 B)队列 C)树 D)图A08、一个含n个顶点和e条弧的有向图以邻接矩阵表示法为存储结构，则计算该有向图中某个顶点出度的时间复杂度为。
A)O(n) B)O(e) C)O(n+e) D)O(n2)C09、已知图的邻接矩阵，根据算法思想，则从顶点0出发按深度优先遍历的结点序列是。
A)0 2 4 3 1 5 6 B)0 1 3 6 5 4 2 C)0 1 3 4 2 5 6 D)0 3 6 1 5 4 2B10、已知图的邻接矩阵同上题，根据算法，则从顶点0出发，按广度优先遍历的结点序列是。
A)0 2 4 3 6 5 1 B)0 1 2 3 4 6 5 C)0 4 2 3 1 5 6 D)0 1 3 4 2 5 6D11、已知图的邻接表如下所示，根据算法，则从顶点0出发按深度优先遍历的结点序列是。
A)0 1 3 2 B)0 2 3 1 C)0 3 2 1 D)0 1 2 3A12、已知图的邻接表如下所示，根据算法，则从顶点0出发按广度优先遍历的结点序列是。
A)0 3 2 1 B)0 1 2 3 C)0 1 3 2 D)0 3 1 2A13、图的深度优先遍历类似于二叉树的。
A)先序遍历 B)中序遍历 C)后序遍历 D)层次遍历D14、图的广度优先遍历类似于二叉树的。
(完整word版)采用连接表存储有向图,设计算法判断任意两个顶点间是否存在路径(word文档良心出品)
十一、采用连接表存储有向图，设计算法判断任意两个顶点间是否存在路径#include "stdio.h"#include "stdlib.h"#include "malloc.h"#define max 100 //顶点的最大个数#define NULL 0typedef struct st1{ //定义邻接表中结点类型int adjvex; //邻接点的位置struct st1 *nextarc; //指向下一个结点char info; //边的信息}Arcnode;typedef struct{ //定义邻接表中头结点类型char vexdata; //顶点信息Arcnode *firstarc; //指向第一个邻接结点}AdjList;typedef struct{ //定义邻接表表头AdjList vextices[max]; //存放表头结点信息int vexnum,arcnum; //有向图的顶点数和边数}AlGraph;int visited[max]; //定义深度优先搜索遍历数组，0表示未被访问过，1表示已被访问过int flag=0; //定义全局标志变量，用来确定两点间是否为通路，1表示存在，0表示不存在/////////////////////////////////////////////////////////////////////建立邻接表AlGraph *create_AdjListGraph(){int n,e,i,j,k;Arcnode *p;AlGraph *al;al=(AlGraph *)malloc(sizeof(AlGraph));printf("请输入结点数：");scanf("%d",&n);for(i=1;i<=n;i++){ //初始化表头结点数组al->vextices[i].vexdata=(char)i; //数据域存放顶点序号al->vextices[i].firstarc=NULL;}printf("请输入边数：");scanf("%d",&e);printf("请输入弧的信息：");for(i=0;i<e;i++){scanf("%d%d",&j,&k); //依次读入弧的信息，结点k为结点j的邻接点p=(Arcnode *)malloc(sizeof(Arcnode)); //申请结点空间，分配结点p->adjvex=k;p->info=' ';p->nextarc=al->vextices[j].firstarc;al->vextices[j].firstarc=p;}al->vexnum=n;al->arcnum=e;return al;}//////////////////////////////////////////////////////////////输出邻接表void print(AlGraph *alg){int i;Arcnode *p;printf("图的邻接表为：\n");for(i=1;i<=alg->vexnum;i++){printf("\t%d-",alg->vextices[i].vexdata);p=alg->vextices[i].firstarc;while(p!=NULL){printf("%d-",p->adjvex);p=p->nextarc;}printf("<\n"); //符号“<”表示空结点}}///////////////////////////////////////////////////////////释放邻接表结点空间void FreeAlGraph(AlGraph *alg){int i;Arcnode *p,*q;for(i=0;i<=alg->vexnum;i++){p=alg->vextices[i].firstarc;while(p!=NULL){q=p->nextarc;free(p);p=q;}}}////////////////////////////////////////////////////深度优先搜索遍历算法int dfs(AlGraph *alg,int i,int n){Arcnode *p;visited[i]=1; //标志已被访问p=alg->vextices[i].firstarc;while(p!=NULL){if(visited[p->adjvex]==0){if(p->adjvex==n){ flag=1; }dfs(alg,p->adjvex,n); //访问未被访问过的结点if(flag==1) return 1;}p=p->nextarc; //搜索下一个邻接点}return 0;}////////////////////////////////////////////////初始化遍历数组并进行路径搜索void dfs_trave(AlGraph *alg,int m,int n){int i;for(i=0;i<=alg->vexnum;i++)visited[i]=0; //初始化访问数组dfs(alg,m,n);}/////////////////////////////////////////////////////////////主函数void main(){int m,n; //需要判断有无通路的两个结点AlGraph *alg;alg=create_AdjListGraph();print(alg); //输出链接表do{ printf("请输入任意两个顶点（输入两个-1退出）：");scanf("%d%d",&m,&n);dfs_trave(alg,m,n);printf("\n");if(flag==1) printf("顶点%d到%d存在通路\n",m,n);else printf("顶点%d到%d不存在通路\n",m,n);flag=0;printf("\n");}while(m!=-1&&n!=-1) ;FreeAlGraph(alg); //释放结点空间}。
算法导论第十五章习题答案
算法导论第十五章习题答案算法导论第十五章习题答案算法导论是一本经典的计算机科学教材，其中第十五章涵盖了图算法的内容。
本文将针对该章节中的习题进行解答，并对其中一些问题进行深入探讨。
1. 习题15.1-1题目要求证明：对于任意的有向图G=(V,E)，如果图中不存在从节点u到节点v的路径，则在每个强连通分量中，节点u和节点v都在同一个强连通分量中。
证明：假设存在一个强连通分量C，其中节点u在C中，节点v在C'中（C'为除了C之外的其他强连通分量）。
由于不存在从u到v的路径，所以在C中不存在从u到v的路径。
但是根据强连通分量的定义，C中的任意两个节点之间都存在路径。
所以存在一条从v到u的路径。
这与C'中的节点v不在C中矛盾，所以假设不成立，节点u和节点v必定在同一个强连通分量中。
2. 习题15.2-2题目要求证明：在一个有向无环图中，存在一个拓扑排序，使得任意两个非根节点u和v，u在v之前。
证明：假设存在一个有向无环图G=(V,E)，不存在上述所要求的拓扑排序。
即对于任意的拓扑排序，存在两个非根节点u和v，u在v之后。
那么我们可以得到一条从u到v的路径。
由于图中不存在环，所以路径上的节点不会重复。
我们可以将路径上的节点按照拓扑排序的顺序排列，得到一个新的拓扑排序，使得u在v之前。
这与假设矛盾，所以原命题成立。
3. 习题15.3-3题目要求证明：在一个有向图G=(V,E)中，如果存在一条从节点u到节点v的路径，那么在图的转置G^T中，存在一条从节点v到节点u的路径。
证明：假设存在一条从节点u到节点v的路径。
那么在图的转置G^T中，边(u,v)变成了边(v,u)。
所以存在一条从节点v到节点u的路径。
因此，原命题成立。
4. 习题15.4-1题目要求：给出一个算法，判断一个有向图G=(V,E)是否是有向无环图。
算法思路：我们可以使用深度优先搜索（DFS）来判断是否存在环。
具体步骤如下：1. 对于图中的每个节点v，设置一个状态标记visited[v]为false。
计算机专业基础综合数据结构图历年真题试卷汇编7_真题无答案
计算机专业基础综合数据结构（图）历年真题试卷汇编7(总分62, 做题时间90分钟)7. 设计题1.已知连通图如下：(1)若从顶点B出发对该图进行遍历，在(1)的基础上分别给出本图的按深度优先搜索和按广度优先搜索的顶点序列；(2)写出按深度优先搜索的递归程序。
【厦门大学200l三(12％分)】SSS_TEXT_QUSTI2.设计算法以实现对无向图G的深度遍历，要求：将每一个连通分量中的顶点以一个表的形，式输出。
例如，下图的输出结果为：(1，3)(2，6，7，4，5，8)(9，10)。
注：本算法中可以调用以下几个函数：firstadj(g，1，)——返回图g中顶点v的第一个邻接点的号码，若不存在，则返回0。
nextadj(g，v，w)——返回图g中顶点v的邻接点中处于w之后的邻接点的号码，若不存在，则返回0。
nodes(g)——返回图g中的顶点数。
【合肥工业大学2000五、4(8分)】SSS_TEXT_QUSTI3.请设计一个图的抽象数据类型(只需要用类Pascal或类C／C++语言给出其主要功能函数或过程的接口说明，不需要指定存储结构，也不需要写出函数或过程的实现方法)，利用抽象数据类型所提供的函数或过程编写图的广度优先周游算法。
算法不应该涉及具体的存储结构，也不允许不通过函数或过程而直接引用图结构的数据成员，抽象数据类型和算法都应该加足够的注释。
【北京大学1999二、1(10分)】SSS_TEXT_QUSTI4.设计算法以判断给定的无向图G中是否存在一条以网为起点的包含所有顶点的简单路径，若存在，返回TRUE，否则，返回FALSE(注：本算法中可以调用以下几个函数：FIRSTADJ(G，V)——返回图G中顶点V的第一个邻接点的号码，若不存在，则返回0；NEXTADJ(G，W)——返回图G中顶点V的邻接点中处于W之后的邻接点的号码，若不存在，则返回0；NODES(G)——返回图G中的顶点数)。
【合肥工业大学1999五、5(8分)】SSS_TEXT_QUSTI5.已有邻接表表示的有向图，请编程判断从第u顶点至第v顶点是否有简单路径，若有，则印出该路径上的顶点。
判别无向图中任意两个顶点之间是否存在长度为K的简单路径。(c语言版)
C语言代码：#include"stdio.h"#include"stdlib.h"#define Max 15#define list_size 20typedef struct Graph //邻接矩阵{char point[Max];int line[Max][Max];int linenum,pointnum;}Graph;typedef struct Node //顺序表中元素{char c;struct key *next;}Node;typedef struct key //链表节点{char c;int leng;struct key *next;}key;typedef struct //顺序表{Node *top;int length;int size;}Sqlist;int local(Sqlist l,char v){int i,j=-1;for(i=0;i<l.length;i++)if(l.top[i].c==v)j=i;return j;}Graph Creat(Graph g){int i,j;printf("请输入图的点数：");scanf("%d",&g.pointnum);printf("\n————顶点————\n"); getchar();printf("输入一个图中的顶点：");for(i=0;i<g.pointnum;i++){if(i)printf("继续输入一个顶点:");scanf("%c",&g.point[i]);getchar();}for(i=0;i<g.pointnum;i++)for(j=0;j<g.pointnum;j++)g.line[i][j]=0;printf("\n————边————\n");printf("\n请输入邻接矩阵：(带权值的)\n\n");for(i=0;i<g.pointnum;i++){for(j=0;j<g.pointnum;j++)scanf("%d",&g.line[i][j]);getchar();return g;}Sqlist Init(Sqlist l){l.top=(Node*)malloc(list_size*sizeof(Node));if(!l.top)exit(0);l.length=0;l.size=list_size;return l;}Sqlist Creat_list(Sqlist l,Graph g){int i,j,flage=0;Node *newbase;key *element,*first;for(i=0;i<g.pointnum;i++){if(l.length>=l.size){newbase=(Node*)realloc(l.top,(l.size+list_size)*sizeof(Node));if(!newbase)exit(0);l.top=newbase;l.size+=list_size;}l.top[i].c=g.point[i];l.length++;}for(i=0;i<g.pointnum;i++){flage=0;l.top[i].next=0;for(j=0;j<g.pointnum;j++){if(g.line[i][j]!=0){flage++;if(flage==1){element=(key*)malloc(sizeof(key));element->next=0;element->c=g.point[j];element->leng=g.line[i][j];l.top[i].next=element;first=element;}else{element=(key*)malloc(sizeof(key));element->next=0;element->c=g.point[j];element->leng=g.line[i][j];first->next=element;first=element;}}}}return l;}void display(Sqlist l){int i;key *f;Node *e;printf("\n——————邻接表——————\n");for(i=0;i<l.length;i++){if(l.top[i].next!=0){printf("%c->",l.top[i].c);f=l.top[i].next;while(f->next){printf("%c,%d->",f->c,f->leng);f=f->next;}printf("%c,%d",f->c,f->leng);printf("\n");}elseprintf("%c\n",l.top[i].c);}printf("\n");}char path[Max]={0};int visit[Max]={0};int flage=0;int path_length;void print_path(char path[]){int i=0;while(path[i+1]){printf("%c->",path[i]);i++;}printf("%c",path[i]);printf("\n");}void find_path(Sqlist l,char v,char w,int k,int j,key* p) {char aim;int m,flage1=0;while(p){aim=p->c;m=local(l,aim);if(!visit[m]){flage=1;k-=p->leng;path[j]=aim;visit[m]=1;if(aim==w){if(k==0){printf("两顶点之间存在长度为%d的路径:",path_length);print_path(path);}else{printf("两顶点之间不存在长度为%d的路径，但存在可达路径",path_length);print_path(path);}flage=1;}elsefind_path(l,aim,w,k,j+1,l.top[m].next);}if(flage==1){k+=p->leng;visit[m]=0;}p=p->next;}}void main(){Graph g;Sqlist list;武汉理工大学《数据结构》课程设计char v,w;int k,i=0,j;key* point;g=Creat(g);list=Init(list);list=Creat_list(list,g);display(list);getchar();printf("请输入任意两个顶点:");scanf("%c,%c",&v,&w);printf("请输入路径长度：");scanf("%d",&k);path_length=k;j=local(list,v);path[0]=v;visit[j]=1;find_path(list,v,w,k,i+1,list.top[j].next);if(flage==0)printf("两顶点之间不存在路径！\n");}11。
有向图中任意两点之间的最短路径
有向图中任意两点之间的最短路径一.问题求出有向图中任意两点之间的最短路径并打印结果二.语言环境C++三.问题分析要解决有向图中任意两点之间的最短路径问题首先应解决的问题是1.从源点到其余各点的最短路径问题2.每一对定点之间的最短路径问题对于”○1从源点到其余各点的最短路径问题”有经典算法-------“迪杰斯特拉算法”.该算法的思想是:(1). 如图（A）图（A ）路径长度最短的最短路径的特点：<V0,V2,V3,V4>13 <V0,V2>2113长度最短路径<V0,V1><V0,V2,V3><V0,V2,V3,V4,V5><V0,V1,V6>81920在这条路径上，必定只含一条弧，并且这条弧的权值最小。
下一条路径长度次短的最短路径的特点：它只可能有两种情况：或者是直接从源点到该点(只含一条弧)；或者是从源点经过顶点v1，再到达该顶点(由两条弧组成)。
再下一条路径长度次短的最短路径的特点:它可能有三种情况：或者是直接从源点到该点(只含一条弧)；或者是从源点经过顶点v1，再到达该顶点(由两条弧组成)；或者是从源点经过顶点v2，再到达该顶点。
其余最短路径的特点：它或者是直接从源点到该点(只含一条弧)；或者是从源点经过已求得最短路径的顶点，再到达该顶点。
由以上特点可知：假设S为已求得最短路径的终点的集合，则可证明：下一条最短路径（设其终点为x）或者是弧（v,x)，或者是中间只经过S中的顶点而最后到达终点x的路径。
假设此路径上有一个顶点不在S中，则说明存在一条终点不在S中，而长度比此路径短的路径。
但这是不可能的，因为我们是按路径长度递增的次序来产生最短路径的，故长度比此路径短的所有路径均已产生，他们的终点必定在S中，即假设不成立。
设置辅助数组Dist，其中每个分量Dist[k] 表示当前所求得的从源点到其余各顶点k 的最短路径。
一般情况下，Dist[k] = <源点到顶点 k 的弧上的权值>或者 = <源点到S中某顶点j的路径长度>+ <顶点j到顶点 k 的弧上的权值>。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
十一、采用连接表存储有向图，设计算法判断任意两个顶点间是否存在路径#include ""
#include ""
#include ""
#define max 100 exdata=(char)i; irstarc=NULL;
}
printf("请输入边数：");
scanf("%d",&e);
printf("请输入弧的信息：");
for(i=0;i<e;i++){
scanf("%d%d",&j,&k); irstarc;
al->vextices[j].firstarc=p;
}
al->vexnum=n;
al->arcnum=e;
return al;
}
exdata);
p=alg->vextices[i].firstarc;
while(p!=NULL){
printf("%d-",p->adjvex);
p=p->nextarc;
}
printf("<\n"); irstarc;
while(p!=NULL){
q=p->nextarc;
free(p);
p=q;
}
}
}
irstarc;
while(p!=NULL){
if(visited[p->adjvex]==0){
if(p->adjvex==n){ flag=1; }
dfs(alg,p->adjvex,n); //访问未被访问过的结点
if(flag==1) return 1;
}
p=p->nextarc; //搜索下一个邻接点
}
return 0;
}
////////////////////////////////////////////////初始化遍历数组并进行路径搜索void dfs_trave(AlGraph *alg,int m,int n){
int i;
for(i=0;i<=alg->vexnum;i++)
visited[i]=0; //初始化访问数组
dfs(alg,m,n);
}
/////////////////////////////////////////////////////////////主函数
void main(){
int m,n; //需要判断有无通路的两个结点
AlGraph *alg;
alg=create_AdjListGraph();
print(alg); //输出链接表
do{ printf("请输入任意两个顶点（输入两个-1退出）：");
scanf("%d%d",&m,&n);
dfs_trave(alg,m,n);
printf("\n");
if(flag==1) printf("顶点%d到%d存在通路\n",m,n);
else printf("顶点%d到%d不存在通路\n",m,n);
flag=0;
printf("\n");
}while(m!=-1&&n!=-1) ;
FreeAlGraph(alg); //释放结点空间
}。