图的两种遍历

最新推荐文章于 2021-12-24 20:24:07 发布
最新推荐文章于 2021-12-24 20:24:07 发布
阅读量335 收藏 4
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51681435/article/details/119951849
版权

深度优先搜索

广度优先搜索

1深度优先搜索

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

//算法6.3　深度优先搜索遍历连通图的递归算法

#include <iostream>
using namespace std;

#define MVNum 100									//最大顶点数
typedef char VerTexType;							//假设顶点的数据类型为字符型 
typedef int ArcType;                 				//假设边的权值类型为整型 

typedef struct{ 
	VerTexType vexs[MVNum];            				//顶点表 
	ArcType arcs[MVNum][MVNum];      				//邻接矩阵 
	int vexnum,arcnum;                				//图的当前点数和边数 
}Graph;
 
bool visited[MVNum];           					//访问标志数组，其初值为"false" 
int FirstAdjVex(Graph G , int v);				//返回v的第一个邻接点
int NextAdjVex(Graph G , int v , int w);		//返回v相对于w的下一个邻接点

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

void CreateUDN(Graph &G){ 
    //采用邻接矩阵表示法，创建无向网G 
	int i , j , k;
	cout <<"请输入总顶点数，总边数 , 以空格隔开:";
    cin >> G.vexnum >> G.arcnum;						 //输入总顶点数，总边数
	cout << endl;

	cout << "输入点的名称，如 a：" << endl;

    for(i = 0; i < G.vexnum; ++i){   
		cout << "请输入第" << (i+1) << "个点的名称:";
		cin >> G.vexs[i];                        		 //依次输入点的信息 
	}
	cout << endl;

    for(i = 0; i < G.vexnum; ++i)                		 //初始化邻接矩阵，边的权值均置为极大值MaxInt 
		for(j = 0; j < G.vexnum; ++j)   
			G.arcs[i][j] = 0;  
	cout << "输入边依附的顶点，如：a b" << 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[j][i] = G.arcs[i][j] = 1;                 //置<v1, v2>的对称边<v2, v1>的权值为w 
	}//for
}//CreateUDN 

void DFS(Graph G, int v){        			//从第v个顶点出发递归地深度优先遍历图G 
	cout << G.vexs[v] << "    ";  visited[v] = true;   	//访问第v个顶点，并置访问标志数组相应分量值为true 
	int w;
	for(w = FirstAdjVex(G, v);  w >= 0;  w = NextAdjVex(G, v, w))  
		//依次检查v的所有邻接点w ，FirstAdjVex(G, v)表示v的第一个邻接点 
		//NextAdjVex(G, v, w)表示v相对于w的下一个邻接点，w≥0表示存在邻接点 
		if(!visited[w]) DFS(G, w);    					//对v的尚未访问的邻接顶点w递归调用DFS 
}//DFS

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;
}//FirstAdjVex

int NextAdjVex(Graph G , int v , int w){
	int i;
	for(i = w ; i < G.vexnum ; ++i){
		if(G.arcs[v][i] == 1 && visited[i] == false)
			return i;
	}
	return -1;
}//NextAdjVex

int main(){
	cout << "************算法6.3　深度优先搜索遍历连通图的递归算法**************" << endl << endl;
	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;
	DFS(G , i);

	cout <<endl;
	return 0;
}//main

//算法6.5　采用邻接矩阵表示图的深度优先搜索遍历

#include <iostream>
using namespace std;

#define MVNum 100							//最大顶点数
typedef char VerTexType;					//假设顶点的数据类型为字符型 
typedef int ArcType;                 		//假设边的权值类型为整型 

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

bool visited[MVNum];           				//访问标志数组，其初值为"false" 
int FirstAdjVex(Graph G , int v);			//返回v的第一个邻接点
int NextAdjVex(Graph G , int v , int w);	//返回v相对于w的下一个邻接点

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

void CreateUDN(Graph &G){ 
    //采用邻接矩阵表示法，创建无向网G 
	int i , j , k;
	cout <<"请输入总顶点数，总边数，以空格隔开:";
    cin >> G.vexnum >> G.arcnum;							//输入总顶点数，总边数
	cout << endl;
	
	cout << "输入点的名称，如a" <<endl;

    for(i = 0; i < G.vexnum; ++i){   
		cout << "请输入第" << (i+1) << "个点的名称:";
		cin >> G.vexs[i];                        			//依次输入点的信息 
	}	
	cout << endl;

    for(i = 0; i < G.vexnum; ++i)                			//初始化邻接矩阵，边的权值均置为极大值MaxInt 
		for(j = 0; j < G.vexnum; ++j)   
			G.arcs[i][j] = 0;  
	cout << "输入边依附的顶点，如a b" << 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[j][i] = G.arcs[i][j] = 1;					//置<v1, v2>的对称边<v2, v1>的权值为w 
	}//for
}//CreateUDN 

void DFS(Graph G, int v){        		
	//图G为邻接矩阵类型 
	int w;
	cout << G.vexs[v] << "    ";  visited[v] = true;  		//访问第v个顶点，并置访问标志数组相应分量值为true 
	for(w = 0; w < G.vexnum; w++)  							//依次检查邻接矩阵v所在的行  
		if((G.arcs[v][w] != 0)&& (!visited[w]))  DFS(G, w); //G.arcs[v][w]!=0表示w是v的邻接点，如果w未访问，则递归调用DFS 
}//DFS

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

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

int main(){
	cout << "************算法6.5　采用邻接矩阵表示图的深度优先搜索遍历**************" << endl << endl;
	Graph G;
	CreateUDN(G);
	cout << endl;
	cout << "无向图G创建完成！" << endl << endl;
	
	cout << "请输入遍历无向图G的起始点：";
	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 << "深度优先搜索遍历无向图G结果：" << endl;
	DFS(G , i);

	cout <<endl;
	return 0;
}//main

//算法6.6　采用邻接表表示图的深度优先搜索遍历

#include <iostream>
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" 

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

void CreateUDG(ALGraph &G){ 
	//采用邻接表表示法，创建无向图G
	int i , k;
	
	cout <<"请输入总顶点数，总边数，以空格隔开:";
	cin >> G.vexnum >> G.arcnum;				//输入总顶点数，总边数 
    cout << endl;
	
	cout << "输入点的名称，如a" << endl;

	for(i = 0; i < G.vexnum; ++i){          	//输入各点，构造表头结点表
		cout << "请输入第" << (i+1) << "个点的名称:";
		cin >> G.vertices[i].data;           	//输入顶点值 
		G.vertices[i].firstarc=NULL;			//初始化表头结点的指针域为NULL 
    }//for
	cout << endl;
    
	cout << "输入边依附的顶点，如a b" << 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的边表头部 
    }//for 
}//CreateUDG

void DFS(ALGraph G, int v){        				//图G为邻接表类型 
	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指向下一个边结点 
	} 
}//DFS

int main(){
	cout << "************算法6.6　采用邻接表表示图的深度优先搜索遍历**************" << endl << endl;
	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);
	
	cout <<endl;
	return 0;
}//main

在这里插入图片描述

广度优先搜索

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//算法6.7　广度优先搜索遍历连通图

#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;

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

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

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

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

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

void CreateUDN(Graph &G){ 
    //采用邻接矩阵表示法，创建无向网G 
	int i , j , k;
	cout <<"请输入总顶点数，总边数，以空格隔开:";
    cin >> G.vexnum >> G.arcnum;							//输入总顶点数，总边数
	cout << endl;
	cout << "输入点的名称，如a" << endl;
    for(i = 0; i < G.vexnum; ++i){   
		cout << "请输入第" << (i+1) << "个点的名称:";
		cin >> G.vexs[i];                        			//依次输入点的信息 
	}
	cout << endl;
    for(i = 0; i < G.vexnum; ++i)                			//初始化邻接矩阵，边的权值均置为极大值MaxInt 
		for(j = 0; j < G.vexnum; ++j)   
			G.arcs[i][j] = 0; 
	cout << "输入边依附的顶点，如a b" << 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 
	}//for 
}//CreateUDN

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

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

void BFS (Graph G, int v){ 
    //按广度优先非递归遍历连通图G 
	sqQueue Q;
	ArcType u;
	ArcType w;

    cout << G.vexs[v] << "  ";    visited[v] = true;     						//访问第v个顶点，并置访问标志数组相应分量值为true 
    InitQueue(Q);              													//辅助队列Q初始化，置空         
    EnQueue(Q, v);            													//v进队 
    while(!QueueEmpty(Q)){   													//队列非空 
		DeQueue(Q, u);       													//队头元素出队并置为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;					//访问w，并置访问标志数组相应分量值为true 
				EnQueue(Q, w);													//w进队 
			}//if 
		}//for
    }//while 
}//BFS 

int main(){
	cout << "************算法6.7　广度优先搜索遍历连通图**************" << endl << endl;
	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);
	
	cout <<endl;
	return 0;
}//main

在这里插入图片描述
在这里插入图片描述

以强大回敬热爱
关注
专栏目录
图的遍历
qq_43873385的博客
01-23 321
图是一种比线性表和树更为复杂的数据结构。图的存储结构虽然没有顺序结构，但是它可以借助二维数组来表示元素之间的关系，即邻接矩阵表示法。图的链式存储有多种，邻接表、十字链表和邻接多重表。 用邻接矩阵表示法表示图，除了一个用于存储邻接矩阵的二维数组外，还要一个一维数组来存储顶点信息。 【形式说明】 #define MaxInt 32767 //表示极大值 #define MVNum 100 //...
图与图的遍历
DFGOMC的博客
11-15 323
图与图的遍历 本文参考自《大话数据结构》 定义 图(graph)是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。 注意 在图中数据元素，我们则称之为顶点(Vertex)； 在图结构中，不允许没有顶点； 在图中，任意两个顶点之间都可能有关系，顶点之间的逻辑关系用边来表示，边集可以是空的； 各种图定义 无向边 ：若顶点vi到vj之间的边没有方向，则称这条边为无向边(Edge)，用无序偶对(vi,vj)表示。如果图中任
DFS遍历连通图
weixin_54418006的博客
12-16 1230
//深度优先搜索遍历连通图的递归算法 #include<iostream> using namespace std; #define MVNum 100 typedef char VerTexType; typedef int ArcType; typedef struct { VerTexType vexs[MVNum]; // 顶点表 ArcType arcs[MVNum][MVNum]; // 邻接矩阵 int vexnum, arcnum; }Graph; bool visited
第六章 6.5 图的遍历
loving coding
12-08 239
深度优先搜索 采用邻接矩阵表示图的深度优先搜索遍历 #include using namespace std; #define MaxInt 32767 #define MVNum 100 #define OK 1 bool visited[MaxInt]; typedef char VerTexType; typedef int ArcType; typedef int Status
掌握图的两种遍历算法深度优先搜索和广度优先搜索算.doc
12-01
图的遍历是图论中的基础操作，主要包含两种主要...掌握DFS和BFS这两种遍历算法对于理解图的性质和解决图相关问题至关重要。在实际编程中，根据问题的具体需求，选择合适的遍历算法和图的存储结构，可以提高算法的效率。
图的两种遍历方法
热门推荐
qq_47664976的博客
05-31 1万+
图的遍历 图的遍历是指，从给定图中任意指定的顶点（称为初始点）出发，按照某种搜索方法沿着图的边访问图中的所有顶点，使每个顶点仅被访问一次，这个过程称为图的遍历。 图的遍历过程根据搜索方法的不同，又可划分为两种搜索策略 1.深度优先遍历 2.广度优先遍历 算法思想 1.深度优先遍历（dfs） 深度优先遍历的步骤 访问顶点V 依次从顶点V的未被访问的邻节点出发，进行深度优先搜索，直至和V有路径相通的顶点都被访问到。 对于连通图进行遍历时，从一个顶点出发即可访问图中所有的顶点。 对于非连通图进行遍历时，若图中尚
数据结构实验代码图的两种遍历.rar
最新发布
05-01
本实验主要探讨了图的两种遍历方法：深度优先搜索（DFS）和广度优先搜索（BFS）。 深度优先搜索（DFS）是一种递归的遍历策略，它尽可能深地探索图的分支。DFS的基本思想是从起点开始，选择一个未访问过的邻接节点...
数据结构关于图的两种遍历方法
12-19
图的两种遍历的具体实现方法加注释。具体实现采用C++语言，有头文件travsal也可以直接把头文件中函数放到主函数中使用。
c语言队头元素出队并置为u,数据结构课程设计图的存储与遍历.doc
weixin_33074843的博客
05-22 366
数据结构课程设计图的存储与遍历中南大学题 目学生姓名指导教师学 院专业班级完成时间课程设计目的1.1掌握图的邻接表存贮结构。1.2掌握队列的基本运算实现。1.3掌握图的邻接表的算法实现。1.4掌握图的广度优先搜索周游算法实现。1.5掌握图的深度优先搜索周游算法实现第二章 设计内容和要求对任意给定的图(顶点数和边数自定)，建立它的邻接表并输出，然后利用队列的五种基本运算(置空队列、进队、...
算法学习 之遍历
东湖畔
05-22 158
/********************广度优先遍历算法*******************/ void BFSTraverse(Graph G, Status (*Visit)(int v)) { // 按广度优先非递归遍历图G。使用辅助队列Q和访问标志数组visited。 for (v=0; v&lt;G.vexnum; ++v) visited[v] = FALS...
图的遍历 - 数据结构
weixin_30457881的博客
07-04 2753
概述 图的遍历是指从图中的任一顶点出发，对图中的所有顶点访问一次且只访问一次。图的遍历操作和树的遍历操作功能相似。图的遍历是图的一种基本操作，图的其它算法如求解图的连通性问题，拓扑排序，求关键路径等都是建立在遍历算法的基础之上。 由于图结构本身的复杂性，所以图的遍历操作也较复杂，主要表现在以下四个方面： ① 在图结构中，没有一个“自然”的首结点，图中任意一个顶点都...
图的深度优先遍历和广度优先遍历
yangshuangtao的专栏
12-09 1138
图的深度优先遍历和广度优先遍历 图的深度优先遍历和广度优先遍历 图的深度优先遍历和广度优先遍历 图的深度优先遍历：V1 V2 V4 V8 V5 V3 V6 V7 图的广度优先遍历：V1 V2 V3 V4 V5 V6 V7 V8 #include #include #include using namespace std; struct _ArcInfo {
图的深度优先遍历算法的c语言,C语言实现图的遍历之深度优先搜索实例
weixin_39577052的博客
05-27 272
C语言实现图的遍历之深度优先搜索实例时间：2021-05-20DFS(Depth-First-Search)深度优先搜索算法是图的遍历算法中非常常见的一类算法。分享给大家供大家参考。具体方法如下：#include #include #include using namespace std; #define MAX_VERTEX_NUM 10struct Node{ int adjvex; str...
深度优先搜索DFS递归实现图的遍历
小鱼的小窝
12-12 1086
DFS遍历图
邻接矩阵广度优先遍历算法 连通图采用邻接表深度优先遍历的非递归过程 图G中距离顶点v的最短路径长度最大迪杰斯特拉
qq_54008392的博客
12-24 3753
1.采用邻接矩阵存储图的广度优先遍历算法的实现(参考教材算法6.5选作)。 2.一个连通图采用邻接表作为存储结构，设计一个算法，实现从顶点v出发的深度优先遍历的非递归过程。 3.设计一个算法，求图G中距离顶点v的最短路径长度最大的一个顶点，设v可达其余各个顶点。 1 //算法6.7　广度优先搜索遍历连通图 #include <iostream> using namespace std; #define MVNum 100 //最大顶点数
数据结构-图的遍历
weixin_30432007的博客
12-13 463
#include <stdio.h>#include <stdlib.h>#define MAX_Vertex_NUM 20 //图的最大顶点数#define MAXQSIZE 30 //队列的最大容量 #define INFINITY 32768 /*表示极大值，即∞*/#define TRUE 1#define FALSE...
深度优先搜索遍历算法的实现
qq_61743064的博客
12-14 271
void DFS(AMG G,int V){ cout<<v;vistited[v]=ture; for(w=0;w<G.vexnum;w++){ if(G.Arcs[v][w]!=0(!visited[w])){ DFS(G,W); } } }
无向图的两种遍历C++
05-03
无向图的两种遍历方法为深度优先搜索和广度优先搜索。 深度优先搜索（DFS）是一种先访问一个顶点，然后再依次访问这个顶点的每个邻接点，并且对于每个邻接点，重复以上过程的遍历方法。在遍历过程中，需要使用一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值