【数据结构】实验十一：图

于 2023-07-28 19:22:54 发布
阅读量1.6k 收藏 16
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65787507/article/details/131968277
版权

实验十一 图

一、实验目的与要求

1）掌握图的存储表示与操作实现。

2）掌握图的连通性及其应用。

二、 实验内容

1.用邻接表存储一个图形结构，并计算每个顶点的度。

2. 采用深度和广度优先搜索算法，遍历上述这张图，并输出遍历结果。

三、实验结果

1）请将调试通过的运行结果截图粘贴在下面，并说明测试用例、运行过程和算法步骤。

2）请分析算法的时间复杂度。

3）请将源代码（必要的注释）cpp文件压缩上传（上传附件）。

题目1：

1）

测试用例：

测试用例为总结点数为4、总边数为5的无向图，如下图所示。

运行结果：

运行过程：

通过邻接表创建无向连通图->通过for循环遍历并输出邻接表结果->通过for循环计算并输出各顶点的度数。

2）

算法步骤和时间复杂度分析：

图的邻接表存储类似于树的孩子链表表示法。对于图中每个顶点vi建立一个链表，第i个链表中的结点表示依附于vi的边。每个链表上附设一个头结点和一个尾结点。

假设需要存储的图的顶点数为V，边数为E。如果存储的是无向图，那么遍历时先访问顶点数组的各个元素，再访问其对应的边链表，由于有V个节点，而且无向图的E条边在边链表中会出现两次，即边共出现2E次，所以一共的访问次数为V+2E。因此，算法的时间复杂度为O(|V|+2|E|)。

对于n个顶点无向图的邻接表，顶点vi的度恰为第i个链表中的结点个数。因此可以计算无向图中每个顶点的度。

3）

实验源代码：

#include <iostream>
using namespace std;
#define MVNum 100//最大顶点数 

typedef char VerTexType;//顶点信息
typedef int OtherInfo;//和边相关的信息 

//边结点 
typedef struct ArcNode{
    int adjvex;//该边所指向的顶点的位置 
    struct ArcNode *nextarc;//指向下一条边的指针 
    OtherInfo info;//和边相关的信息
}ArcNode; 

//顶点
typedef struct VNode{ 
    VerTexType data;//顶点信息                 	 
    ArcNode *firstarc;//指向第一条依附该顶点的边的指针 
}VNode, AdjList[MVNum];//AdjList表示邻接表类型 

typedef struct{ 
    AdjList vertices;//邻接表 
    int vexnum, arcnum;//图的当前顶点数和边数 
}ALGraph;

//确定点v在G中的位置
int LocateVex(ALGraph G,VerTexType v){
	for(int i = 0; i < G.vexnum; ++i){
		if(G.vertices[i].data == v){
			return i;//顶点已经存在，返回序号i 
		}
	}
    return -1;
}

//采用邻接表表示法，创建无向图G
void CreateUDG(ALGraph &G){
	int i , k;
	cout <<"请输入总顶点数：";
	cin >> G.vexnum;
	cout <<"请输入总边数：";
	cin >> G.arcnum;
    cout << endl;
	cout << "输入点的名称：" <<endl;
	for(i = 0; i < G.vexnum; ++i){       	
		cout << "请输入第" << (i+1) << "个点的名称:";
		cin >> G.vertices[i].data;//输入顶点值 
		G.vertices[i].firstarc=NULL;//初始化表头结点的指针域为NULL 
    }
	cout << endl;
	cout << "请输入一条边依附的顶点："<<endl;
	for(k = 0; k < G.arcnum;++k){
		VerTexType v1 , v2;//顶点名字 
		int i,j;
		cout << "请输入第" << (k + 1) << "条边依附的顶点:";
		cin >> v1 >> v2;//输入边的两个顶点 
		i = LocateVex(G, v1);//确定第一个点的位置 
		j = LocateVex(G, v2);//确定第二个点的位置
		ArcNode *p1=new ArcNode;//生成一个新的边结点*p1
		p1->adjvex=j;//邻接点序号为j
		p1->nextarc= G.vertices[i].firstarc; 
		G.vertices[i].firstarc=p1;//将新结点*p1插入顶点vi的边表头部
		ArcNode *p2=new ArcNode;//生成另一个对称的新的边结点*p2 
		p2->adjvex=i;//邻接点序号为i 
		p2->nextarc= G.vertices[j].firstarc;  
		G.vertices[j].firstarc=p2;//将新结点*p2插入顶点vj的边表头部 
    } 
}

//输出邻接表 
void Show(ALGraph &G){
	cout<<endl;
	int i;
	cout<<endl<<"邻接表为："<<endl; 
	for(i = 0 ; i < G.vexnum ; ++i){
		VNode temp = G.vertices[i];
		ArcNode *p = temp.firstarc;
		if(p == NULL){
			cout << G.vertices[i].data;
			cout << endl;
		}
		else{
			cout << temp.data;
			while(p){
				cout << "->";
				cout << p->adjvex;
				p = p->nextarc;
			}
		}
		cout << endl;
	}
}

//计算度数 
void CountDegree(ALGraph *G){
	cout<<endl;
	int i,j,k,degree;
	int count1=0;
	ArcNode *p;
	for(i=0;i<G->vexnum;i++){
		degree=0;
		p=G->vertices[i].firstarc;
		while(p!=NULL){
			degree++;
			p=p->nextarc ;
		} 
		if(i!=G->vexnum -1){
			cout<<degree<<" ";
		}
		else{
			cout<<degree;
		}
	}
}

int main(){
	ALGraph G;
	CreateUDG(G);
	Show(G);
	cout<<endl<<"各顶点度数依次为："<<endl;
	CountDegree(&G);
	return 0;
}

题目2：

1）

测试用例：

下图所示的总顶点数的9，总边数为10的无向连通图。人为设置从A点开始遍历。

运行结果：

深度优先：

 

 广度优先：

运行过程：

深度优先：

通过邻接表创建无向连通图->输入遍历起点的名称->判断起点是否在无向图内->调用DFS函数进行深度遍历。

广度优先：

通过邻接矩阵和队列创建无向连通图->输入遍历起点的名称->判断起点是否在无向图内->调用BFS函数进行深度遍历。

2）

算法步骤和时间复杂度分析：

深度优先：

假设图的顶点个数为n，边的个数为e。本算法的执行时间主要耗费在递归调用DFS函数上。当访问某顶点时，DFS的执行时间主要耗费在从该顶点出发搜索其所有邻接点上。采用邻接表作为图的存储结构时，对n个顶点访问就需要对所有链表中的e个表结点检查一遍。因此，算法的时间复杂度为O(n+e)。

广度优先：

假设图的顶点个数为n，边的个数为e。本算法对图中的每一个顶点均入队一次。当访问某个顶点时，执行时间主要耗费在从该顶点出发搜索其所有邻接点上。采用邻接矩阵作为图的存储结构时，查找每一个顶点的邻接点所需要的时间为O(n2)。因此，算法的时间复杂度为O(n2)。

3）

实验源代码：

深度优先

//深度优先 
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

#define MVNum 100						
typedef char VerTexType;					

typedef struct ArcNode{                		//边结点 
    int adjvex;                          	//该边所指向的顶点的位置 
    struct ArcNode *nextarc;          		//指向下一条边的指针 
}ArcNode; 

typedef struct VNode{ 
    VerTexType data;                    	//顶点信息
    ArcNode *firstarc;                		//指向第一条依附该顶点的边的指针 
}VNode, AdjList[MVNum];               		//AdjList表示邻接表类型 

typedef struct{
    AdjList vertices;                 		//邻接表 
    int vexnum, arcnum;              		//图的当前顶点数和边数 
}ALGraph;

bool visited[MVNum];//访问标志数组，其初值为"false" 

//确定点v在G中的位置
int LocateVex(ALGraph G , VerTexType v){
	for(int i = 0; i < G.vexnum; ++i){
		if(G.vertices[i].data == v){
			return i;
		}
	}
	return -1;
}

//采用邻接表表示法，创建无向图G
void CreateUDG(ALGraph &G){ 
	int i , k;
	cout <<"请输入总顶点数，总边数：";
	cin >> G.vexnum >> G.arcnum;
    cout << endl;
	
	cout << "输入点的名称：" << endl;
    //输入各点，构造表头结点表
	for(i = 0; i < G.vexnum; ++i){          	
		cout << "请输入第" << (i+1) << "个点的名称:";
		cin >> G.vertices[i].data;//输入顶点值 
		G.vertices[i].firstarc=NULL;		
    }
	cout << endl;
    
	cout << "输入边依附的顶点：" << endl;
    //输入各边，构造邻接表
	for(k = 0; k < G.arcnum;++k){        		
		VerTexType v1 , v2;
		int i , j;
		cout << "请输入第" << (k + 1) << "条边依附的顶点:";
		cin >> v1 >> v2;                 		
		i = LocateVex(G, v1);  
		j = LocateVex(G, v2);
		//确定v1和v2在G中位置，即顶点在G.vertices中的序号 
		
		ArcNode *p1=new ArcNode;//生成一个新的边结点*p1 
		p1->adjvex=j;//邻接点序号为j 
		p1->nextarc= G.vertices[i].firstarc;  
		G.vertices[i].firstarc=p1;  
		//将新结点*p1插入顶点vi的边表头部
		
		ArcNode *p2=new ArcNode;//生成另一个对称的新的边结点*p2 
		p2->adjvex=i;//邻接点序号为i 
		p2->nextarc= G.vertices[j].firstarc;
		G.vertices[j].firstarc=p2;
		//将新结点*p2插入顶点vj的边表头部 
    }
}

//深度优先 
void DFS(ALGraph G, int v){        				
	cout << G.vertices[v].data << "->";  
	visited[v] = true;//访问第v个顶点，并置访问标志数组相应分量值为true 
	ArcNode *p = G.vertices[v].firstarc;//p指向v的边链表的第一个边结点 
	//边结点非空
	while(p != NULL){ 
		int w = p->adjvex; //表示w是v的邻接点 
		if(!visited[w]){
			DFS(G, w);//如果w未访问，则递归调用DFS 
		}
		p = p->nextarc;//p指向下一个边结点 
	} 
}

int main(){
	ALGraph G;
	CreateUDG(G);
	cout << endl;
	cout << "无向连通图G创建完成" << endl << endl;

	cout << "请输入遍历连通图的起始点：";
	VerTexType c;
	cin >> c;
	
	int i;
	for(i = 0 ; i < G.vexnum ; ++i){
		if(c == G.vertices[i].data){
			break;
		}
	}
	cout << endl;
	
	while(i >= G.vexnum){
		cout << "该点不存在，请重新输入！" << endl;
		cout << "请输入遍历连通图的起始点：";
		cin >> c;
		for(i = 0 ; i < G.vexnum ; ++i){
			if(c == G.vertices[i].data){
				break;
			}
		}
	}
	cout << "深度优先搜索遍历图结果为：" << endl;
	DFS(G , i);
	return 0;
}

广度优先

//广度优先
#include <iostream>
using namespace std;

#define MVNum 100                       	
#define MAXQSIZE 100					
						
typedef char VerTexType;              		
typedef int ArcType;                  		
bool visited[MVNum];//访问标志数组，其初值为"false" 

//图的邻接矩阵存储表示-
typedef struct{ 
	VerTexType vexs[MVNum];//顶点表
	ArcType arcs[MVNum][MVNum];//邻接矩阵
	int vexnum,arcnum;//图的当前点数和边数
}Graph;

//队列
typedef struct{
	ArcType *base;//初始化的动态分配存储空间
	int front;//头指针
	int rear;//尾指针，队尾元素的下一个位置
}sqQueue;

//构造一个空队列Q
void InitQueue(sqQueue &Q){
	Q.base = new ArcType[MAXQSIZE];
	if(!Q.base){
		exit(1);
	}
	Q.front = Q.rear = 0;
}

//插入元素e为Q的新的队尾元素
void EnQueue(sqQueue &Q, ArcType e){
	if((Q.rear + 1) % MAXQSIZE == Q.front){
		return;
	}
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1) % MAXQSIZE;
}

//判断是否为空队
bool QueueEmpty(sqQueue Q){
	if(Q.rear == Q.front){
		return true;
	}
	return false;
}

//队头元素出队 
void DeQueue(sqQueue &Q, ArcType &u){
	u = Q.base[Q.front];
	Q.front = (Q.front + 1) % MAXQSIZE;
}

//确定点v在G中的位置
int LocateVex(Graph G , VerTexType v){
	for(int i = 0; i < G.vexnum; ++i){
		if(G.vexs[i] == v){
			return i;
		}
	}
	return -1;
}

//采用邻接矩阵表示法，创建无向G
void CreateUDN(Graph &G){
	int i , j , k;
	cout <<"请输入总顶点数，总边数：";
    cin >> G.vexnum >> G.arcnum;						
	cout << endl;
	cout << "输入点的名称：" << endl;
    for(i = 0; i < G.vexnum; ++i){   
		cout << "请输入第" << (i+1) << "个点的名称:";
		cin >> G.vexs[i];
	}
	cout << endl;
	//初始化邻接矩阵，边的权值均置为极大值MaxInt
    for(i = 0; i < G.vexnum; ++i)               			 
		for(j = 0; j < G.vexnum; ++j)   
			G.arcs[i][j] = 0; 
	cout << "输入边依附的顶点：" << endl;
	for(k = 0; k < G.arcnum;++k){							
		VerTexType v1 , v2;
		cout << "请输入第" << (k + 1) << "条边依附的顶点:";
		cin >> v1 >> v2;									
		i = LocateVex(G, v1);  
		j = LocateVex(G, v2);
		//确定v1和v2在G中的位置，即顶点数组的下标 
		G.arcs[i][j] = 1;//边<v1, v2>的权值置为w 
		G.arcs[j][i] = G.arcs[i][j];//置<v1, v2>的对称边<v2, v1>的权值为w 
	}
}

//返回v的第一个邻接点
int FirstAdjVex(Graph G , int v){
	int i;
	for(i = 0 ; i < G.vexnum ; ++i){
		if(G.arcs[v][i] == 1 && visited[i] == false){
			return i;
		}
	}
	return -1;
}

//返回v相对于w的下一个邻接点
int NextAdjVex(Graph G , int u , int w){
	int i;
	for(i = w ; i < G.vexnum ; ++i){
		if(G.arcs[u][i] == 1 && visited[i] == false){
			return i;
		}
	}
	return -1;
}

//按广度优先非递归遍历连通图G
void BFS (Graph G, int v){ 
	sqQueue Q;
	ArcType u;
	ArcType w;
    cout << G.vexs[v] << "->";    
	visited[v] = true;  
    InitQueue(Q);//辅助队列Q  
    EnQueue(Q, v);//v进队 
    while(!QueueEmpty(Q)){
		DeQueue(Q, u);
		for(w = FirstAdjVex(G, u); w >= 0; w = NextAdjVex(G, u, w)){
			//依次检查u的所有邻接点w ，FirstAdjVex(G, u)表示u的第一个邻接点 
			//NextAdjVex(G, u, w)表示u相对于w的下一个邻接点，w≥0表示存在邻接点 
			if(!visited[w]){//w为u的尚未访问的邻接顶点
				cout << G.vexs[w]<<"->";   
				visited[w] = true;
				EnQueue(Q, w);//w进队 
			}
		}
    }
}

int main(){
	Graph G;
	CreateUDN(G);
	cout << endl;
	cout << "无向连通图G创建完成" << endl << endl;
	cout << "请输入遍历连通图的起始点：";
	VerTexType c;
	cin >> c;
	int i;
	for(i = 0 ; i < G.vexnum ; ++i){
		if(c == G.vexs[i]){
			break;
		}
	}
	cout << endl;
	while(i >= G.vexnum){
		cout << "该点不存在，请重新输入！" << endl;
		cout << "请输入遍历连通图的起始点：";
		cin >> c;
		for(i = 0 ; i < G.vexnum ; ++i){
			if(c == G.vexs[i]){
				break;
			}
		}
	}
	cout << "广度优先搜索遍历连通图结果：" << endl;
	BFS(G , i);
	return 0;
}

实验十一 图（2）

一、实验目的与要求

3）掌握最小生成树的概念和算法；

4）掌握最短路径的算法的实现；

5）掌握拓扑排序的应用。

二、实验内容

1.输出所有可能的路径

有n个结点的有向无环图，选取合适的存储方式并找到所有从0到n-1的路径并输出（不要求按顺序）。二维数组的第i个数组中的单元都表示有向图中i号结点所能到达的结点（注：有向图是有方向的，即规定了a→b你就不能从b→a）空就是没有下一个结点了。

示例1：

输入：graph = [[1,2],[3],[3],[]]

输出：[[0,1,3],[0,2,3]]

解释：有两条路径 0 -> 1 -> 3 和 0 -> 2 -> 3

示例2：

输入：graph = [[4,3,1],[3,2,4],[3],[4],[]]

输出：[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]

2.建造物流配送中心问题

给定4个城市之间的交通图如下图所示（图中弧上数字表示城市之间的道路长度）。要在4个城市之间选择一个城市建造一个物流配送中心，并使得到物流配送中心最远的城市到物流配送中心的路程最短。

要求：

（1）设计存储结构表示城市及城市之间的关系；

（2）求出物流配送中心最远城市到物流配送中心的最短路程；

（3）分析算法的时间复杂度。

三、实验结果

1）请将调试通过的主要源代码、运行结果截图粘贴在下面，并说明测试用例、运行过程。（必要的注释、Times New Roman 5号，行间距1.5倍）

2）简述算法步骤（选画技术路线图），格式如下：

S1:

S2:

3）请分析算法的时间复杂度。

4）请将源代码（必要的注释）cpp文件一起压缩上传（上传附件）。

题目1：

（1.1）源代码

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;

//DFS回溯算法——遍历graph[p]，寻找下一个元素，并进行回溯。
void DFS(vector<vector<int> > & graph,vector<int> path,vector<vector<int> >& res,int p){
	int i;
	//在graph[p]中找下一个元素
    for(i=0;i<graph[p].size();i++){
    	//找到最后一个元素，将path加入res
        if(graph[p][i]==graph.size()-1){
            path.push_back(graph.size()-1);
            res.push_back(path);
            path.pop_back();
            continue;
        }
        path.push_back(graph[p][i]);  //不是最后一个元素，继续回溯
        DFS(graph,path,res,graph[p][i]);  //递归调用 
        path.pop_back();
    }
}

//寻找所有到达路径 
vector<vector<int> > allPathsSourceTarget(vector<vector<int> >& graph) {
    vector<vector<int> > res;  //res存储一条路径的所有结点 
    vector<int> path={0};
    DFS(graph,path,res,0);  //调用DFS函数 
    return res;
}

//主函数 
int main() {
	int n;
	cout<<"请输入结点个数：";
	cin>>n;
	vector<vector<int> > store(n);
	cout<<endl<<"请依次输入每个结点的出度以及可达结点的编号："<<endl<<endl;
	for(int i=0;i<n;i++){
		int m;
		cout<<"编号为"<<i<<"的结点的出度：";
		cin>>m;
		cout<<endl<<"该结点可达结点的编号：";
		vector<int> each(m);
		for(int j=0;j<m;j++){
			cin>>each[j];
		}
		cout<<endl;
		store[i]=each;
	}
	vector<vector<int> > res=allPathsSourceTarget(store);
	cout<<endl<<"所有的可能路径如下："<<endl;
	cout<<endl;
	for(int k=0;k<res.size();k++){
		for(int l=0;l<res[k].size();l++){
			if(l==0){
				cout<<res[k][l];
			}
			else{
				cout<<"->"<<res[k][l];
			}
		}
		cout<<endl;
	}
	return 0;
}

（1.2）测试用例

测试用例1：

    如图1所示的4点4边的有向图。寻找0点到3点的所有可能路径。

测试用例2：

    如图2所示的5点8边的有向图。寻找0点到4点的所有可能路径。

（图1）

（图2）

（1.3）运行结果

测试用例1：

测试用例2：

（1.4）运行过程

输入总结点数 -> 输入各结点的出度 -> 输入当前结点可达的结点 -> 调用寻找所有到达路径的函数 -> DFS回溯遍历 -> 输出所有可能的路径。

（2）算法步骤

S1：DFS回溯函数。该函数不仅包含了递归的过程，而且包含了回退的过程。对于一个无向连通图，访问图中某个顶点v0后，然后访问它的某一个邻接顶点v1，然后再从v1出发，访问v1的未访问过的邻接顶点。如此下去，直至到达所有的领接顶点都被访问过。然后回退一步，回到前一次被访问的顶点，看是否还有没有访问的顶点。如果有没有访问的顶点，那么从这个顶点出发，进行向上述的过程一样进行访问；如果无没有访问的顶点，那么再回退一步，进行类似的访问，直至所有的顶点都被访问为止。后续该函数将在寻找所有到达路径函数中被调用。

S2：寻找所有到达路径函数。利用vector<int>向量容器，同时调用DFS回溯函数，将得到的路径结点顺序存储到res数组中，最后返回res数组的结果。后续该函数将在主函数中被调用。

S3：主函数。依次输入结点数、每个结点的出度和当前结点指向的结点，并用数组储存起来。建立起有向图的结构，并明确各个结点之间的连通性。

 

 

（3）算法时间复杂度分析

在遍历有向图时，对于图中每个结点，DFS函数至多调用一次。一旦某个结点被标志为已访问，就不再从当前结点开始进行搜索。对图的遍历实质上是对每个结点查找其邻接点的过程。DFS回溯函数中，使用的是二维数组和向量容器进行存储。因此，查找每个顶点的邻接点所需时间为O(n2)。

因此，本算法的时间复杂度为O(n2)。

题目2：

（1.1）源代码

#include <iostream>
#include <vector>
#define inf 99999
using namespace std;

//邻接矩阵 
int graph[4][4]{
    {0,8,inf,inf},
    {10,0,5,inf},
    {4,inf,0,4},
    {inf,7,3,0},
}; 

int path[4][4]{ 
    {0,1,2,3},
    {0,1,2,3},
    {0,1,2,3},
    {0,1,2,3},
}; 

//最短路径算法 
void solve(int graph[4][4],int path[4][4]){
	int i,j,k;
	for(k=0;k<4;k++) {
        for(i=0;i<4;i++) {
            for(j=0;j<4;j++) {
                if(graph[i][k]+graph[k][j] < graph[i][j]) {
                    graph[i][j] = graph[i][k]+graph[k][j];  //更新最短路径 
                    path[i][j] = path[i][k];
                }
            }
        }
    }
}

//输出邻接矩阵
void Output(int graph[4][4]){
	int i,j;
	for(i=0;i<4;i++){
    	cout<<"[";
    	for(j=0;j<4;j++){
    		if(graph[i][j]==99999){
    			cout<<"inf";
			}
			else{
				cout.width(4);
    			cout<<graph[i][j];
			}
    		if(j!=3){
    			cout<<",";
			}
		}
		cout<<"]\n";
	}
}

//排序最远距离
void Sort(int graph[4][4]){
	int i,j,maxlen[4];//i行j列 
	for(j=0;j<4;j++){
		int maxno=0;
		for(i=0;i<4;i++){
			if(graph[maxno][j]<graph[i][j]){
				maxno=i;
			}
		}
		maxlen[j]=maxno; 
	}
	cout<<"到当前结点最远的距离依次为：";
	for(int k=0;k<4;k++){
		cout<<graph[maxlen[k]][k]<<" ";//第k列的最大数 
	}
	cout<<endl;
	cout<<"其中最小的距离为：";
	int min=graph[maxlen[0]][0],minno=0;
	for(i=1;i<4;i++){
		if(min>graph[maxlen[i]][i]){
			min=graph[maxlen[i]][i];
			minno=i;
		}
	}
	cout<<min<<endl;
	cout<<"所以物流配送中心应该建设的地方为：";
	switch(minno){
		case 0:cout<<"a"<<endl;break;
		case 1:cout<<"b"<<endl;break;
		case 2:cout<<"c"<<endl;break;
		case 3:cout<<"d"<<endl;break;
	}
}

//主函数 
int main() {
	cout<<"初始邻接矩阵:"<<endl; 
	Output(graph);
    solve(graph,path);
    cout<<endl<<"最终邻接矩阵:"<<endl; 
    Output(graph);
    cout<<endl;
    Sort(graph);
    return 0;
}

（1.2）测试用例

测试用例为如下图所示的4点7边的有向图。

预设置的邻接矩阵为：

{0,8,inf,inf}

{10,0,5,inf}

{4,inf,0,4}

{inf,7,3,0}

（1.3）运行结果

（1.4）运行过程

预先设置初始邻接矩阵 -> 输出初始邻接矩阵 -> 将每一个结点进行最小路径函数调用 -> 输出最小路径条件下的邻接矩阵 -> 排序离当前结点的最远距离 -> 寻找最远距离中的最小值和最小值对应的结点并输出。

（2）算法步骤

S0：初始化。预先设置邻接矩阵graph和存储路径的二维数组path。

S1：最短路径算法函数。利用三层for循环，遍历图的所有路径，同时根据判断条件得到当前的最短路径，并更新最短路径，从而使graph中的数据得以更新。

S2：输出邻接矩阵函数。按照矩阵的形式，输出结果最短路径算法更新后的邻接矩阵。

S3：排序最远距离函数。首先通过两层for循环寻找所有结点到当前结点的最远距离，并通过maxlen数组存储。之后通过一层for循环寻找maxlen数组中的最小值，并记录最小值对应的结点序号。最后统一输出每一个结点的最远物流距离，最小的最远物流距离及其对应结点。

S4：主函数。在主函数中依次调用输出邻接矩阵函数（最初的状态）、最短路径算法函数、输出邻接矩阵函数（给每个结点均进行了戴克斯特拉算法的状态）、排序最远距离函数，即可得到物流中心的建设结果和计算分析过程。

（3）算法时间复杂度分析

在最短路径算法函数中，使用了三层for循环来更新最短路径，对于邻接矩阵的每一行而言，耗费的时间为O(n3)。

在排序最远距离函数中，使用了两层for循环来寻找每个结点的最远物流距离，耗费的时间为O(n2)；并使用了一层for循环来寻找最远物流距离中的最小值，耗费的时间为O(n)。

因此，本算法的时间复杂度为O(n3)。

MorleyOlsen
关注
  • 3
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构之图实验
// 在校菜鸟大学生的日常学习博客
09-01 2563
图实验实验目的实验环境实验要求实验内容源代码运行结果 实验目的 通过完成本实验，掌握图的基本的存储结构（邻接矩阵、邻接表），以及图的基本算法实现（建立、遍历），并能运用图结构分析解决一些实际问题。 本实验训练的要点是：图的邻接矩阵存储结构，及各种操作的算法实现（建立、遍历）。 实验环境 CodeBlocks 实验要求 熟悉c语言的语法知识； 掌握图的邻接矩阵存储结构及其定义、构造、遍历等基本操作； 实验内容 完成图的定义、存储、插入顶点、插入边、删除顶点和删除边等函数的编写，已知一个有向图的顶点集V
数据结构实验 图
WZY22502701的博客
06-19 426
熟悉图的两种常用的存储结构，以及在这两种存储结构上的两种遍历图的方法，即深度优先遍历和广度优先遍历。进一步掌握递归算法的设计方法。
C语言 图的建立（邻接矩阵与邻接表）
m0_73070900的博客
05-25 4551
5Cinfty。
数据结构实验——图的基本操作
02-12
一、实验目的 1、掌握图的存储方式 2、 掌握图的相关操作 二、实验内容 1、实现拓扑排序算法。
数据结构实验——图
04-06
文件：包括图的文件存储，及对照表。代码：包括从文件读取并创建图，打印图的两种遍历序，深/广度优先遍历生成树或森林，Prim算法，Kruskal算法，Dijkstra算法，Floyd算法，求解AOE网关键路径。包含相应头文件及cpp文件，可直接在codeblocks上运行。
数据结构图实验
qq_52544734的博客
06-10 842
tree.h #ifndef _TREE_H_ #define _TREE_H_ #include <iostream> #include <queue> using namespace std; //树（森林）的孩子兄弟链表表示 typedef char elementType; typedef struct csNode { elementType data; struct csNode *firstChild, *nextSibling; }csNode,
数据结构实验9：图的相关操作
u25th_engineer的博客
01-05 5925
                                                目录                                                  实验9 8.1 实验目的 8.2 实验任务 8.3 实验说明 1. 数据文件格式设计 2. 从数据文件创建邻接矩阵表示的图 3. 从数据文件创建邻接表表示的图 4. 图的销毁 8...
数据结构实验十一：图实验
06-05
实验十一：图实验 　采用邻接表存储有向图，设计算法判断任意两个顶点间手否存在路径。 二，问题分析 　本程序要求采用邻接表存储有向图，设计算法判断任意两个顶点间手否存在路径，完成这些操作需要解决的关键...
数据结构实验报告及全套代码.zip
07-29
数据结构实验报告及全套代码：实验一熟悉环境 实验二 顺序表的基本操作 实验三 单链表 实验四 双向链表 实验五 栈的操作 实验六 队列 实验七 串的操作 实验八数组操作 实验九二叉树的遍历 实验十 二叉树的应用 实验...
数据结构实验报告(1) - 线性表
01-21
数据结构实验报告(1) - 线性表
数据结构实验 图的遍历
10-23
图也是数据结构里的重要知识点，能够实现语言编写实现图的性质和操作，也需要有点语言功底啊。。。
数据结构试验4-图实验报告及源码
03-08
数据结构图的实验报告，内含源码。需要的放心下载！
数据结构与算法实验指导实验十一.doc
05-06
数据结构与算法实验指导实验十一.doc
数据结构第三版C语言-实验1.doc
08-26
为了达到上述目的，本课程安排了十一个实验项目，每个项目训练重点在于基本的数据结构，而不强调面面俱到。每个实验题目提交的成果都是两个部分，一个是实验报告，一个是源程序文件。实验报告以word文档格式提交，...
数据结构 实验10~11 图及其应用
qq_55793988的博客
06-17 596
实验目的：熟悉图的基本概念、逻辑特性、存储表示方法、基本操作和基本应用。 实验要求：熟悉图的基本概念、逻辑特性、存储表示方法，实现无向网的存储表示、图的深度优先搜索遍历、广度优先搜索遍历、单源最短路径算法。 实验内容 编写程序，实现以下功能： (1) 实现交通网、通信网或局域网的邻接矩阵存储表示，设数据元素类型为字符串（如地名、房间号等）。 (2) 实现该网的深度和广度优先搜索遍历，输出遍历结果。 (3) *实现上述网络的邻接表存储表示，实现其广度优先搜索遍历，输出遍历结果。 (4) *求从一
【数据结构 图】数据结构实验--图及其应用
Young12138的博客
11-17 2718
数据结构实验–图及其应用 （代码有纰漏 仅供自己后期修改保存用） 设计并验证如下算法：带权图采用邻接表表示，实现无向图的广度优先搜索与有向图的深度优先搜索。 #define MAX_VERTEX_NUM 20 //图的邻接表存储表示 typedef struct ArcNode{ int adjvex； //该弧所指向的顶点的位置 struct ArcNode *nextarc； //指向下一...
数据结构 实验四 图
weixin_30268071的博客
11-17 243
数据结构 实验四 图 这次给出图论部分的数据结构相关代码，由于图结构不像树结构那样具有明显的层次性，较实验三的二叉树来说会复杂一些；在图的存储结构中，邻接矩阵的存储方式较为简单明了，但是在实际开发中往往由于其会导致占用大量的内存空间而被舍弃，但邻接表这样的链式结构就解决了这一的问题，所以对邻接表的掌握较为重要。 下面放出图的相关代码： #include &l...
数据结构实验
Sophia_fez的博客
02-02 3512
下载地址：http://download.csdn.net/download/xunciy/10237667 1约瑟夫环 2.表达式求值 3.树的遍历 4.哈弗曼树 5 图的遍历 第五次上机实验 基本要求： 分别以邻接表和邻接矩阵为存储结构， 实现图的深度优先和广度优先遍历; 以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集。 测试数据：
数据结构图的实验原理
最新发布
12-18
根据提供的引用内容，数据结构图的实验原理包括以下内容： 1.了解链式储存结构的基本操作，包括链表的创建、插入、删除等操作。 2.实现链栈的初始化、入栈、出栈和取栈顶元素等操作。 3.掌握树和二叉树的实现，包括二叉树的遍历、查找、插入、删除等操作。 4.掌握图的有关算法，如创建、遍历、连通分量、生成树/最小生成树算法（如Prim、Kruskal算法）等。 5.掌握查找算法，包括顺序查找、二分查找、哈希查找等。 6.掌握排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。 7.进行数据处理综合实验，包括对链表、栈、队列、树、图等数据结构的综合应用。 因此，数据结构图的实验原理主要包括对链式储存结构、树和二叉树、图的算法、查找算法、排序算法以及数据处理综合实验的掌握和应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MorleyOlsen

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值