1 　　 /* 实现深度优先算法的函数；核心思想是二叉树先序遍历核心思想（非递归法版本） */
 2     SharedPointer< Array<int> > DFS(int i)
 3     {
 4         DynamicArray<int>* ret = NULL;  // 返回值是一个数组
 5         if( (0 <= i) && (i < vCount()) )  // 参数合法
 6         {
 7             LinkStack<int> s;  // 压入邻接顶点的栈
 8             LinkQueue<int> r;  // 压入遍历值的队列
 9             DynamicArray<bool> visited(vCount());  // 访问标记数组
10
11             /* 将标记里面的值初始化为未有访问 */
12             for(int j=0; j<visited.length(); j++)
13             {
14                 visited[j] = false;
15             }
16
17             s.push(i);  // 初始顶点压入栈中
18
19             while( s.size() > 0 )  // 有顶点就要继续
20             {
21                 int v = s.top();  // 得到栈顶的元素
22
23                 s.pop();  // 弹出栈顶元素
24
25                 if( !visited[v] )  // 顶点未有访问
26                 {
27                     SharedPointer< Array<int> > aj = getAdgacent(v);  // 得到 v 的所有邻接顶点
28
29                     /* 将 v 的所有邻接顶点压入栈中 */
30                     for(int j=aj->length()-1; j>=0; j--)
31                     {
32                         s.push((*aj)[j]);  // 将邻接顶点逐个压入栈中
33                     }
34
35                     r.add(v);  // 将 v 压入队列中
36
37                     visited[v] = true;  // 将 v 标记位已经访问
38                 }
39             }
40
41             ret = toArray(r);  // 将队列转换为数组
42         }
43         else
44         {
45             THROW_EXCEPTION(InvalidParameterException, "Index i is invalid ...");
46         }
47
48         return ret;
49     }

 1 #include <iostream>
 2 #include "MatrixGraph.h"
 3
 4 using namespace std;
 5 using namespace DTLib;
 6
 7 int main()
 8 {
 9     MatrixGraph<9, char, int> g;
10 　　 const char* VD = "ABEDCGFHI";
11
12     for(int i=0; i<9; i++)
13     {
14         g.setVertex(i, VD[i]); //设置顶点相关的值为字符串 VD 中的内容
15 　　 }
16
17     g.setEdge(0, 1, 0);  // 无向图、特殊的有向图，所以每个点之间的邻接矩阵对称， 这里权值为 0，只关心是否连接，不关心权值
18     g.setEdge(1, 0, 0);
19     g.setEdge(0, 3, 0);
20     g.setEdge(3, 0, 0);
21     g.setEdge(0, 4, 0);
22     g.setEdge(4, 0, 0);
23     g.setEdge(1, 2, 0);
24     g.setEdge(2, 1, 0);
25     g.setEdge(1, 4, 0);
26     g.setEdge(4, 1, 0);
27     g.setEdge(2, 5, 0);
28     g.setEdge(5, 2, 0);
29     g.setEdge(3, 6, 0);
30     g.setEdge(6, 3, 0);
31     g.setEdge(4, 6, 0);
32     g.setEdge(6, 4, 0);
33     g.setEdge(6, 7, 0);
34     g.setEdge(7, 6, 0);
35     g.setEdge(7, 8, 0);
36     g.setEdge(8, 7, 0);
37
38 　　 SharedPointer< Array<int> > sa = g.DFS(0);
39
40     for(int i=0; i<sa->length(); i++)
41     {
42         cout << (*sa)[i] << " ";
43 　　 }
44
45     return 0;
46 }

 1 /* 定义深度优先算法的递归函数 */
 2 template < typename V, typename E>
 3 void DFS(Graph<V, E>& g, int v, Array<bool>& visited)
 4 {
 5     if( (0 <= v) && (v < g.vCount()) )
 6     {
 7         cout << v << endl;  // 访问的方式是打印
 8
 9         visited[v] = true;  // 设置访问标记
10
11         SharedPointer< Array<int> > aj = g.getAdgacent(v);  // 获取 v 的邻接顶点
12
13         /* v 是否有邻接顶点，有的话就递归进行深度优先算法的遍历 */
14         for(int i=0; i<aj->length(); i++)
15         {
16        /* 如果没有进行访问，就进行深度优先遍历 */
17             if( !visited[(*aj)[i]])
18             {
19                 DFS(g, (*aj)[i], visited);  // 递归调用
20             }
21         }
22     }
23     else
24     {
25         THROW_EXCEPTION(InvalidParameterException, "Index v is invalid ...");
26     }
27 }

 1 /* 递归法深度优先遍历图，第一个参数是要被遍历的图，第二个参数是遍历的起始顶点 */
 2 template < typename V, typename E >
 3 void DFS(Graph<V, E>& g, int v)
 4 {
 5 DynamicArray<bool> visited(g.vCount());  // 标记顶点是否被访问过
 6
 7     /* 为每一个顶点设置是否被访问的初始值 */
 8     for(int i=0; i<visited.length();i++)
 9     {
10         visited[i] = false;
11 }
12
13     DFS(g, v, visited);
14 }