算法程序设计实验报告
算法实验报告结果分析
一、实验背景随着计算机科学技术的不断发展，算法作为计算机科学的核心内容之一，其重要性日益凸显。
为了验证和评估不同算法的性能，我们进行了一系列算法实验，通过对比分析实验结果，以期为后续算法研究和优化提供参考。
二、实验方法本次实验选取了三种常见的算法：快速排序、归并排序和插入排序，分别对随机生成的数据集进行排序操作。
实验数据集的大小分为10000、20000、30000、40000和50000五个级别，以验证算法在不同数据量下的性能表现。
实验过程中，我们使用Python编程语言实现三种算法，并记录每种算法的运行时间。
同时，为了确保实验结果的准确性，我们对每种算法进行了多次运行，并取平均值作为最终结果。
三、实验结果1. 快速排序快速排序是一种高效的排序算法，其平均时间复杂度为O(nlogn)。
从实验结果来看，快速排序在所有数据量级别下均表现出较好的性能。
在数据量较小的10000和20000级别，快速排序的运行时间分别为0.05秒和0.1秒；而在数据量较大的40000和50000级别，运行时间分别为0.8秒和1.2秒。
总体来看，快速排序在各个数据量级别下的运行时间均保持在较低水平。
2. 归并排序归并排序是一种稳定的排序算法，其时间复杂度也为O(nlogn)。
实验结果显示，归并排序在数据量较小的10000和20000级别下的运行时间分别为0.15秒和0.25秒，而在数据量较大的40000和50000级别，运行时间分别为1.5秒和2.5秒。
与快速排序相比，归并排序在数据量较小的情况下性能稍逊一筹，但在数据量较大时，其运行时间仍然保持在较低水平。
3. 插入排序插入排序是一种简单易实现的排序算法，但其时间复杂度为O(n^2)。
实验结果显示，插入排序在数据量较小的10000和20000级别下的运行时间分别为0.3秒和0.6秒，而在数据量较大的40000和50000级别，运行时间分别为8秒和15秒。
可以看出，随着数据量的增加，插入排序的性能明显下降。
算法实验报告
算法实验报告算法实验报告引言：算法是计算机科学的核心内容之一，它是解决问题的方法和步骤的描述。
算法的设计和分析是计算机科学与工程中的重要研究方向之一。
本实验旨在通过对算法的实际应用和实验验证，深入理解算法的性能和效果。
实验一：排序算法的比较在本实验中，我们将比较三种常见的排序算法：冒泡排序、插入排序和快速排序。
我们将通过对不同规模的随机数组进行排序，并记录每种算法所需的时间和比较次数，以评估它们的性能。
实验结果显示，快速排序是最快的排序算法，其时间复杂度为O(nlogn)，比较次数也相对较少。
插入排序的时间复杂度为O(n^2)，比较次数较多，但对于小规模的数组排序效果较好。
而冒泡排序的时间复杂度也为O(n^2)，但比较次数更多，效率相对较低。
实验二：图的最短路径算法在图的最短路径问题中，我们将比较Dijkstra算法和Floyd-Warshall算法的效率和准确性。
我们将使用一个带权有向图，并计算从一个顶点到其他所有顶点的最短路径。
实验结果表明，Dijkstra算法适用于单源最短路径问题，其时间复杂度为O(V^2)，其中V为顶点数。
而Floyd-Warshall算法适用于多源最短路径问题，其时间复杂度为O(V^3)。
两种算法在准确性上没有明显差异，但在处理大规模图时，Floyd-Warshall算法的效率较低。
实验三：动态规划算法动态规划是一种通过将问题分解成子问题并记录子问题的解来解决复杂问题的方法。
在本实验中，我们将比较两种动态规划算法：0-1背包问题和最长公共子序列问题。
实验结果显示，0-1背包问题的动态规划算法可以有效地找到最优解，其时间复杂度为O(nW)，其中n为物品个数，W为背包容量。
最长公共子序列问题的动态规划算法可以找到两个序列的最长公共子序列，其时间复杂度为O(mn)，其中m和n分别为两个序列的长度。
结论：通过本次实验，我们对不同算法的性能和效果有了更深入的了解。
排序算法中，快速排序是最快且效率最高的；在图的最短路径问题中，Dijkstra算法和Floyd-Warshall算法分别适用于不同的场景；动态规划算法可以解决复杂的问题，并找到最优解。
算法分析与设计实验报告--回溯法
算法分析与设计实验报告--回溯法实验目的：通过本次实验，掌握回溯法的基本原理和应用，能够设计出回溯法算法解决实际问题。
实验内容：1.回溯法概述回溯法全称“试探回溯法”，又称“逐步退化法”。
它是一种通过不断试图寻找问题的解，直到找到解或者穷尽所有可能的解空间技术。
回溯法的基本思路是从问题的某一个初始状态开始，搜索可行解步骤，一旦发现不满足求解条件的解就回溯到上一步，重新进行搜索，直到找到解或者所有可能的解空间已经搜索完毕。
2.回溯法的基本应用回溯法可用于求解许多 NP 问题，如 0/1 背包问题、八皇后问题、旅行商问题等。
它通常分为两种类型：一种是通过枚举所有可能的解空间来寻找解；另一种则是通过剪枝操作将搜索空间减少到若干种情况，大大减少了搜索时间。
3.回溯法的解题思路（1）问题分析：首先需要对问题进行分析，确定可行解空间和搜索策略；（2）状态表示：将问题的每一种状况表示成一个状态；（3）搜索策略：确定解空间的搜索顺序；（4）搜索过程：通过逐步试探，不断扩大搜索范围，更新当前状态；（5）终止条件：在搜索过程中，如果找到了满足要求的解，或者所有的可行解空间都已搜索完毕，就结束搜索。
4.八皇后问题八皇后问题是指在一个 8x8 的棋盘上放置八个皇后，使得任意两个皇后都不在同一行、同一列或同一对角线上。
通过回溯法可以求解出所有的可能解。
实验过程：回溯法的实现关键在于搜索空间的剪枝，避免搜索无用的解；因此，对于八皇后问题，需要建立一个二维数组来存放棋盘状态，以及一个一维数组来存放每行放置的皇后位置。
从第一行开始搜索，按照列的顺序依次判断当前的空位是否可以放置皇后，如果可以，则在相应的位置标记皇后，并递归到下一行；如果不能，则回溯到上一行，重新搜索。
当搜索到第八行时，获取一组解并返回。
代码实现：```pythondef is_valid(board, row, col):for i in range(row):if board[i] == col or abs(board[i] - col) == abs(i - row):return Falsereturn True实验结果：当 n=4 时，求得的所有可行解如下：```[[1, 3, 0, 2],[2, 0, 3, 1]]```本次实验通过实现回溯法求解八皇后问题，掌握了回溯法的基本原理和应用，并对回溯法的核心思想进行了深入理解。
算法课设实验报告(3篇)
第1篇一、实验背景与目的随着计算机技术的飞速发展，算法在计算机科学中扮演着至关重要的角色。
为了加深对算法设计与分析的理解，提高实际应用能力，本实验课程设计旨在通过实际操作，让学生掌握算法设计与分析的基本方法，学会运用所学知识解决实际问题。
二、实验内容与步骤本次实验共分为三个部分，分别为排序算法、贪心算法和动态规划算法的设计与实现。
1. 排序算法（1）实验目的：熟悉常见的排序算法，理解其原理，比较其优缺点，并实现至少三种排序算法。
（2）实验内容：- 实现冒泡排序、快速排序和归并排序三种算法。
- 对每种算法进行时间复杂度和空间复杂度的分析。
- 编写测试程序，对算法进行性能测试，比较不同算法的优劣。
（3）实验步骤：- 分析冒泡排序、快速排序和归并排序的原理。
- 编写三种排序算法的代码。
- 分析代码的时间复杂度和空间复杂度。
- 编写测试程序，生成随机测试数据，测试三种算法的性能。
- 比较三种算法的运行时间和内存占用。
2. 贪心算法（1）实验目的：理解贪心算法的基本思想，掌握贪心算法的解题步骤，并实现一个贪心算法问题。
（2）实验内容：- 实现一个贪心算法问题，如活动选择问题。
- 分析贪心算法的正确性，并证明其最优性。
（3）实验步骤：- 分析活动选择问题的贪心策略。
- 编写贪心算法的代码。
- 分析贪心算法的正确性，并证明其最优性。
- 编写测试程序，验证贪心算法的正确性。
3. 动态规划算法（1）实验目的：理解动态规划算法的基本思想，掌握动态规划算法的解题步骤，并实现一个动态规划算法问题。
（2）实验内容：- 实现一个动态规划算法问题，如背包问题。
- 分析动态规划算法的正确性，并证明其最优性。
（3）实验步骤：- 分析背包问题的动态规划策略。
- 编写动态规划算法的代码。
- 分析动态规划算法的正确性，并证明其最优性。
- 编写测试程序，验证动态规划算法的正确性。
三、实验结果与分析1. 排序算法实验结果：- 冒泡排序：时间复杂度O(n^2)，空间复杂度O(1)。
算法实验报告范文
算法实验报告范文《算法设计与分析》实验报告班级姓名学号年月日目录实验一二分查找程序实现…………………………………………………………………03页实验二棋盘覆盖问题（分治法）.…………………………………………………………08页实验三0-1背包问题的动态规划算法设计……………………………………………….11页实验四背包问题的贪心算法………………………………………………………………14页实验五最小重量机器设计问题（回溯法）………………………………………………17页实验六最小重量机器设计问题（分支限界法）…………………………………………20页指导教师对实验报告的评语成绩：指导教师签字：年月日2实验一：二分查找程序实现一、实验时间：2022年10月8日，星期二，第一、二节地点：J13#328二、实验目的及要求目的：1、用c/c++语言实现二分搜索算法。
2、通过随机产生有序表的方法，测出在平均意义下算法比较次数随问题规模的变化曲线，并作图。
三、实验环境平台：Win732位操作系统开发工具：Codeblock10.05四、实验内容对已经排好序的n个元素a[0：n-1]，现在要在这n个元素中找出一特定元素某。
五、算法描述及实验步骤算法描述：折半查找法也称为二分查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(logn)完成搜索任务。
它的基本思想是，将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的某作比较，如果某=a[n/2]则找到某，算法终止。
如果某a[n/2]，则我们只要在数组a的右半部继续搜索某。
二分搜索法的应用极其广泛，而且它的思想易于理解。
确定算法复杂度基本步骤：1、首先设定问题规模n；2、随即产生递增数列；3、在n个有序数中随机取一个作为待查找量，搜索之；4、记录查找过程中的比较次数，再次生成新的有序表并查找，记录查找次数，每个数组重复10次；5、改变问题规模n重复上述步骤2~4，n取100、200……1000；6、依实验数据作图，并与理论图作比较；7、二分搜索算法平均查找次数：问题规模为n时，平均查找次数为：A(n)=Int(logn)+1/2//Int()函数为向下取整3即二分搜索算法对于含有n个数据的有序表L平均作了约Int(logn)+1/2次的查找操作。
数字整型算法实验报告(3篇)
第1篇一、实验目的1. 理解数字整型算法的基本原理和方法。
2. 掌握常用的数字整型算法，如整数乘法、除法、取余、排序等。
3. 培养算法设计与分析能力，提高编程实践能力。
二、实验内容1. 整数乘法算法2. 整数除法算法3. 整数取余算法4. 快速排序算法5. 堆排序算法三、实验原理1. 整数乘法算法：利用位运算，将两个整数进行逐位相乘，然后求和得到最终结果。
2. 整数除法算法：利用长除法原理，将除数逐步减去被除数的倍数，直到余数小于除数，此时商即为最终结果。
3. 整数取余算法：与整数除法类似，只需取除法的余数即可。
4. 快速排序算法：采用分治策略，将待排序的序列分为两部分，一部分大于等于基准值，另一部分小于基准值，然后递归地对这两部分进行排序。
5. 堆排序算法：利用堆这种数据结构，通过调整堆的性质来实现排序。
四、实验步骤1. 整数乘法算法实现```cint multiply(int a, int b) {int result = 0;while (b != 0) {if (b & 1) {result += a;}a <<= 1;b >>= 1;}return result;}```2. 整数除法算法实现```cint divide(int a, int b) {if (a == 0) return 0;int sign = (a > 0) ^ (b > 0) ? -1 : 1;long long dividend = abs((long long)a), divisor = abs((long long)b); long long quotient = 0;while (dividend >= divisor) {dividend -= divisor;quotient++;}return sign (int)quotient;}```3. 整数取余算法实现```cint remainder(int a, int b) {return a % b;}```4. 快速排序算法实现```cvoid quickSort(int arr[], int low, int high) { if (low < high) {int pivot = partition(arr, low, high); quickSort(arr, low, pivot - 1);quickSort(arr, pivot + 1, high);}}int partition(int arr[], int low, int high) { int pivot = arr[high];int i = low - 1;for (int j = low; j < high; j++) {if (arr[j] <= pivot) {i++;swap(&arr[i], &arr[j]);}}swap(&arr[i + 1], &arr[high]);return i + 1;}```5. 堆排序算法实现```cvoid heapify(int arr[], int n, int i) {int largest = i;int left = 2 i + 1;int right = 2 i + 2;if (left < n && arr[left] > arr[largest]) { largest = left;}if (right < n && arr[right] > arr[largest]) { largest = right;}if (largest != i) {swap(&arr[i], &arr[largest]);heapify(arr, n, largest);}}void heapSort(int arr[], int n) {for (int i = n / 2 - 1; i >= 0; i--) {heapify(arr, n, i);}for (int i = n - 1; i > 0; i--) {swap(&arr[0], &arr[i]);heapify(arr, i, 0);}}```五、实验结果与分析1. 整数乘法算法：通过位运算实现，效率较高，适用于大整数乘法运算。
算法分析与设计实验报告合并排序快速排序
算法分析与设计实验报告：合并排序与快速排序一、引言算法是计算机科学中非常重要的一部分，它涉及到解决问题的方法和步骤。
合并排序和快速排序是两种经典而常用的排序算法。
本文将对这两种排序算法进行分析和设计实验，通过对比它们的性能和效率，以期得出最优算法。
二、合并排序合并排序是一种分治算法，它将原始数组不断分解为更小的数组，直到最后细分为单个元素。
然后，再将这些单个元素两两合并，形成一个有序数组。
合并排序的核心操作是合并两个有序的数组。
1. 算法步骤（1）将原始数组分解为更小的子数组，直到每个子数组只有一个元素；（2）两两合并相邻的子数组，同时进行排序，生成新的有序数组；（3）重复步骤（2），直到生成最终的有序数组。
2. 算法性能合并排序的最优时间复杂度为O(nlogn)，其中n为待排序数组的长度。
无论最好情况还是最坏情况，合并排序的复杂度都相同。
合并排序需要额外的存储空间来存储临时数组，所以空间复杂度为O(n)。
三、快速排序快速排序也是一种分治算法，它将原始数组根据一个主元（pivot）分成两个子数组，一个子数组的元素都小于主元，另一个子数组的元素都大于主元。
然后，递归地对这两个子数组进行排序，最后得到有序数组。
快速排序的核心操作是划分。
1. 算法步骤（1）选择一个主元（pivot），可以是随机选择或者固定选择第一个元素；（2）将原始数组根据主元划分为两个子数组，一个子数组的元素都小于主元，另一个子数组的元素都大于主元；（3）递归地对这两个子数组进行快速排序；（4）重复步骤（2）和（3），直到每个子数组只有一个元素，即得到最终的有序数组。
2. 算法性能快速排序的平均时间复杂度为O(nlogn)，其中n为待排序数组的长度。
最坏情况下，当每次选择的主元都是最小或最大元素时，时间复杂度为O(n^2)。
快速排序是原地排序，不需要额外的存储空间，所以空间复杂度为O(1)。
四、实验设计为了验证合并排序和快速排序的性能和效率，我们设计以下实验：1. 实验目的：比较合并排序和快速排序的时间复杂度和空间复杂度。
程序设计与算法分析综合实验报告
程序设计与算法分析综合实验报告
1. 实验目的
该实验的目的是通过设计和实现一个程序来分析算法的运行时间和空间复杂度，以便更好地理解算法的性能和优化方法。
2. 实验方法
在实验中，我们选择了一种特定的算法，并使用不同规模的数据进行测试。
我们记录了算法在处理不同规模数据时的运行时间和占用的内存空间，并进行了分析和总结。
3. 实验结果
通过实验，我们得出了以下结论：
- 算法的运行时间随着输入规模的增加而增加，但增长的速度并不是线性的，可能存在其他因素影响。
- 算法在不同规模的数据上，占用的内存空间并不一致，可以通过优化算法来减少内存使用量。
具体的实验结果请参见附录。
4. 实验分析
在实验分析中，我们对算法的性能进行了深入研究：
- 我们分析了算法运行时间与输入规模的关系，并观察到了一些规律和趋势。
- 我们比较了不同规模数据上的内存使用情况，并探讨了一些可能的优化方法。
5. 实验总结
通过本次实验，我们深入了解了程序设计与算法分析，掌握了一些基本的算法分析方法和技巧。
同时，我们也认识到了算法的优化对程序性能的影响，为以后的程序设计和优化提供了启示。
6. 附录
实验数据
注：以上数据仅为示例，实际数据可根据实际实验进行填充。
参考资料
- 《算法分析与设计》。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
程序设计》课程设计姓名：王学号：20100034班级：软件工程00 班指导教师：王会青成绩：2010年 6 月实验一.构造可以使n 个城市连接的最小生成树专业：__软件工程___ 班级：__软件姓名：_王___ 学号：_20100034完成日期：_2010/6/26 ________一、【问题描述】给定一个地区的n 个城市间的距离网，用Prim 算法或Kruskal 算法建立最小生成树，并计算得到的最小生成树的代价。
1 城市间的道路网采用邻接矩阵表示，邻接矩阵的存储结构定义采用课本中给出的定义，若两个城市之间不存在道路，则将相应边的权值设为自己定义的无穷大值。
2 显示出城市间道路网的邻接矩阵。
3 最小生成树中包括的边及其权值，并显示得到的最小生成树的总代价。
4 输入城市数、道路数→输入城市名→输入道路信息→执行Kruskal 算法→执行Prim 算法→输出最小生成树二、【问题分析】1. 抽象数据类型结构体数组的定义：#ifnd ef ADJACENCYMATRIXED// 防止该头文件被重复引用#define ADJACENCYMATRIXED // 而引起的数据重复定义#define INFINITY 32767 // 最大值∞#define MAX_VERTEX_NUM 20 // 最大顶点个数typedef int VRType; // 权值，即边的值typedef char InfoType; // 附加信息的类型，后面使用时会定义成一个指针typedef char VertexType[MAX_VERTEX_NUM]; // 顶点类型typedef enum {DG=1, DN, UDG, UDN} GraphKind; //{ 有向图，有向网，无向图，无向网}typedef struct ArcCell{VRType adj; //VRType 是顶点关系类型。
对无权图，用1 或0 表示相邻否；对带权图，则为权值类型。
InfoType*info; // 该弧关系信息的指针}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];typedef struct{VertexType vexs[MAX_VERTEX_NUM]; // 顶点向量 AdjMatrixarcs; // 邻接矩阵 int vexnum, arcnum;GraphKind kind;}MGraph;typedef struct{ VertexType adjvex; VRType lowcost;}closedge[MAX_VERTEX_NUM];#endif // 结束 if2 程序模块MGraph G;// 网 G ，唯一的全局变量 int main(int argc, char * argv[]); // 主函数Status LocateVex(MGraph G, VertexType v); // 判断城市 v 在网 G 中的位置 Status CreateUDN(MGraph &G);// 创建网 G 的邻接矩阵 void DisplayNet(MGraph G); // 以邻接矩阵的形式显示网 G void MiniSpanTree_KRUSKAL(MGraph G); // 最小生成树的 Kruskal 算法 void MiniSpanTree_PRIM(MGraph G, VertexType u); // 最小生成树的 Prim 算法 Status Minimum(closedge closeEdge, int n);//Prim 算法中求下一个城市的函数 void DeleteInfo(MGraph &G); // 释放堆内存上动态申请的空间 3. 流程图创建用邻接矩阵表示的城市道路网输入城市数 G.vexnum 、 道路数 G.arcnum输入城市名 G.vexs[i]// 图的当前顶点数和弧数 // 图的种类标志 // 普里姆算法辅助数组的定义输入表示道路的两个城市及道路值G.arcs[i][j].adj返回OKPrim 算法化辅助数组closeEdgefor (i=1; i<G.vexnum; ++i)求下一个城市k = Minimum(closeEdge,G.vexnum)输出找到的道路标记城市，避免重复输出总耗费4.数据类型定义为了用邻接矩阵表示图G ，先是定义二维数组的每一个元素含道路值然后在图的定义中定义一个此二维数组的结构成员。
并且在图中还定义一个用来存放城市的一维数组及int 型的城市数级道路数。
用二维数组的两个下标表示道路，这两个下标又在一位数组中对应两个城市。
这样就建立起了一个城市到城市之间的道路网。
4. 程序主要模块说明：该程序共含5 个模块，本人负责其中2 个模块构造：***************LocateVex(MGraph G, VertexTypev)**************** Status LocateVex(MGraph G, VertexType v);{while (strcmp(G.vexs[i], v)) {i++;}返回i；}**************** CreateUDN *************************{输入城市数、道路数；for （i=0; i< 城市数; ++i）输入城市名；for （i=0; i< 城市数; ++i）for（j=0; j< 城市数; ++j）初始化邻接矩阵：道路值= INFINITY;for （i=0; i< 城市数; ++i）for（j=0; j< 城市数; ++j）输入两个城市表示道路，输入道路值；}PRIM 算法MiniSpanTree_PRIM*********void MiniSpanTree_PRIM(MGraph G, VertexType u) {定义辅助数组：closedge closeEdge; 初始化：strcpy(closeEdge[j].adjvex, u);closeEdge[j].lowcost = G.arcs[k][j].adj;for (i=1; i<G.vexnum; ++i){在其余G.vexnum-1 个城市中找到离辅助数组中标记的道路最小值；显示找到的道路；标记新找到的城市；}}********************** Minimum*****************Status Minimum(closedge closeEdge, int n){在辅助数组中找到道路值最小的道路的两点城市：if ((closeEdge[i].lowcost != 0) && (minTemp > closeEdge[i].lowcost)) 返回该城市在G 中的位置}三、【功能实现】#include <iostream.h>#include <stdio.h>#include <string.h>#include <windows.h>#include "TypeDefine.h"#include "AdjacencyMatrix.h"#include "InitializeFunction.h"#include "MiniSpanTree_KRUSKAL.h"#include "MiniSpanTree_PRIM.h"#include "DisplayNet.h" #include "DeleteInfo.h"MGraph G; // 全局变量Gint main(int argc, char * argv[]);// 主函数Status LocateVex(MGraph G, VertexType v);// 判断城市v 在网G 中的位置Status CreateUDN(MGraph &G);// 创建网G 的邻接矩阵void DisplayNet(MGraph G);// 以邻接矩阵的形式显示网Gvoid MiniSpanTree_KRUSKAL(MGraph G);//最小生成树的Kruskal 算法void MiniSpanTree_PRIM(MGraph G, VertexType u);// 最小生成树的Prim 算法Status Minimum(closedge closeEdge, int n);//Prim 算法中求下一个城市的函数void DeleteInfo(MGraph &G);// 释放堆内存上动态申请的空间int main(int argc, char * argv[]){CreateGraph(G);DisplayNet(G);MiniSpanTree_KRUSKAL(G);MiniSpanTree_PRIM(G, G.vexs[0]);DeleteInfo(G);cout<<endl<<endl;system("pause");return 0;}//intializeFunction.hStatus CreateDG(MGraph &G){return 0;};Status CreateDN(MGraph &G){return 0;};Status CreateUDG(MGraph &G){return 0;};Status CreateUDN(MGraph &G);Status LocateVex(MGraph G, VertexType v){// 判断输入的顶点v 在G 中的位置。
// 根据顶点的类型，可重载此函数。
目前为char int i=0;while (strcmp(G.vexs[i], v)) {i++;}return i;}Status CreateGraph(MGraph &G){// 采用数组(邻接矩阵)表示法，构造图G.G.kind = UDN; // 默认构造无向网/* printf("+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");printf("|1: 有向图2:无向图3:有向网4:无向网\n"); printf("| 请选择:[ ]\b\b");scanf("%d", &G.kind);printf("+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");*/switch (G.kind){case DG: return CreateDG(G); // 构造有向图G case DN: return CreateDN(G);// 构造有向网G case UDG: return CreateUDG(G); // 构造无向图G case UDN: return CreateUDN(G); // 构造无向网G default : return ERROR;}}//CreateGraphStatus CreateUDN （MGraph &G ）{// 采用数组（邻接矩阵）表示法，构造图 G.int i, j, k;VertexType v1, v2;VRType w;printf （" 构造可以使 N 个城市连接的最小生成树 printf （" 请输入城市数、道路数 （至少 6 个城市， 10 条道路 ）："）; cin>>G.vexnum>>G.arcnum; for (i=0; i<G.vexnum; ++i)cin>>G.vexs[i];}for (i=0; i<G.vexnum; ++i) {for (j=0; j<G.vexnum; ++j){G.arcs[i][j].adj = INFINITY;// G.arcs[i][j].info = NULL;}}printf （" 请输入一条道路连接的两个城市名及权值 :\n"）; for (k=0; k<G.arcnum; ++k)printf(" 共%3d 条道路，第 %3d 条道路：", G.arcnum,k+1);printf （" 请输入第 %d 个城市名（共 %d 个):", i+1, G.vexnum); \n"); // 构造顶点向量// 初始化邻接矩阵 // 构造邻接矩阵cin>>v1>>v2>>w; // 输入一条边依附的顶点及权值i = LocateVex(G, v1); // 确定v1、v2 在G 中的位置j = LocateVex(G, v2);G.arcs[i][j].adj = w; // 弧<v1,v2>的权值G.arcs[j][i] = G.arcs[i][j]; // 置<v1,v2>的对称弧<v2,v1>return OK;}//CreateUDN//MiniSpan Tree PRIM.hStatus Minimum(closedge closeEdge, int n){int i, flag, minTemp = INFINITY;for (i=0; i<n; ++i){if ((closeEdge[i].lowcost != 0) && (minTemp > closeEdge[i].lowcost)){minTemp = closeEdge[i].lowcost;flag = i;return flag;void MiniSpanTree_PRIM(MGraph G, VertexType u)// 用普里姆算法从第u 个顶点出发构造网G 的最小生成树T，输出T 的各条边。