刷题笔记-图-图的遍历

目录

• 深度优先遍历（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;
}

来源：https://www.cnblogs.com/houzm/p/12370470.html