图的深度优先搜索（DFS）、广度优先搜索（BFS）

深度优先搜索（DFS）、广度优先搜索（BFS）

图的邻接矩阵形式

#include <iostream>
#include <queue>
#include <stack>
#define MAX 100

typedef struct
{
    int edges[MAX][MAX];    //邻接矩阵
    int n;                  //顶点数
    int e;                  //边数
}MGraph;

bool visited[MAX];          //标记顶点是否被访问过

void CreatMGraph(MGraph &G)    //用引用作参数
{
    int i, j;
    int s, t;                 //存储顶点编号
    int v;                   //存储边的权值
    for(i = 0; i < G.n; i ++)       //初始化
    {
        for(j = 0; j < G.n; j ++)
        {
            G.edges[i][j] = 0;
        }
    }

    std::cout << "输入边的顶点编号和权值:" << std::endl;
    for(i = 0; i < G.e; i ++)      //对矩阵相邻的边赋权值
    {
        std::cin >> s >> t >> v;   //输入边的顶点编号以及权值
        G.edges[s][t] = v;
    }
}

//深度优先搜索递归实现
void DFS(MGraph G, int v)
{
    int i;
    std::cout << v << " ";          //访问结点v
    visited[v] = true;
    for(i = 0; i < G.n; i ++)       //访问与v相邻的未被访问过的结点
    {
        if(G.edges[v][i] != 0 && visited[i] == false)
        {
            DFS(G,i);
        }
    }
}

//深度优先搜索非递归实现，借助于栈
void DFS1(MGraph G, int v)
{
    std::stack<int> s;
    std::cout << v << " ";        //访问初始结点
    visited[v] = true;
    s.push(v);              //入栈
    while(!s.empty())
    {
        int i, j;
        i=s.top();          //取栈顶顶点
        for(j = 0; j < G.n; j++)  //访问与顶点i相邻的顶点
        {
            if(G.edges[i][j] != 0 && visited[j] == false)
            {
                std::cout << j << " ";     //访问
                visited[j] = true;
                s.push(j);           //访问完后入栈
                break;               //找到一个相邻未访问的顶点，访问之后则跳出循环
            }
        }
        if(j == G.n)                   //如果与i相邻的顶点都被访问过，则将顶点i出栈
            s.pop();
    }
}

//广度优先搜索，借助于队列
void BFS(MGraph G, int v)
{
    std::queue<int> Q;             //STL模板中的queue
    std::cout << v << " ";
    visited[v] = true;
    Q.push(v);
    while(!Q.empty())
    {
        int i, j;
        i=Q.front();         //取队首顶点
        Q.pop();
        for(j = 0; j < G.n; j ++)   //广度遍历
        {
            if(G.edges[i][j] != 0 && visited[j] == false)
            {
                std::cout << j << " ";
                visited[j] = true;
                Q.push(j);
            }
        }
    }
}

int main()
{
    int n, e;    //建立的图的顶点数和边数

    while(1)
    {
        std::cout << "请输入建立的图的顶点数n和边数e:"<< std::endl;
        std::cin >> n >> e;
        MGraph G;
        G.n = n;
        G.e = e;
        CreatMGraph(G);

        int i;

        //深度优先搜索递归
        for(i = 0; i < G.n; i ++)       //初始化
        {
            visited[i] = false;
        }
        std::cout << "深度优先搜索（递归）的顶点顺序:" << std::endl;
        DFS(G,0);
        for(i = 0; i < G.n; i ++)
        {
            if(visited[i] == false)
                DFS(G,i);
        }
        std::cout << std::endl;

        //深度优先搜索非递归
        for(i = 0; i < G.n; i ++)       //重新初始化
        {
            visited[i] = false;
        }
        std::cout << "深度优先搜索（非递归）的顶点顺序:" << std::endl;
        for(i = 0; i < G.n; i ++)
        {
            if(visited[i] == false)
                DFS1(G,i);
        }
        std::cout << std::endl;

        //广度优先搜索
        for(i = 0; i < G.n; i ++)       //重新初始化
        {
            visited[i] = false;
        }
        std::cout << "广度优先搜索的顶点顺序:" << std::endl;
        for(i = 0; i < G.n; i ++)
        {
            if(visited[i] == false)
                BFS(G,i);
        }
        std::cout << std::endl;
    }

    return 0;
}