图的深度优先遍历 (Depth First Search)

深度优先遍历的理解

深度优先搜索（Depth First Search），简称DFS，这种方法类似于二叉树的前序遍历。

假设 初始状态时图中所有的结点都没有被访问，从$V$点出发，访问此节点， 之后依次访问从$V$没被访问的邻接点出发进行遍历，直到与结点$V$连通结点全部被访问，之后回溯之前结点到其他未被访问的结点，重复此过程 ，直到图中的结点全部被访问，完成遍历。

以下图为例：

以上图为例，其实就类似于树的前序遍历， 从顶点$V_1$出发，选择邻接点$V_2$ 同理依次访问顶点$V_4$ $V_8$ $V_5$，此时$V_5$已经没有邻接点可以访问，现在就回溯到$V_8$ ,$V_8$也没有邻接点，直到$V_1$有其他邻接点没有访问，此时依次访问$V_3$ $V_6$ $V_7$

所以深度遍历图的顺序为 :$V_1$-> $V_2$->$V_4$-> $V_8$-> $V_5$-> $V_3$-> $V_6$-> $V_7$ 大致理解意思接下来看图一步步了解实现过程

实现遍历的过程图解

使用非递归的方式实现深度遍历比较好理解,根据刚刚说的思路我们通过栈的结构保存访问过的结点，过程如下：

1.将结点压入栈中，访问栈顶部的结点

2.从当前已经访问的点u移动到v时，将v压入栈中，u不存在相邻的结点u弹栈。

可能光说不太理解，我们看一下图了解一下实现的过程：

观察上图得到一下的过程：

1.访问结点0 压入栈中。

2.访问结点1 压入栈中。

3.同理分别将2，3，6压入栈中

4.访问结点5，此时结点5不存在与它相邻并且未被访问的结点，此时，将结点5弹栈。

5.同理6，3结点依次弹栈

6.回溯到结点2时，将结点4压入栈中

7.访问顶点4，此时结点4不存在与它相邻并且未被访问的结点，此时，将结点4弹栈。

8.回溯到结点2，此时结点2不存在与它相邻并且未被访问的结点，此时，将结点2弹栈。

9.同理，1 ，0 弹栈完成遍历所有结点

非递归实现遍历

使用非递归的方式实现深度遍历,通过栈的结构保存访问过的结点

代码如下：

void DFS(Graph G){
    stack<int> s;
    for(int i = 0; i < G.numvex; i++){
        if(!vis[i]){
            s.push(i);
            vis[i] = true;
            cout << G.vexs[i];
        }
         /*用来添加与V依次相邻并且没有被访问的结点
           以上图为例此处第一次将 V1 V2 V3 V6 V5 压入栈中
       	*/
        while(!s.empty()){
           //获取栈顶元素
            int top = s.top();
            int j;
           //找到与当前栈顶元素相邻并且没有访问过的结点
            for(j = 0; j < G.numvex; j++){
                if(G.arc[top][j] && !vis[j]){
                    s.push(j);
                    vis[j] = true;
                    cout << G.vexs[j];
                    break;
                }
            }
        //如果当前的结点没有相邻并且没有被访问的结点的话 弹栈
            if(j == G.numvex) s.pop();
        }
    }
}

解释一下执行过程， 从顶点$V_0$开始遍历， 没有被访问过，压入栈中 ，此时进入while循环 栈不为空循环 找到与$V_0$依次相邻并且没有被访问的结点也就是$V_1$，$V_2$，$V_3$ ，$V_6$，$V_5$ 依次访问并压入栈中，

$V_5$遍历所有与它相邻的结点全部访问过，弹栈回溯，重复此过程，完成深度遍历。

递归方法实现遍历

深度遍历的过程就是让访问的过程一直往下走下去，遇到没有可以访问的结点就回溯

void DFS(Graph G, int i){
    vis[i] = true;
    cout << G.vexs[i] << " ";
    for(int j = 0; j < G.numvex; j++){
        if(!vis[j] && G.arc[i][j]!= 0) DFS(G,j);
    }
}
void DFStrave(Graph G){
    for(int i = 0; i < G.numvex; i++){
          if(!vis[i]) DFS(G, i);
    }
}

解释一下递归的方式实现遍历，从$V_0$开始进行深度搜索，访问并标记，执行递归访问${V_{1}}， $$V_2$，$V_3$ ，$V_6$，$V_5$ 此时 下次$V_5$ 没有相邻并且未访问的结点，那么此时就结束这次的递归，回溯 重复此过程完成遍历

完整过程

给出完整实现的代码：

#include <iostream>
#include <stack>
#include <cstring>
#define MAX_VEX 100

using namespace std;
struct Graph{
    char vexs[MAX_VEX];
    int arc[MAX_VEX][MAX_VEX];
    int numvex,numarc;
};
bool vis[MAX_VEX];
void CreateGraph(Graph &G){
    int vi, vj;
    cout << "please enter the number of vertexes and arcs : \n";
    cin >> G.numvex >> G.numarc;
    for(int i = 0; i < G.numvex; i++){
        printf("Please enter the NO.%d name of vex : ",i+1);
        cin >> G.vexs[i];
    }
    memset(G.arc, 0, sizeof(G.arc));
    cout << endl;
    for(int i = 0; i < G.numarc; i++){
        cout<< "Enter the subscripts and weights from vertex vi to vertex vj : ";
        cin >> vi >> vj ;
        G.arc[vi][vj] = 1;
        G.arc[vj][vi] = 1;
    }
}
void DFS(Graph G, int i){
    vis[i] = true;
    cout << G.vexs[i] << " ";
    for(int j = 0; j < G.numvex; j++){
        if(!vis[j] && G.arc[i][j]!= 0) DFS(G,j);
    }
}
void DFStrave(Graph G){
    for(int i = 0; i < G.numvex; i++){
          if(!vis[i]) DFS(G, i);
    }
}
void DFS1 (Graph G){
    stack<int> s;
    for(int i = 0; i < G.numvex; i++){
        if(!vis[i]){
            s.push(i);
            vis[i] = true;
            cout << G.vexs[i] << " ";
        }
        while(!s.empty()){
            int top = s.top();
            int j;
            for(j = 0; j < G.numvex; j++){
                if(G.arc[top][j] && !vis[j]){
                    s.push(j);
                    vis[j] = true;
                    cout << G.vexs[j] << " ";
                    break;
                }
            }
            if(j == G.numvex) s.pop();
        }
    }
}
int main(){
    Graph G;
    CreateGraph(G);
    //DFStrave(G);
    DFS1(G);
    return 0;
}
/*
7 11
0 1 2 3 4 5 6
0 1
0 2
0 4
4 2
1 2
1 3
2 3
2 5
5 6
2 5
3 6
*/