算法笔记-图-图的遍历

目录

• 深度优先遍历（DFS）
  • 邻接表（DFS）
  • 邻接矩阵（DFS）
• 广度优先遍历（BFS）
  • 邻接表（BFS 无层级统计）
  • 邻接表（BFS 含层级统计）
  • 邻接矩阵（BFS 无层级统计）
  • 邻接矩阵（BFS 含层级统计）

深度优先遍历（DFS）

邻接表（DFS）

#include <iostream>
#include <vector>
using namespace std;
const int maxn=10;
vector<int> g[maxn];
int n,vis[maxn];
void dfs(int v, int h) {
	vis[v]=1;
	// 层级相关处理，或者对当前访问顶点的处理
	for(int i=0; i<g[v].size(); i++) {
		if(vis[g[v][i]]==0) {
			dfs(g[v][i],h+1);
		}
	}
}
void dfs_travel() {
	for(int i=0; i<n; i++) {
		if(vis[i]==0) {
			dfs(i,1); //起始高度假设为1
			// 统计连通分量
		}
	}
}
int main(int argc,char * argv[]) {
	scanf("%d",&n);
	int a,b;
	for(int i=0;i<n;i++){
		scanf("%d %d",&a,&b);
		g[a].push_back(b);
		g[b].push_back(a);
	}
	dfs_travel();
	return 0;
}

邻接矩阵（DFS）

#include <iostream>
#include <vector>
using namespace std;
const int maxn=10;
int g[maxn][maxn];
int n,vis[maxn];
void dfs(int v, int h) {
	vis[v]=1;
	// 层级相关处理，或者对当前访问顶点的处理
	for(int i=1; i<=n; i++) {
		if(g[v][i]==1 && vis[i]==0) {
			dfs(i, h+1);
		}
	}
}
void dfs_travel() {
	for(int i=1; i<=n; i++) {
		if(vis[i]==0) {
			dfs(i,1); //起始高度假设为1
			// 统计连通分量
		}
	}
}
int main(int argc,char * argv[]) {
	scanf("%d",&n);
	int a,b;
	for(int i=1; i<=n; i++) { //顶点编号从1开始 
		scanf("%d %d",&a,&b);
		g[a][b]=1;
		g[b][a]=1;
	}
	dfs_travel();
	return 0;
}

广度优先遍历（BFS）

邻接表（BFS 无层级统计）

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int maxn=10;
vector<int> g[maxn];
int n,vis[maxn];
void bfs(int v) {
	queue<int> q;
	q.push(v);
	vis[v]=1;
	while(!q.empty()){
		int w = q.front();
		q.pop();
                // 层级相关处理，或者对当前访问顶点的处理
		for(int i=0;i<g[w].size();i++){
			if(vis[g[w][i]]==0){
				q.push(g[w][i]);
				vis[g[w][i]]=1; 
			}
		}
	}
}
void bfs_travel() {
	for(int i=0; i<n; i++) {
		if(vis[i]==0) {
			bfs(i); //起始高度假设为1
			// 统计连通分量
		}
	}
}
int main(int argc,char * argv[]) {
	scanf("%d",&n);
	int a,b;
	for(int i=0;i<n;i++){
		scanf("%d %d",&a,&b);
		g[a].push_back(b);
		g[b].push_back(a);
	}
	bfs_travel();
	return 0;
}

邻接表（BFS 含层级统计）

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int maxn=10;
vector<int> g[maxn];
int n,vis[maxn];
struct node{
	int v;
	int h; 
};
void bfs(int v) {
	queue<node> q;
	q.push({v,1}); //初始层级为1 
	vis[v]=1;
	while(!q.empty()){
		node w = q.front();
		q.pop();
                // 层级相关处理，或者对当前访问顶点的处理
		for(int i=0;i<g[w.v].size();i++){
			if(vis[g[w.v][i]]==0){
				q.push({g[w.v][i],w.h+1});
				vis[g[w.v][i]]=1; 
			}
		}
	}
}
void bfs_travel() {
	for(int i=0; i<n; i++) {
		if(vis[i]==0) {
			bfs(i); //起始高度假设为1
			// 统计连通分量
		}
	}
}
int main(int argc,char * argv[]) {
	scanf("%d",&n);
	int a,b;
	for(int i=0;i<n;i++){
		scanf("%d %d",&a,&b);
		g[a].push_back(b);
		g[b].push_back(a);
	}
	bfs_travel();
	return 0;
}

邻接矩阵（BFS 无层级统计）

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int maxn=10;
int g[maxn][maxn];
int n,vis[maxn];
void bfs(int v) {
	queue<int> q;
	q.push(v);
	vis[v]=1;
	while(!q.empty()) {
		int w = q.front();
		q.pop();
                // 层级相关处理，或者对当前访问顶点的处理
		for(int i=1; i<=n; i++) {
			if(g[w][i]==1 && vis[i]==0) {
				q.push(i);
				vis[i]=1;
			}
		}
	}
}
void bfs_travel() {
	for(int i=1; i<=n; i++) {
		if(vis[i]==0) {
			bfs(i); //起始高度假设为1
			// 统计连通分量
		}
	}
}
int main(int argc,char * argv[]) {
	scanf("%d",&n);
	int a,b;
	for(int i=1; i<=n; i++) { //顶点编号从1开始
		scanf("%d %d",&a,&b);
		g[a][b]=1;
		g[b][a]=1;
	}
	bfs_travel();
	return 0;
}

邻接矩阵（BFS 含层级统计）

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int maxn=10;
int g[maxn][maxn];
int n,inq[maxn];
struct node {
	int v;
	int h;
};
void bfs(int v) {
	queue<node> q;
	q.push({v,1}); //初始层级为1
	inq[v]=1;
	while(!q.empty()) {
		node w = q.front();
		q.pop();
		// 层级相关处理，或者对当前访问顶点的处理
		for(int i=1; i<=n; i++) {
			if(g[w.v][i]==1 && inq[i]==0) {
				q.push({i,w.h+1});
				inq[i]=1;
			}
		}
	}
}
void bfs_travel() {
	for(int i=1; i<=n; i++) {
		if(inq[i]==0) {
			bfs(i); //起始高度假设为1
			// 统计连通分量
		}
	}
}
int main(int argc,char * argv[]) {
	scanf("%d",&n);
	int a,b;
	for(int i=1; i<=n; i++) {
		scanf("%d %d",&a,&b);
		g[a][b]=1;
		g[b][a]=1;
	}
	bfs_travel();
	return 0;
}