图的遍历总结

DFS
邻接矩阵存储图
注意：如果G是一个连通图，那么只需要一次DFS就行了。

const int maxn = 1000;
const int INF = 1000000;
int n, G[maxn][maxn];
bool vis[maxn] = {false};


//访问u所在的连通块
void DFS(int u, int depth)  //u为当前访问的顶点标号，depth为深度
{
    vis[u] = true;      //标记u已访问
    //如果需要对u进行操作，可以在这里进行
    //下面对所有从u出发能到达的分支顶点进行枚举
    for(int v = 0; v < n; v++)   //对每个顶点
    {
        if(vis[v] == false && G[u][v] != INF)   //如果v未被访问且u能到达v
        {
            DFS(v, depth + 1)       //访问v，深度+1
        }
    }
}


void DFSTrave()     //遍历图G
{
    for(int u = 0; u < n; u++)      //对每个顶点u
    {
        if(vis[u] == false)         //如果u未被访问
            DFS(u, 1);              //访问u和u所在的连通块，1表示初始为第一层
    }
}

邻接表存储图

vector<int> Adj[maxn];
int n;
bool vis[maxn] = {false};

void DFS(int u, int depth)
{
    vis[u] = true;
    for(int i = 0; i < Adj[u].size(); i++)	//这里与邻接矩阵不同
    {
        int v = Adj[u][i];
        if(vis[v] == false)
            DFS(v, depth + 1)
    }
}

void DFSTrave()
{
    for(int u = 0; u < n; u++)
    {
        if(vis[u] == false)
            DFS(u, 1);
    }
}

BFS
邻接矩阵存储图
注意：如果G是一个连通图，那么只需要一次DFS就行了。

const int maxn = 510;      
const int INF = 1000000;
int n, G[maxn][maxn];
bool inq[maxn] = {false};

void BFS(int u)     //遍历u所在的连通块
{
    queue<int> q;   //定义队列
    q.push(u);      //初始节点u入队
    inq[u] = true;  //标记u已入队
    while(!q.empty())
    {
        int u = q.front();      //取队首元素
        q.pop();                //队首元素出队
        for(int v = 0; v < n; v++)
        {
            if(inq[v] == false && G[u][v] != INF)   //如果u的邻接点v未曾加入过队列
            {   
                q.push(v);                  //将v入队
                inq[v] = true;              //标记v已入队
            }
        }
    }
}


void BFSTrave()     //遍历图G
{
    for(int u = 0; u < n; u++)      //对于所有顶点
    {
        if(inq[u] == false)     //如果u未曾加入过队列
            BFS(u);             //遍历u所在的连通块
    }
}

邻接表存储图

vector<int> Adj[maxn];
int n;
bool inq[maxn] = {false};

void BFS(int u)
{
    queue<int> q;
    q.push(u);
    inq[u] = true;
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        for(int i = 0; i < Adj[u].size(); i++)	//这里与邻接矩阵不同
        {
            int v = Adj[u][i];
            if(inq[v] == false)
            {
                q.push(v);
                inq[v] = true;
            }
        }
    }
}

void BFSTrave()
{
    for(int u = 0; u < n; u++)
    {
        if(inq[u] == false)
            BFS(u);
    }
}

如果还要存放结点的定点编号和层号

struct node
{
    int v, layer;
};

这种情况下，vector邻接表中的元素就不再是int，而变成node。

vector <node> Adj[N];

struct node
{
	int v;
	int layer;
};
vector <node> Adj[N];
int n;
bool inq[maxn] = {false};

void BFS(int s)
{
    queue<node> q;
    node start;
    start.v = s;
    start.layer = 0;
    q.push(start);
    inq[start.v] = true;
    while(!q.empty())
    {
        node topnode = q.front();
        q.pop();
        int u = topnode.v;
        for(int i = 0; i < Adj[u].size(); i++)
        {
            node next = Adj[u][i];
            next.layer = topnode.layer + 1;
            if(inq[next.v] == false)
            {
                q.push(next);
                inq[next.v] = true;
            }
        }
    }
}