广度优先遍历&深度优先遍历

一、广度优先算法BFS(Breadth First Search)

基本实现思想

        （1）顶点v入队列。

        （2）当队列非空时则继续执行，否则算法结束。

        （3）出队列取得队头顶点v；

        （4）查找顶点v的所以子节点，并依次进入队列；

        （5）转到步骤（2）。

二、深度优先算法DFS(Depth First Search)

基本思想：　

递归实现：

             （1）访问顶点v，打印节点；

             （2）遍历v的子节点w，while（w存在），递归执行该节点；

代码：

　　/布尔型数组Visited[]初始化成false
　　void DFS(Vetex v)
　　{
    　　Visited[v] = true;
    　　for each w adjacent to v
       　　 if (!Visited[w])
            　　DFS(w);
　　}

非递归实现：

             （1）访问顶点v，顶点v入栈S，打印输出顶点，visited[v]=1

              （2）while(栈S非空)

                      x=栈S的顶元素(不出栈)；

                      if(存在并找到未被访问的x的子结点w)

                      　　访问w，打印输出，visited[w]=1；w进栈;

                      else

                      　　x出栈;

 注：visited[x]=1，标记该节点已被访问

#include<iostream>
#include<queue>
#include<stack>
#include<vector>
using namespace std;
const int MAX = 10;
typedef struct graph
{
    int n;//顶点个数
    int e;//边数
    int edge[MAX][MAX];//邻接矩阵
}Graph;
vector<bool> visited(MAX,0);
void InitGraph(Graph *G)
{
    for (int i = 0; i < MAX; i++)
        for (int j = 0; j < MAX; j++)
            G->edge[i][j] = 0;
}

//广度优先遍历,num是从哪个结点开始
void BFS(Graph G,int num)
{
    queue<int> q;
    cout << num << " ";
    visited[num] = true;
    q.push(num);
    while (!q.empty())
    {
        int temp = q.front();
        q.pop();
        for (int i = 0; i < G.n; i++)
        {
            if (G.edge[temp][i] != 0 && visited[i] == false)
            {
                q.push(i);
                cout << i << " ";
                visited[i] = true;
            }
        }
    }
    cout << endl;
}

//深度优先遍历的递归版本
void DFS1(graph G,int num)
{
    visited[num] = true;
    cout << num << " ";
    for (int i = 0; i < G.n; i++)
    {
        if (G.edge[num][i] != 0 && visited[i] == false)
            DFS1(G,i);
    }
}

//深度优先非递归版本
void DFS2(graph G,int num)
{
    stack<int> s;
    s.push(num);
    visited[num] = true;
    while (!s.empty())
    {
        int temp = s.top();
        s.pop();
        cout << temp<<" ";
        for (int i = G.n - 1; i >= 0; i--)
        {
            if (G.edge[temp][i] != 0 && visited[i] == false)
            {
                s.push(i);
                visited[i] = true;
            }
        }
    }
    cout << endl;
}

int main()
{
    int a, b, v, i;
    Graph G;
    cin >> G.n >> G.e;   //n,e为顶点个数，边个数  
    InitGraph(&G);   //对G进行初始化，整个MAX范围初始化  
    for (i = 0; i < G.e; i++)   //建图  
    {
        cin >> a >> b >> v;  //a,b为顶点，v为权值  
        G.edge[a][b] = v;
        G.edge[b][a] = v;
    }
    BFS(G, 0); //0为开始搜索的顶点序号  
    for (i = 0; i < MAX; i++)
        visited[i] = 0;
    DFS1(G, 0);
    cout << endl;
    for (i = 0; i < MAX; i++)
        visited[i] = 0;
    DFS2(G, 0);
    return 0;
}