北邮数据结构实验第二次实验图
北邮世纪学院数据结构实验文档
北邮世纪学院数据结构实验文档实验一：<编程文档><注意：生成日期和修改日期不需要填写，系统自动填写><生成新文档的时候，需要修改页眉中标注的部分，不需要修改页脚><修改文档之后，请刷新一下目录，由于我们的文档一般比较长，还是有目录比较好。
> <文件名起名原则：_文档名称>修订历史记录本文档简要说明。
目录修订历史记录 (1)1问题描述 (3)2主函数流程MAIN() (3)2.1功能 (3)2.2性能 (3)2.3输人项 (3)2.4输出项 (3)2.5算法 (3)2.6流程逻辑 (3)2.7注释设计 (4)2.8限制条件 (4)3函数1设计说明 (4)4源程序 (4)5测试报告 (5)5.1案例一：测试MAIN() (5)5.2案例二：测试子函数 (5)5.3尚未解决的问题 (5)6心得体会 (5)7分工及签名 (5)1问题描述给出对该程序的简要描述(作业题)，主要说明安排设计本程序的目的意义。
2主函数流程main()2.1功能说明该程序应具有的功能，可采用IPO图（即输入一处理一输出图）的形式。
2.2性能说明对该程序的全部性能要求，包括对精度、灵活性和时间特性的要求。
2.3输人项给出对每一个输入项的特性，包括名称、标识、数据的类型和格式、数据值的有效范围、输入的方式。
数量和频度、输入媒体、输入数据的来源和安全保密条件等等。
2.4输出项给出对每一个输出项的特性，包括名称、标识、数据的类型和格式，数据值的有效范围，输出的形式、数量和频度，输出媒体、对输出图形及符号的说明、安全保密条件等等。
2.5算法详细说明本程序所选用的算法，具体的计算公式和计算步骤。
2.6流程逻辑用图表（例如流程图、判定表等）辅以必要的说明来表示本程序的逻辑流程。
Word自带的绘图工具一般都不利于排版，建议使用Visio绘制所有的流程图和模块图，插入Word。
Visio可以有很多页，最好将自己的论文图片都放在一个vsd文件中。
北邮信通院数据结构实验报告三哈夫曼编码器.pptx
-1
2.2 关键算法分析 （1）计算出现字符的权值
利用 ASCII 码统计出现字符的次数，再将未出现的字符进行筛选，将出现的字符及頻 数存储在数组 a[]中。
void Huffman::Init() {
int nNum[256]= {0}; //记录每一个字符出现的次数 int ch = cin.get();
第2页
北京邮电大学信息与通信工程学 院
2
-1
-1
-1
5
-1
-1
-1
6
-1
-1
-1
7
-1
-1
-1
9
-1
-1
-1
weight lchild rchild parent
2
-1
-1
5
5
-1
-1
5
6
-1
-1
6
7
-1
-1
6
9
-1
-1
7
7
0
1
7
第3页
北京邮电大学信息与通信工程学 院
13
2
3
8
16
5
4
8
29
6
7
2、建立编码表(CreateTable)：利用已经建好的赫夫曼树进行编码，并将每 个字符的编码输出。
3、编码(Encoding)：根据编码表对输入的字符串进行编码，并将编码后的 字符串输出。
4、译码(Decoding)：利用已经建好的赫夫曼树对编码后的字符串进行译 码，并输出译码结果。
5、打印(Print)：以直观的方式打印赫夫曼树（选作） 6、计算输入的字符串编码前和编码后的长度，并进行分析，讨论赫夫
北邮数据结构实验报告
北邮数据结构实验报告北京邮电大学信息与通信工程学院2009级数据结构实验报告实验名称：实验三哈夫曼编/解码器的实现学生姓名：陈聪捷日期：2010年11月28日1.实验要求一、实验目的：了解哈夫曼树的思想和相关概念;二、实验内容：利用二叉树结构实现哈夫曼编/解码器1.初始化：能够对输入的任意长度的字符串s进行统计，统计每个字符的频度，并建立哈夫曼树。
2.建立编码表：利用已经建好的哈夫曼树进行编码，并将每个字符的编码输出。
3.编码：根据编码表对输入的字符串进行编码，并将编码后的字符串输出。
4.译码：利用已经建好的哈夫曼树对编码后的字符串进行译码，并输出译码结果。
5.打印：以直观的方式打印哈夫曼树。
6.计算输入的字符串编码前和编码后的长度，并进行分析，讨论哈夫曼编码的压缩效果。
7.用户界面可以设计成“菜单”方式，能进行交互，根据输入的字符串中每个字符出现的次数统计频度，对没有出现的字符一律不用编码。
2.程序分析2.1存储结构二叉树templateclassBiTree{public:BiTree();//构造函数，其前序序列由键盘输入~BiTree(void);//析构函数BiNode*Getroot();//获得指向根结点的指针protected:BiNode*root;//指向根结点的头指针};//声明类BiTree及定义结构BiNodeData：二叉树是由一个根结点和两棵互不相交的左右子树构成data:HCode*HCodeTable;//编码表inttSize;//编码表中的总字符数二叉树的节点结构templatestructBiNode//二叉树的结点结构{Tdata;//记录数据Tlchild;//左孩子Trchild;//右孩子Tparent;//双亲};编码表的节点结构structHCode{chardata;//编码表中的字符charcode[100];//该字符对应的编码};待编码字符串由键盘输入，输入时用链表存储，链表节点为structNode{charcharacter;//输入的字符unsignedintcount;//该字符的权值boolused;//建立树的时候该字符是否使用过Node*next;//保存下一个节点的地址};示意图：2.2关键算法分析1.初始化函数(voidHuffmanTree::Init(stringInput))算法伪代码：1.初始化链表的头结点2.获得输入字符串的第一个字符，并将其插入到链表尾部,n=1(n 记录的是链表中字符的个数)3.从字符串第2个字符开始，逐个取出字符串中的字符3.1将当前取出的字符与链表中已经存在的字符逐个比较，如果当前取出的字符与链表中已经存在的某个字符相同，则链表中该字符的权值加1。
北邮数据结构试验报告试验二含源码
数据结构实验报告实验名称:实验二一一栈和队学生姓名:申宇飞班级：班内序03号：学号：日期2013年11月18日：1- 实验要求1.1实验目的：通过选择卞面五个题目之一进行实现，掌握如卞内容：>进一步掌握指针、模板类、异常处理的使用>掌握栈的操作的实现方法>掌握队列的操作的实现方法>学习使用栈解决实际问题的能力>学习使用队列解决实际问题的能力1.2实验内容题目1根据栈和队列的抽象数据类型的定义，按要求实现一个栈或一个队列。
要求：1、实现一个共享栈2、实现一个链栈3、实现一个循环队列4、实现一个链队列编写测试mainO函数测试线性表的正确性。
2.程序分析2.1存储结构链栈：栈的链式存储结构,其实现原理类似于单链表，结点结构与单链表相同，但链栈在实现时直接采用栈顶指针指向栈顶元素。
第］页北京邮电大学信息与通信工程学院data next栈顶栈底关键算法分析链栈：一、入栈操作算法步骤：自然语言描述：1、建立新结点2、给p结点的数据域赋值3、修改p结点的指针域，将其指向栈顶结点4、栈顶指针指向p结点伪代码描述：1)Node<T> * s = new Node<T>;2)p->data = x;3)p->next = top;4)top = p;二、出栈操作算法步骤：自然语言描述：1、判断栈是否为空2、保存栈顶结点的数据域3、定义指针p指向栈顶结点4、栈顶指针指向下一个结点5、释放p结点伪代码描述：1)if(EmptyO)throw" F溢“；2)T x = top->data;3)Node<T> * p = top;4)top = top->next;5)elete p;三、链栈的取栈顶元素算法步骤：自然语言描述：1、判断栈是否为空第3页2、定义指针p指向栈顶结点3、返回栈顶元素的值，不删除伪代码描述1)if(EmptyO)tlu'ow H卜溢"；2)Node<T>*p=top;3)cout«p->data;四、遍历链栈元素算法步骤：自然语言描述：1、定义指针p指向栈顶结点2、判断栈是否为空3、返回栈元素的值4、把下一个指针的值赋给p 伪代码描述：1)Node<T>*p = top;2)while(p !=NULL)3)cout« p->data ;4)p = p->next;五、析构函数算法步骤：自然语言描述：1、判断栈顶指针是否为空2、定义指针p指向栈顶结点3、把下一个指针的值赋给栈顶指针4、释放要释放的指针伪代码描述：1)while(top)2)strnct Node <T> * p = top;3)top = top->next;4)deletep; 时间复杂的：0(1)。
北邮 DSP 实验二实验报告
实验二：数字信号的 FFT 分析题目1假设信号 x(n) 由下述信号组成：()0.001*cos(0.45)sin(0.3)cos(0.302)4x n n n n ππππ=+-- 这个信号有两根主谱线 0.3pi 和 0.302pi 靠的非常近，而另一根谱线 0.45pi 的幅度很小，请选择合适的长度 N 和窗函数，用 DFT 分析其频谱，得到清楚的三根谱线。
步骤：1.编写离散傅里叶变换DFT 函数：function [Xk] = dft(xn,N)% Computes Discrete Fourier Transform Coefficients% [Xk] = dft(xn,N)% Xk = DFT coeff. array over 0 <= k <= N-1% xn = input signal% N = length of DFTn = [0:1:N-1]; % row vector for nk = [0:1:N-1]; % row vecor for kWN = exp(-j*2*pi/N); % Wn factornk = n'*k; % creates a N by N matrix of nk valuesWNnk = WN .^ nk; % DFT matrixXk = xn * WNnk; % row vector for DFT coefficients2.代码实现：n=0:1:999;x=0.001*cos(0.45*n*pi)+sin(0.3*n*pi)-cos(0.302*n*pi-0.25*pi);stem(n,x);title('signal x(n), 0<=n<=999');xlabel('n');X=dft(x,1000);% 计算1000点DFT magX=abs(X(1:1:501));% 镜像对称，只画出一半 k=0:1:500;w=2*pi*k/1000;stem(w/pi,magX);title('DTFT Magnitude');xlabel('frequency in pi units');axis([0.29,0.31,0,500]);xlabel('frequency between 0.29pi and 0.31pi');axis([0.44,0.46,0,0.5]);xlabel('frequency between 0.44pi and 0.46pi');3.图片：4.分析：x(n)由3个正弦函数叠加而成，周期分别是40, 20, 1000。
北邮计算机科学与技术操作系统第二次实验
北京邮电大学操作系统第二次实验实验报告班级302班第一部分：内存管理的伙伴算法1.实验描述：实现一个内存管理的伙伴算法，实现内存块申请时的分配和释放后的回收。
用随机函数仿真进程进行内存申请，并且以较为随机的次序进行释放。
对其碎片进行统计，当申请分配内存失败时区分实际空间不足和由于碎片而不能满足。
2.实验原理解释：假设要求分配的块其大小为128个页面。
该算法先在块大小为128个页面的链表中查找，看是否有这样一个空闲块。
如果有，就直接分配；如果没有，该算法会查找下一个更大的块，具体地说，就是在块大小为256个页面的链表中查找一个空闲块。
如果存在这样的空闲块，内核就把这256个页面分为两等份，一份分配出去，另一份插入到块大小为128个页面的链表中。
如果在块大小为256个页面的链表中也没有找到空闲页块，就继续找更大的块，即512个页面的块。
如果存在这样的块，内核就从512个页面的块中分出128个页面满足请求，然后从384个页面中取出256个页面插入到块大小为256个页面的链表中。
然后把剩余的128个页面插入到块大小为128个页面的链表中。
如果512个页面的链表中还没有空闲块，该算法就放弃分配，并发出出错信号。
以上过程的逆过程就是块的释放过程，这也是该算法名字的来由。
满足以下条件的两个块称为伙伴：两个块的大小相同，两个块的物理地址连续。
伙伴算法把满足以上条件的两个块合并为一个块，该算法是迭代算法，如果合并后的块还可以跟相邻的块进行合并，那么该算法就继续合并。
3.试验运行截图：第一组数据测试截图：第二组数据测试截图：第三组数据测试截图：4.实验代码：#include<iostream>#include<stdio.h>#define GETMIN(a,b) ((a)<(b)?(a):(b)) #define GETMAX(a,b) ((a)>(b)?(a):(b)) using namespace std;struct Node{int size;int remain;int frag;int isSplit;Node *left;Node *right;Node *parent;};struct Process{int oriMem;int reqMem;Node *ptr;void init(int _oriMem){int i;if(_oriMem<=0){oriMem=0;reqMem=0;ptr=NULL;return;}oriMem=_oriMem;for(i=31;i>=0;i--){if(oriMem&(1<<i)){break;}}if(oriMem==1<<i){reqMem=oriMem;}else{reqMem=1<<(i+1);}ptr=NULL;}};class BuddyTree{private:Node *root;Node *newNode(Node *_parent,int _size,int _remain){Node *ptr=new(Node);ptr->size=_size;ptr->remain=_remain;ptr->frag=0;ptr->isSplit=0;ptr->left=NULL;ptr->right=NULL;ptr->parent=_parent;return ptr;}public:Node* getRoot(){return root;}void init(int MaxMem){root=newNode(NULL,MaxMem,MaxMem);}void requestMem(Node *ptr,Node *&res,int reqSize,int oriSize){ if(ptr->remain<reqSize){res=NULL;return;}if(ptr->size==reqSize){res=ptr;ptr->remain=0;ptr->frag+=reqSize-oriSize;return;}if(ptr->isSplit==0){int _size=ptr->size/2;ptr->isSplit=1;ptr->left=newNode(ptr,_size,_size);ptr->right=newNode(ptr,_size,_size);requestMem(ptr->left,res,reqSize,oriSize);}else{int minMem=GETMIN(ptr->left->remain,ptr->right->remain); if(minMem>=reqSize){if(ptr->left->remain<=ptr->right->remain){requestMem(ptr->left,res,reqSize,oriSize);}else{requestMem(ptr->right,res,reqSize,oriSize);}}else{if(ptr->left->remain>=reqSize){requestMem(ptr->left,res,reqSize,oriSize);}else{requestMem(ptr->right,res,reqSize,oriSize);}}}ptr->remain=GETMAX(ptr->left->remain,ptr->right->remain);ptr->frag=ptr->left->frag+ptr->right->frag;}void releaseMem(Node *ptr){int memsize=ptr->size;int frag=ptr->frag;ptr->frag=0;ptr->remain=memsize;ptr=ptr->parent;while(ptr){if(ptr->left->remain==ptr->left->size&&ptr->right->remain==ptr->right->size){ ptr->remain=ptr->size;}else{ptr->remain=GETMAX(ptr->left->remain,ptr->right->remain);}ptr->frag-=frag;ptr=ptr->parent;}}void printTree(Node *ptr){if(ptr==NULL)return;char tmp[100];sprintf(tmp,"[Node size %dB]",ptr->size);printf("%-26s",tmp);sprintf(tmp,"remaining : %dB",ptr->remain);printf("%-26s",tmp);sprintf(tmp,"fragment : %dB",ptr->frag);printf("%s\n",tmp);printTree(ptr->left);printTree(ptr->right);}};Process P[200];int test[3][20]={{24,80,4600,8,100,1,500},{70,480,3300,25,10600,8909,490,99,40},{1,20,300,4000,50000,600000,7000000,80000000,900000000}}; int n[3]={7,9,9};int memory[3]={1024,1024*1024,1024*1024*1024};int main(){BuddyTree BT;char tmp[100];for(int t=0;t<3;t++){printf("Test%d:\n",t+1);printf("Process status:\n");for(int j=0;j<n[t];j++){P[j].init(test[t][j]);sprintf(tmp,"Original request: %d",P[j].oriMem);printf("%-30s",tmp);sprintf(tmp,"Actual request: %d",P[j].reqMem);printf("%s\n",tmp);}printf("\nMemory amount : %dB\n",memory[t]);BT.init(memory[t]);printf("\n");printf("Constructing the tree:\n");for(int j=0;j<n[t];j++){sprintf(tmp,"The process needs %d bytes.",P[j].oriMem);printf("%-35s",tmp);BT.requestMem(BT.getRoot(),P[j].ptr,P[j].reqMem,P[j].oriMem);if(P[j].ptr){printf("Request success,obtain %d bytes.\n",P[j].reqMem);}else{printf("Request failed.\n");}}printf("\n");printf("After constructing,preorder the tree:\n");BT.printTree(BT.getRoot());printf("\n");printf("After constructing the tree,the sum of fragment is %d.\n",BT.getRoot()->frag);printf("\n");printf("After the release,the tree(preorder) is:\n");for(int j=0;j<n[t];j++){if(P[j].ptr){BT.releaseMem(P[j].ptr);}}BT.printTree(BT.getRoot());printf("\n");printf("\n");system("pause");printf("\n");}return 0;}第二部分：设计一个虚拟存储区和内存工作区，并使用下述算法计算访问命中率1.实验描述：设计一个虚拟存储区和内存工作区，并使用下述算法计算访问命中率。
北邮高级计算机系统结构实验二三四五
实验二指令流水线相关性分析·实验目的通过使用WINDLX模拟器，对程序中的三种相关现象进行观察，并对使用专用通路，增加运算部件等技术对性能的影响进行考察，加深对流水线和RISC 处理器的特点的理解。
·实验原理：指令流水线中主要有结构相关、数据相关、控制相关。
相关影响流水线性能。
·实验步骤一．使用WinDLX模拟器，对Fact.s做如下分析：（1）观察程序中出现的数据/控制/结构相关。
指出程序中出现上述现象的指令组合。
（2）考察增加浮点运算部件对性能的影响。
（3）考察增加forward部件对性能的影响。
（4）观察转移指令在转移成功和转移不成功时候的流水线开销。
·实验过程一．使用WinDLX模拟器，对Fact.s做如下分析：浮点加、乘、除部件都设置为1，浮点数运算部件的延时都设置为4，如图1：图1 初始设置将fact.s和input.s加载至WinDLX中，如图2示。
图2 加载程序1.观察程序中出现的数据/控制/结构相关；指出程序中出现上述现象的指令组合。
1）数据相关点击F7，使程序单步执行，当出现R-Stall时停止，运行过程中出现下图3所示，输入整数6。
图3 输入整数6打开Clock Diagram，可以清楚的看到指令执行的流水线如图4所示。
图4 指令流水线双击第一次出现R-Stall的指令行，如图5所示。
图5 指令详细信息对以上出现的情况分析如下：程序发生了数据相关，R-Stall（R-暂停）表示引起暂停的原因是RAW。
lbu r3,0×0(r2)要在WB周期写回r3中的数据；而下一条指令seqi r5,r3,0×a要在intEX周期中读取r3中的数据。
上述过程发生了WR冲突，即写读相关。
为了避免此类冲突，seq r5,r4,0×a的intEX指令延迟了一个周期进行。
由此，相关指令为：2）控制相关由图6可以看出，在第4时钟周期：第一条指令处于MEM段，第二条命令处于intEX段，第三条指令出于aborted状态，第四条命令处于IF段。
北邮数据结构实验报告三题目2-哈夫曼树
11．实验要求利用二叉树结构实现哈夫曼编/ 解码器(1). 初始化：能够对输入的任意长度的字符串s 进行统计，统计每个字符的频度，并建立哈夫曼树。
(2). 建立编码表：利用已经建好的哈夫曼树进行编码，并将每个字符的编码输出。
(3). 编码：根据编码表对输入的字符串进行编码，并将编码后的字符串输出。
(4). 译码：利用已经建好的哈夫曼树对编码后的字符串进行译码，并输出译码结果。
(5). 打印：以直观的方式打印哈夫曼树。
(6). 计算输入的字符串编码前和编码后的长度，并进行分析，讨论哈夫曼编码的压缩效果。
(7). 用户界面可以设计成“菜单”方式，能进行交互，根据输入的字符串中每个字符出现的次数统计频度，对没有出现的字符一律不用编码。
2.程序分析2.1存储结构二叉树：示意图：root2.21{2.3 关键算法分析1. 定义哈夫曼树的模板类#include <iostream>#include <string.h> using namespace std; structLNode {char ch;int weight;char code[20];LNode* next; };struct TNode{int weight; //int Lchild; //int Rchild; //int Parent; // };class Huffman 结点权值左孩子指针右孩子指针双亲指针// 链表的节点, 用来统计字符频率，并编码// 字符// 权值// 字符编码// 指向下一个节点// 哈弗曼树结点的结构体1 public:Huffman(); ~Huffman(); void CreateTable(); void PrintTable(); void Encoding(); void Decoding(); void Comrate();// 构造函数，输入、统计字符，创建哈弗曼树、码表// 释放链表空间、哈弗曼树的节点// 建立编码表，并将信息存入链表// 输出码表// 哈弗曼编码// 译码void SelectMin(int &x,int &y,int begin,int end);void reverse(char ch[]); voidcontrol();private: // 选取权值最小的两个数，创建哈弗曼树// 将码值倒置，用来编码// 对菜单交互等提示操作TNode* troot;LNode* lroot; void List(char a[]); void HTree(); int Letter; char astr[1000]; char bstr[1000]; // 在统计字符频率是构建链表的根节点// 统计字符的权值建立的单链表// 哈弗曼树建立// 共有不同字符总数// 用户输入的一串字符// 将字符串的码值保存Huffman::Huffman(){lroot=new LNode;bstr[0]='\0';lroot->next=NULL;Letter=0; // 初始化字符总数为1 cout<<" 请输入一串字符，以回车键结束"<<endl;cin.getline(astr,1000,'\n');if(strlen(astr)==0) throw 1;else{List(astr); // 用链表存储每个字符HTree();CreateTable();Encoding();}};Huffman::~Huffman(){delete troot;LNode* p=lroot;while(p=lroot->next)1{{ lroot=p->next; delete p; p=lroot;}delete p; };2. 建立哈夫曼树void Huffman::HTree(){LNode* p=lroot; int a=0;troot=new TNode[2*Letter-1]; //2n-1 while (p=p->next){troot[a].weight=p->weight; troot[a].Parent=-1; troot[a].Lchild=-1; troot[a].Rchild=-1; a++;};for (int i=Letter;i<2*Letter-1;i++)troot[i].Parent=-1; int x,y,begin=0;for (int j=Letter;j<2*Letter-1;j++) while (troot[begin].Parent!=-1)begin++;个结点// 建立叶子节点// 是两个最小值的角标SelectMin(x,y,begin,j);troot[j].weight=troot[x].weight+troot[y].weight;troot[j].Lchild=x;troot[j].Rchild=y;troot[j].Parent=-1;troot[x].Parent=j;troot[y].Parent=j;}};3.统计字符的频率void Huffman::List(char a[]){LNode *p=lroot;int i=0;while(a[i]!='\0'){{while (p&&p->ch!=a[i]) // 查找链表中没有该字符或者找到该字符p=p->next;if (!p) // 如果没有该字符，创建节点。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构实验报告1．实验要求（ 1）实验目的通过选择下面 5 个题目之一进行实现，掌握如下内容：掌握图基本操作的实现方法了解最小生成树的思想和相关概念了解最短路径的思想和相关概念学习使用图解决实际问题的能力(2)实验内容根据图的抽象数据类型的定义，使用邻接矩阵或邻接表实现一个图。
图的基本功能：1、图的建立2、图的销毁3、深度优先遍历图4、广度优先遍历图5、使用普里姆算法生成最小生成树6、使用克鲁斯卡尔算法生成最小生成树7、求指定顶点到其他各顶点的最短路径8、其他：比如连通性判断等自定义操作编写测试 main() 函数测试图的正确性2.程序分析2.1存储结构图：(1)带权值的无向图V096V12V2(2)带权值的有向图V063 94V12V2 2.2关键算法分析（1）深度优先遍历int visited[MAXSIZE]={false}; template<class T>void MGraph<T>::DFS(int v){cout<<vertex[v];visited[v]=true;for(int j=0;j<vNum;j++)if(arc[v][j]==1&&!visited[j])DFS(j);}时间复杂度： O(n2)（2）广度优先遍历int queue[MAXSIZE];int f=0,r=0;cout<<vertex[v];visit[v]=true;queue[++r]=v;while(f!=r){v=queue[++f];for(int j=0;j<vNum;j++){if(arc[v][j]==1&&!visit[j]){cout<<vertex[j];visit[j]=true;queue[++r]=j;}时间复杂度： O（ n2）（3）普利姆算法int adjvex[MAXSIZE];int lowcost[MAXSIZE];int MAX=10000;template<class T>int mininum(MGraph<T> G,int a[]){int min=MAX;int k=0;for(int i=0;i<G.vNum;i++){if(a[i]!=0&&a[i]<min)//寻找 U-{V-U} 中边权值最小的顶点{min=a[i];k=i;}}return k;}template<class T>void MGraph<T>:: Prim(MGraph G){for(int i=0;i<G.vNum;i++){adjvex[i]=0;lowcost[i]=G.arcs[0][i];}lowcost[0]=0;//初始化 U={vo}for(int i=1;i<G.vNum;i++){int k=mininum(G,lowcost);//求下一个边权值最小的邻接点cout<<'V'<<adjvex[k]<<"->V"<<k<<endl;lowcost[k]=0;for(int j=0;j<G.vNum;j++){if(lowcost[j]!=0&&G.arcs[k][j]<lowcost[j]){lowcost[j]=G.arcs[k][j];adjvex[j]=k;}}}}时间复杂度： O(n2)（4）克鲁斯卡尔算法template<class T>void GenSortEdge(MGraph<T> G,VEdge E[])//获取EdgeList{int k=0,i,j;for(i=0;i<G.vNum;i++)//边赋值for(j=i;j<G.vNum;j++)if(G.arcs[i][j]!=MAX){E[k].fromV=i;E[k].endV=j;E[k].weight=G.arcs[i][j];k++;}for(i=0;i<G.arcNum-1;i++){for(j=i+1;j<G.arcNum;j++)if(E[i].weight>E[j].weight){VEdge t=E[i];E[i]=E[j];E[j]=t;}}}const int MAX_VERTEXT=20;template<class T>void MGraph<T>:: Kruskal(VEdge E[],int n,int e){int vset[MAX_VERTEXT];for(int i=0;i<n;i++) vset[i]=i;//初始化vset int k=0,j=0;while(k<n-1){int m=E[j].fromV,n=E[j].endV;int sn1=vset[m];//m int sn2=vset[n];//n if(sn1!=sn2){所属的集合所属的集合cout<<'V'<<m<<"->V"<<n<<endl;k++;for(int i=0;i<n;i++){if(vset[i]==sn2)//集合编号为sn2 的全部改为sn1 vset[i]=sn1;时间复杂度： O(n2 )（5）求最短路径，连通性判断int dist[MAXSIZE][MAXSIZE];int path[MAXSIZE][MAXSIZE];template<class T>void Floyd(MGraph<T> G){for(int i=0;i<G.vNum;i++)//寻找最短路径for(int j=0;j<G.vNum;j++){dist[i][j]=G.arcs[i][j];if(dist[i][j]!=MAX_VALUE)path[i][j]=i;elsepath[i][j]=-1;}for(int k=0;k<G.vNum;k++)for(int i=0;i<G.vNum;i++)for(int j=0;j<G.vNum;j++)if(dist[i][k]+dist[k][j]<dist[i][j])//更新迭代数组Disk[][]{dist[i][j]=dist[i][k]+dist[k][j];path[i][j]=k;}cout<<" 任意两点间的最短路径长度( 以矩阵表示）： "<<endl;int l=1;for(int i=0;i<G.arcNum;i++)for(int j=0;j<G.arcNum;j++){cout<<dist[i][j]<<" ";l++;if(l>G.arcNum) {cout<<endl;l=1;}}}时间复杂度： O(n3)3.程序运行结果（1）流程图：初始化带权值的无向图深度优先遍历，广度优先遍历用普利姆算法求最小生成树用克鲁斯卡尔算法求最小生成树初始化带权值的有向图用 Floyd 算法求任意两点间最短路径，并判断连通性删除图（2）本程序所用的图带权值的无向图V096V12V2带权值的有向图V06394V12V2（ 3）程序结果4.总结（1）遇到的问题：私有数据访问权的问题，在编程时应该注意（2）心得体会：通过这次实验，我掌握了图基本操作的实现方法，了解最小生成树的思想和相关概念，了解最短路径的思想和相关概念等等。
（3）改进：可以适当对某些步骤进行合并或省略，使程序更加简洁。
源代码：#include<iostream>using namespace std;const int MAXSIZE=20;const int MAX_EDGE=20;const int MAX_VALUE=1000;struct VEdge{int fromV;// int endV;// int weight;//起始顶点终止顶点边的权值};VEdge EdgeList[MAX_EDGE];template<class T>class MGraph{public:MGraph(T a[],int n,int e);MGraph(T a[],int n,int e,int h);void DFS(int v);void BFS(int v);void Prim(MGraph G);void Kruskal(VEdge E[],int n,int e);int vNum,arcNum;int arcs[MAXSIZE][MAXSIZE];//用于储存权值的数组int arc[MAXSIZE][MAXSIZE];private:T vertex[MAXSIZE];};template<class T> //构造带权值的有向图MGraph<T>::MGraph(T a[],int n,int e,int h){int i,j,k,l;vNum=n;arcNum=e;for(k=0;k<n;k++) vertex[k]=a[k];for(k=0;k<n;k++)for(j=0;j<n;j++) arc[k][j]=0;for(int i=0;i<MAXSIZE;i++){for(int j=0;j<MAXSIZE;j++){arcs[i][j]=MAX_VALUE;}}cout<<"请输入连通的两顶点下标(弧头-弧尾）及弧的权值(<1000)："<<endl;for(int i=0;i<MAXSIZE;i++){arcs[i][i]=0;}for(k=0;k<h;k++){cin>>i>>j>>l;arcs[i][j]=l;arc[i][j]=1;}}template<class T>//带权值的无向图MGraph<T>::MGraph(T a[],int n,int e){int i,j,k,l;vNum=n;arcNum=e;for(k=0;k<n;k++) vertex[k]=a[k];for(k=0;k<n;k++)for(j=0;j<n;j++) arc[k][j]=0;cout<<"请输入连通的两顶点下标及边的权值(<1000)： "<<endl;for(k=0;k<e;k++){cin>>i>>j>>l;arcs[i][j]=l;arcs[j][i]=arcs[i][j];arc[i][j]=1;arc[j][i]=arc[i][j];}}//深度广度遍历int visited[MAXSIZE]={false}; template<class T>void MGraph<T>::DFS(int v){cout<<vertex[v];visited[v]=true;for(int j=0;j<vNum;j++)if(arc[v][j]==1&&!visited[j])DFS(j);}int visit[MAXSIZE]={false};template<class T>void MGraph<T>::BFS(int v){int queue[MAXSIZE];int f=0,r=0;cout<<vertex[v];visit[v]=true;queue[++r]=v;while(f!=r){v=queue[++f];for(int j=0;j<vNum;j++){if(arc[v][j]==1&&!visit[j]){cout<<vertex[j];visit[j]=true;queue[++r]=j;}}}}//普利姆算法int adjvex[MAXSIZE];int lowcost[MAXSIZE];int MAX=10000;template<class T>int mininum(MGraph<T> G,int a[]){int min=MAX;int k=0;for(int i=0;i<G.vNum;i++){if(a[i]!=0&&a[i]<min)//寻找 U-{V-U} 中边权值最小的顶点{min=a[i];k=i;}}return k;}template<class T>void MGraph<T>:: Prim(MGraph G){for(int i=0;i<G.vNum;i++){adjvex[i]=0;lowcost[i]=G.arcs[0][i];}lowcost[0]=0;//初始化 U={vo}for(int i=1;i<G.vNum;i++){int k=mininum(G,lowcost);//求下一个边权值最小的邻接点cout<<'V'<<adjvex[k]<<"->V"<<k<<endl;lowcost[k]=0;for(int j=0;j<G.vNum;j++){if(lowcost[j]!=0&&G.arcs[k][j]<lowcost[j]){lowcost[j]=G.arcs[k][j];adjvex[j]=k;}}}}//克鲁斯卡尔算法template<class T>void GenSortEdge(MGraph<T> G,VEdge E[])//获取EdgeList{int k=0,i,j;for(i=0;i<G.vNum;i++)//边赋值for(j=i;j<G.vNum;j++)if(G.arcs[i][j]!=MAX){E[k].fromV=i;E[k].endV=j;E[k].weight=G.arcs[i][j];k++;}for(i=0;i<G.arcNum-1;i++){for(j=i+1;j<G.arcNum;j++)if(E[i].weight>E[j].weight){VEdge t=E[i];E[i]=E[j];E[j]=t;}}}const int MAX_VERTEXT=20;template<class T>void MGraph<T>:: Kruskal(VEdge E[],int n,int e){int vset[MAX_VERTEXT];for(int i=0;i<n;i++) vset[i]=i;//初始化vset int k=0,j=0;while(k<n-1){int m=E[j].fromV,n=E[j].endV;int sn1=vset[m];//m int sn2=vset[n];//n if(sn1!=sn2){所属的集合所属的集合cout<<'V'<<m<<"->V"<<n<<endl;k++;for(int i=0;i<n;i++){if(vset[i]==sn2)//集合编号为sn2 的全部改为sn1 vset[i]=sn1;}}j++;}}//求最短路径//连通性判断int dist[MAXSIZE][MAXSIZE];int path[MAXSIZE][MAXSIZE];template<class T>void Floyd(MGraph<T> G){for(int i=0;i<G.vNum;i++)//寻找最短路径for(int j=0;j<G.vNum;j++){dist[i][j]=G.arcs[i][j];if(dist[i][j]!=MAX_VALUE)path[i][j]=i;elsepath[i][j]=-1;}for(int k=0;k<G.vNum;k++)for(int i=0;i<G.vNum;i++)for(int j=0;j<G.vNum;j++)if(dist[i][k]+dist[k][j]<dist[i][j])//更新迭代数组Disk[][]{dist[i][j]=dist[i][k]+dist[k][j];path[i][j]=k;}cout<<" 任意两点间的最短路径( 以矩阵表示）： "<<endl;int l=1;for(int i=0;i<G.arcNum;i++)for(int j=0;j<G.arcNum;j++){cout<<dist[i][j]<<" ";l++;if(l>G.arcNum) {cout<<endl;l=1;}}}void main(){int v,e;cout<<" 请输入顶点数(<21) 和边数 (<21) ：";cin>>v>>e;if(v>20||v<0||e<0||e>20)cout<<" 输入错误！ "<<endl;charch[20]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t'};MGraph<char> A(ch,v,e);cout<<"请输入深度优先遍历的起始顶点下标：";int s;cin>>s;cout<<" 深度优先遍历:"<<endl;A.DFS(s);cout<<endl;cout<<" 请输入广度优先遍历的起始顶点下标：";int k;cin>>k;cout<<" 广度优先遍历："<<endl;A.BFS(k);cout<<endl;cout<<" 普利姆算法求最小生成树："<<endl;A.Prim(A);cout<<" 克鲁斯卡尔算法求最小生成树："<<endl;VEdge EdgeList[MAX_EDGE];GenSortEdge(A,EdgeList);A.Kruskal(EdgeList,v,e);//初始化带权值的有向图cout<<" 构造带权值的有向图，请输入弧数：";int h;cin>>h;MGraph<char> B(ch,v,e,h);Floyd(B);}。