图的深度优先搜索遍历(邻接表&邻接矩阵，递归&非递归)(C++)

图的深度优先搜索遍历可有递归和迭代两种方法。

递归的方式比较容易，每次以当前节点的未被访问的邻接节点为新的出发点去遍历即可，编程的时候注意维护好全局的访问标记以及访问序列即可(可以以引用的方式传递)。

非递归(迭代)的方式需要借助栈。从起点开始，先保存栈顶，然后栈顶出栈，并将该节点(初始的时候为起点)的所有未被访问的邻接节点依次入栈；重复直到栈为空。

采用邻接表时，复杂度为O(V+E)。采用邻接矩阵时，复杂度为O(V^2)。V为顶点数、E为边数。

C++代码如下：
这里有4个函数，分别是：
邻接表 非递归
邻接表 递归
邻接矩阵 非递归
邻接矩阵 递归

#include <iostream>
#include <vector>
#include <stack>

using namespace std;

typedef int DATA_TYPE;  // 权值为int型
const DATA_TYPE NO_EDGE = 10000000;  // 表示没有该边

// 邻接矩阵
struct AdjMatrixGraph
{
    vector<vector<DATA_TYPE> > weights;
};

// 邻接表
struct AdjTableGraph
{
    vector<vector<int> > adjTable;
    vector<vector<DATA_TYPE> > adjWeights;  // 暂时用不到 维数与adjTable一致
};

// 邻接表深度优先搜索算法迭代
vector<int> AdjTableDFS1(AdjTableGraph graph, int startNode)
{
    int vertexNum = graph.adjTable.size();
    vector<int> visited(vertexNum, 0);
    vector<int> visitOrder;
    stack<int> trace;
    trace.push(startNode);
    visited[startNode] = 1;

    while (!trace.empty())
    {
        int currentNode = trace.top();
        trace.pop();
        visitOrder.push_back(currentNode);

        if (graph.adjTable[currentNode].size() > 0)
        {
            for (size_t i = 0; i < graph.adjTable[currentNode].size(); ++i)
            {
                if (visited[graph.adjTable[currentNode][i]] == 0)
                {
                    trace.push(graph.adjTable[currentNode][i]);
                    visited[graph.adjTable[currentNode][i]] = 1;
                }
            }
        }
    }

    return visitOrder;
}


// 邻接表深度优先搜索算法递归
void AdjTableDFS2(AdjTableGraph graph, vector<int> &visited, vector<int> &visitOrder, int startNode)
{
    visited[startNode] = 1;
    visitOrder.push_back(startNode);

    if (graph.adjTable[startNode].size() > 0)
    {
        for (size_t i = 0; i < graph.adjTable[startNode].size(); ++i)
        {
            if (visited[graph.adjTable[startNode][i]] == 0)
            {
                AdjTableDFS2(graph, visited, visitOrder, graph.adjTable[startNode][i]);
            }
        }
    }
}


// 邻接矩阵深度优先搜索算法迭代
vector<int> AdjMatrixDFS1(AdjMatrixGraph graph, int startNode)
{
    int vertexNum = graph.weights.size();
    vector<int> visited(vertexNum, 0);
    vector<int> visitOrder;
    stack<int> trace;
    trace.push(startNode);
    visited[startNode] = 1;

    while (!trace.empty())
    {
        int currentNode = trace.top();
        trace.pop();
        visitOrder.push_back(currentNode);

        for (size_t i = 0; i < vertexNum; ++i)
        {
            if (visited[i] == 0 && graph.weights[currentNode][i] < NO_EDGE)
            {
                trace.push(i);
                visited[i] = 1;
            }
        }
    }

    return visitOrder;
}

// 邻接矩阵深度优先搜索算法递归
void AdjMatrixDFS2(AdjMatrixGraph graph, vector<int> &visited, vector<int> &visitOrder, int startNode)
{
    int vertexNum = graph.weights.size();
    visited[startNode] = 1;
    visitOrder.push_back(startNode);

    for (size_t i = 0; i < vertexNum; ++i)
    {
        if (visited[i] == 0 && graph.weights[startNode][i] < NO_EDGE)
        {
            AdjMatrixDFS2(graph, visited, visitOrder, i);
        }
    }
}


int main(int argc, char *argv[])
{

    // 图的初始化
    // 顶点编号必须为从0开始的连续的整数(若不是，先转换)
    // 图为有向图

    // ================邻接表方式===============
    AdjTableGraph graph;
    graph.adjTable.push_back(vector<int>{1, 3});
    graph.adjTable.push_back(vector<int>{2});
    graph.adjTable.push_back(vector<int>{4});
    graph.adjTable.push_back(vector<int>{2});
    graph.adjTable.push_back(vector<int>{});

    // 邻接表 非递归
    vector<int> visitOrder = AdjTableDFS1(graph, 0);
    cout << "邻接表 非递归： ";
    for (size_t i = 0; i < visitOrder.size(); ++i)
    {
        cout << visitOrder[i] << " ";
    }
    cout << endl;

    // 邻接表 递归
    vector<int> visited2(graph.adjTable.size(), 0);
    vector<int> visitOrder2;
    AdjTableDFS2(graph, visited2, visitOrder2, 0);
    cout << "邻接表 递归： ";
    for (size_t i = 0; i < visitOrder2.size(); ++i)
    {
        cout << visitOrder2[i] << " ";
    }
    cout << endl;


    // ===============邻接矩阵方式===============
    AdjMatrixGraph graph2;
    graph2.weights.push_back(vector<DATA_TYPE>{0, 8, NO_EDGE, 5, NO_EDGE});
    graph2.weights.push_back(vector<DATA_TYPE>{NO_EDGE, 0, 3, NO_EDGE, NO_EDGE});
    graph2.weights.push_back(vector<DATA_TYPE>{NO_EDGE, NO_EDGE, 0, NO_EDGE, 6});
    graph2.weights.push_back(vector<DATA_TYPE>{NO_EDGE, NO_EDGE, 9, 0, NO_EDGE});
    graph2.weights.push_back(vector<DATA_TYPE>{NO_EDGE, NO_EDGE, NO_EDGE, NO_EDGE, 0});

    // 邻接矩阵 非递归
    vector<int> visitOrder3 = AdjMatrixDFS1(graph2, 0);
    cout << "邻接矩阵 非递归： ";
    for (size_t i = 0; i < visitOrder3.size(); ++i)
    {
        cout << visitOrder3[i] << " ";
    }
    cout << endl;

    // 邻接矩阵 递归
    vector<int> visited4(graph2.weights.size(), 0);
    vector<int> visitOrder4;
    AdjMatrixDFS2(graph2, visited4, visitOrder4, 0);
    cout << "邻接矩阵 递归： ";
    for (size_t i = 0; i < visitOrder4.size(); ++i)
    {
        cout << visitOrder4[i] << " ";
    }
    cout << endl;

    return 0;
}

测试用例图如下：

编译环境(CLion 2016 with MinGW G++, GDB 7.11)

输出结果：
邻接表 非递归： 0 3 2 4 1
邻接表 递归： 0 1 2 4 3
邻接矩阵 非递归： 0 3 2 4 1
邻接矩阵 递归： 0 1 2 4 3