图的深度优先搜索（DFS）

深度优先是指要一条路走到黑，遍历具有后来先服务的特性，适合用递归。

算法步骤：

        1、建立bool类型访问结点标记数组，并初始化所有元素为false，代表每个结点都没有被访问；

        2、以图中的的一个结点为原点v，访问v并在访问标记数组中标记已访问；
        3、遍历v的所有邻接点，若有未访问，递归。

代码实现：

#include <iostream>
using namespace std;
#define maxn 10
bool visited[maxn];
using VexType = char;

class AMGragh
{
public:
    VexType vex[maxn];
    int edge[maxn][maxn];
    int vex_num, edge_num;
};

int LocateVex(const AMGragh& g, const VexType& v)
{
    for (int i = 0; i < g.vex_num; i++)
    {
        if (v == g.vex[i])
        {
            return i;
        }
    }
    return -1;
}

void CreateAMGraph(AMGragh& g)
{
    memset(g.vex, 0, sizeof(g.vex));
    memset(g.edge, 0, sizeof(g.edge));
    VexType u, v;
    int loc_u, loc_v;
    cout << "请输入顶点数：" << endl;
    cin >> g.vex_num;
    cout << "请输入边数：" << endl;
    cin >> g.edge_num;
    cout << "请依次输入结点:" << endl;
    for (int i = 0; i < g.vex_num; i++)
    {
        cin >> g.vex[i];
    }
    cout << "请依次输入边的两个顶点：" << endl;
    for (int i = 0; i < g.edge_num;i++)
    {
        cin >> u >> v;
        loc_u = LocateVex(g, u);
        loc_v = LocateVex(g, v);
        g.edge[loc_u][loc_v] = g.edge[loc_v][loc_u] = 1;
    }
}

//void OutputAMGragh(const AMGragh& g)
//{
//    for (int i = 0; i < g.vex_num; i++)
//    {
//        for (int j = 0; j < g.vex_num; j++)
//        {
//            cout << g.edge[i][j] << " ";
//        }
//        cout << endl;
//    }
//}

void DFS(const AMGragh g, const int& v)
{
    cout << g.vex[v] << " ";
    visited[v] = true;
    for (int i = 0; i < g.vex_num; i++)
    {
        if (g.edge[v][i] && !visited[i])
        {
            DFS(g, i);
        }
    }
}

int main()
{
    VexType start_vex;
    AMGragh g;
    CreateAMGraph(g);
    //OutputAMGragh(g);
    cout << "请输入要开始深度优先遍历的首个结点：" << endl;
    cin >> start_vex;
    int str = LocateVex(g, start_vex);
    DFS(g, str);

    return 0;
}