深度優先搜索

深度優先搜索（DFS：Depth-First Search）是一種圖搜索策略，其將搜索限制到 2 種操作：

• (a) 訪問圖中的一個節點；
• (b) 訪問該節點的子節點；

在深度優先搜索中，對於最新發現的頂點，如果它還有以此為起點而未探測到的邊，就沿此邊繼續探測下去。當頂點 v 的所有邊都已被探尋過后，搜索將回溯到發現頂點 v 有起始點的那些邊。這一過程一直進行到已發現從源頂點可達的所有頂點為止。實際上深度優先搜索最初的探究也是為了解決迷宮問題。

對圖的深度優先搜索與對樹（Tree）的深度優先遍歷（Depth First Traversal）是類似的，區別在於圖中可能存在環，所以可能會遍歷到已經遍歷的節點。

例如，下面的圖中，從頂點 2 開始遍歷，當遍歷到頂點 0 時，子頂點為 1 和 2，而頂點 2 已經遍歷過，如果不做標記，遍歷過程將陷入死循環。所以，在 DFS 的算法實現中需要對頂點是否訪問過做標記。

上圖的 DFS 遍歷結果為 2, 0, 1, 3。

DFS 算法可以通過不同方式來實現：

• 遞歸方式
• 非遞歸方式：使用棧（Stack）數據結構來存儲遍歷圖中節點的中間狀態；

DFS 算法的遞歸方式偽碼如下：

procedure DFS(G,v):
    label v as discovered
    for all edges from v to w in G.adjacentEdges(v) do
        if vertex w is not labeled as discovered then
            recursively call DFS(G,w)

DFS 算法的非遞歸方式偽碼如下：

procedure DFS-iterative(G,v):
    let S be a stack
    S.push(v)
    while S is not empty
          v ← S.pop() 
          if v is not labeled as discovered:
              label v as discovered
              for all edges from v to w in G.adjacentEdges(v) do
                  S.push(w)

深度優先搜索（DFS）的時間復雜度為 O(V+E)，V 即 Vertex 頂點數量，E 即 Edge 邊數量。

DFS 算法實現代碼如下：

using System;
using System.Linq;
using System.Collections.Generic;

namespace GraphAlgorithmTesting
{
  class Program
  {
    static void Main(string[] args)
    {
      Graph g = new Graph(4);
      g.AddEdge(0, 1);
      g.AddEdge(0, 2);
      g.AddEdge(1, 2);
      g.AddEdge(2, 0);
      g.AddEdge(2, 3);
      g.AddEdge(3, 3);

      foreach (var vertex in g.DFS(2))
      {
        Console.WriteLine(vertex);
      }
      foreach (var vertex in g.RecursiveDFS(2))
      {
        Console.WriteLine(vertex);
      }

      Console.ReadKey();
    }

    class Edge
    {
      public Edge(int begin, int end)
      {
        this.Begin = begin;
        this.End = end;
      }

      public int Begin { get; private set; }
      public int End { get; private set; }
    }

    class Graph
    {
      private Dictionary<int, List<Edge>> _adjacentEdges
        = new Dictionary<int, List<Edge>>();

      public Graph(int vertexCount)
      {
        this.VertexCount = vertexCount;
      }

      public int VertexCount { get; private set; }

      public void AddEdge(int begin, int end)
      {
        if (!_adjacentEdges.ContainsKey(begin))
        {
          var edges = new List<Edge>();
          _adjacentEdges.Add(begin, edges);
        }

        _adjacentEdges[begin].Add(new Edge(begin, end));
      }

      public List<int> DFS(int start)
      {
        List<int> traversal = new List<int>();
        int current = start;

        // mark all the vertices as not visited
        bool[] visited = new bool[VertexCount];
        for (int i = 0; i < VertexCount; i++)
        {
          visited[i] = false;
        }

        // create a stack for DFS
        Stack<int> stack = new Stack<int>();

        // mark the current node as visited and push it
        visited[current] = true;
        stack.Push(current);

        while (stack.Count > 0)
        {
          current = stack.Pop();

          // if this is what we are looking for
          traversal.Add(current);

          // get all child vertices of the popped vertex,
          // if a child has not been visited, 
          // then mark it visited and push it
          if (_adjacentEdges.ContainsKey(current))
          {
            foreach (var edge in _adjacentEdges[current].OrderByDescending(e => e.End))
            {
              if (!visited[edge.End])
              {
                visited[edge.End] = true;
                stack.Push(edge.End);
              }
            }
          }
        }

        return traversal;
      }

      public List<int> RecursiveDFS(int start)
      {
        List<int> traversal = new List<int>();
        int current = start;

        // mark all the vertices as not visited
        bool[] visited = new bool[VertexCount];
        for (int i = 0; i < VertexCount; i++)
        {
          visited[i] = false;
        }

        // traversal
        RecursiveDFSTraversal(current, visited, traversal);

        return traversal;
      }

      private void RecursiveDFSTraversal(int current, bool[] visited, List<int> traversal)
      {
        visited[current] = true;
        traversal.Add(current);

        if (_adjacentEdges.ContainsKey(current))
        {
          foreach (var edge in _adjacentEdges[current].OrderBy(e => e.End))
          {
            if (!visited[edge.End])
            {
              RecursiveDFSTraversal(edge.End, visited, traversal);
            }
          }
        }
      }
    }
  }
}

參考資料

• 廣度優先搜索
• 深度優先搜索
• Breadth First Traversal for a Graph
• Depth First Traversal for a Graph
• 深度優先搜索 廣度優先搜索類訓練題
• Introduction to Algorithms 6.006 - Lecture 13
• 深度優先搜索 DFS
• 算法與數據結構

本篇文章《深度優先搜索》由 Dennis Gao 發表自博客園，未經作者本人同意禁止任何形式的轉載，任何自動或人為的爬蟲轉載行為均為耍流氓。