重拾算法(4)——图的广度优先和深度优先搜索算法的实现与33867个测试用例

重拾算法(4)——图的广度优先和深度优先搜索算法的实现与33867个测试用例

本篇继续上一篇的方式，给出图的深度优先和广度优先搜索算法，然后用33867个测试用例进行自动化测试，以证明算法的正确性。

用邻接表(adjacency list)表示图(graph)

    public partial class AdjacencyListGraph<TVertex, TEdge> : ICloneable
    {        
        public AdjacencyListGraph()
        {
            this.Vertexes = new List<AdjacencyListVertex<TVertex, TEdge>>();
        }
        
        public IList<AdjacencyListVertex<TVertex, TEdge>> Vertexes { get; protected set; }
        
        /* 略 */
    }
    
    public class AdjacencyListVertex<TVertex, TEdge>
    {
        public TVertex Value { get;set; }
        public IList<AdjacencyListEdge<TVertex, TEdge>> Edges { get;set; }
        
        public AdjacencyListVertex()
        {
            this.Edges = new List<AdjacencyListEdge<TVertex, TEdge>>();
        }
    }
    
    public class AdjacencyListEdge<TVertex, TEdge>
    {
        public TEdge Value { get;set; }
        public AdjacencyListVertex<TVertex, TEdge> Vertex1 { get;set; }
        public AdjacencyListVertex<TVertex, TEdge> Vertex2 { get;set; }
        
        public AdjacencyListEdge(AdjacencyListVertex<TVertex, TEdge> vertex1, AdjacencyListVertex<TVertex, TEdge> vertex2)
        {
            this.Vertex1 = vertex1; 
            this.Vertex2 = vertex2;
        }
    }

 

图的广度优先算法

图的广度优先算法和树的层次遍历是类似的。

        SearchReport<TVertex, TEdge> BreadthFirstTraverse(GraphNodeWorker<TVertex, TEdge> worker, bool reportNeeded)
        {
            SearchReport<TVertex, TEdge> result = null;
            if (reportNeeded) { result = new SearchReport<TVertex, TEdge>(); }
            var visited = new Dictionary<AdjacencyListVertex<TVertex, TEdge>, bool>();
            foreach (var vertex in this.Vertexes)
            {
                if ((!visited.ContainsKey(vertex)) || (!visited[vertex]))
                { 
                    BFS(vertex, visited, worker); 
                    if (reportNeeded) { result.ConnectedComponents.Add(vertex); }
                }
            }
            return result;
        }
        
        void BFS(AdjacencyListVertex<TVertex, TEdge> headNode, Dictionary<AdjacencyListVertex<TVertex, TEdge>, bool> visited, GraphNodeWorker<TVertex, TEdge> worker)
        {
            var queue = new Queue<AdjacencyListVertex<TVertex, TEdge>>();
            queue.Enqueue(headNode);
            while (queue.Count > 0)
            {
                var vertex = queue.Dequeue();
                if ((!visited.ContainsKey(vertex)) || (!visited[vertex]))
                {
                    if (vertex != null)
                    {
                        worker.DoActionOnNode(vertex);
                        if (!visited.ContainsKey(vertex))
                        { visited.Add(vertex, true); }
                        else
                        { visited[vertex] = true; }
                        var neighbourVertexes = from edge in vertex.Edges
                                                select GetNeighbourVertex(vertex, edge);
                        foreach (var v in neighbourVertexes)
                        {
                            if ((!visited.ContainsKey(v)) || (!visited[v]))
                            { queue.Enqueue(v); }
                        }
                    }
                }
            }
        }

 

其中的SearchReport<TVertex, TEdge>是一个统计搜索结果的对象，定义如下

    public class SearchReport<TVertex, TEdge>
    {
        public List<AdjacencyListVertex<TVertex, TEdge>> ConnectedComponents { get;set; }
        public SearchReport()
        {
            ConnectedComponents = new List<AdjacencyListVertex<TVertex, TEdge>>();
        }
    }

ConnectedComponents有多少个元素，就表示这个图有多少个连通分量。

 

图的深度优先搜索算法

图的深度优先搜索可以用"递归"、"栈"和"优化的栈"三种形式实现。

        SearchReport<TVertex, TEdge> DepthFirstTraverse(GraphNodeWorker<TVertex, TEdge> worker, bool reportNeeded, DepthFirstTraverseOption option)
        {
            SearchReport<TVertex, TEdge> result = null;
            if (reportNeeded) { result = new SearchReport<TVertex, TEdge>(); }
            var visited = new Dictionary<AdjacencyListVertex<TVertex, TEdge>, bool>();
            foreach (var vertex in this.Vertexes)
            {
                if ((!visited.ContainsKey(vertex)) || (!visited[vertex]))
                {
                    switch (option)
                    {
                    case DepthFirstTraverseOption.DFSRecursively:
                        DFS(vertex, visited, worker);
                        break;
                    case DepthFirstTraverseOption.DFSByStack:
                        DFSByStack(vertex, visited, worker);
                        break;
                    case DepthFirstTraverseOption.DFSByStackOptimized:
                        DFSByStackOptimized(vertex, visited, worker);
                        break;
                    default:
                        throw new NotImplementedException();
                    }
                    if (reportNeeded) { result.ConnectedComponents.Add(vertex);}
                }
            }
            return result;
        }

 

用递归实现深度优先搜索

        void DFS(AdjacencyListVertex<TVertex, TEdge> vertex, Dictionary<AdjacencyListVertex<TVertex, TEdge>, bool> visited, GraphNodeWorker<TVertex, TEdge> worker)
        {
            //if ((!visited.ContainsKey(vertex)) || (!visited[vertex]))
            {
                worker.DoActionOnNode(vertex);
                if (!visited.ContainsKey(vertex))
                { visited.Add(vertex, true); }
                else
                { visited[vertex] = true; }
                var neighbourVertexes = from edge in vertex.Edges
                                        select GetNeighbourVertex(vertex, edge);
                foreach (var v in neighbourVertexes)
                {
                    if ((!visited.ContainsKey(v)) || (!visited[v]))
                    { DFS(v, visited, worker); }
                }
            }
        }

 

其中GetNeighbourVertex是个辅助函数，用于获取与指定结点相连的结点。

        AdjacencyListVertex<TVertex, TEdge> GetNeighbourVertex(AdjacencyListVertex<TVertex, TEdge> vertex, AdjacencyListEdge<TVertex, TEdge> edge)
        {
            if (vertex == null || edge == null) { return null; }
            Debug.Assert(!((vertex != edge.Vertex1) && (vertex != edge.Vertex2)));
            
            AdjacencyListVertex<TVertex, TEdge> result = null;
            if (vertex != edge.Vertex1) { result = edge.Vertex1; }
            else { result = edge.Vertex2; }
            
            return result;
        }

 

用栈实现深度优先搜索

        void DFSByStack(AdjacencyListVertex<TVertex, TEdge> root, Dictionary<AdjacencyListVertex<TVertex, TEdge>, bool> visited, GraphNodeWorker<TVertex, TEdge> worker)
        {
            var stack = new Stack<AdjacencyListVertex<TVertex, TEdge>>();
            stack.Push(root);

            while (stack.Count > 0)
            {
                var vertex = stack.Pop();
                if (vertex != null)
                {
                    if ((!visited.ContainsKey(vertex)) || (!visited[vertex]))
                    {
                        worker.DoActionOnNode(vertex);
                        if (!visited.ContainsKey(vertex))
                        { visited.Add(vertex, true); }
                        else
                        { visited[vertex] = true; }
                        
                        var neighbourVertexes = from edge in vertex.Edges
                                                select GetNeighbourVertex(vertex, edge);
                        foreach (var v in neighbourVertexes.Reverse())
                        {
                            if ((!visited.ContainsKey(v)) || (!visited[v]))
                            {
                                stack.Push(v);
                            }
                        }
                    }
                }
            }
        }

 

这个用栈实现的深度优先搜索算法，其特点是与上文用递归实现的算法相比，两者对图上结点的遍历顺序完全相同。因此我用这个两个算法对比以验证他们两个是否正确。

优化过的用栈实现深度优先搜索

这个用栈实现的深度优先搜索算法还有可优化的空间。优化后的算法如下。

        void DFSByStackOptimized(AdjacencyListVertex<TVertex, TEdge> root, Dictionary<AdjacencyListVertex<TVertex, TEdge>, bool> visited, GraphNodeWorker<TVertex, TEdge> worker)
        {
            var stack = new Stack<AdjacencyListVertex<TVertex, TEdge>>();
            stack.Push(root);
            if (!visited.ContainsKey(root)) { visited.Add(root, false); }
            else { visited[root] = false; }

            while (stack.Count > 0)
            {
                var vertex = stack.Pop();
                if (vertex != null)
                {
                    worker.DoActionOnNode(vertex);
                    visited[vertex] = true;
                    var neighbourVertexes = from edge in vertex.Edges
                                            select GetNeighbourVertex(vertex, edge);
                    foreach (var v in neighbourVertexes)
                    {
                        if (!visited.ContainsKey(v))
                        {
                            stack.Push(v);
                            visited.Add(v, false);
                        }
                    }
                }
            }
        }

 

这一版的算法，避免了不必要的入栈出栈，减少了对visited的判定次数，去掉了不必要的Reverse()。

要注意的是，优化后的算法，对图上结点的遍历顺序与优化前有所不同。

 

测试

我的测试思路如下：

• 编程自动生成具有1、2、3、4、5、6个结点的图的所有情形（一共有33867个。结点数目相同时，连线的不同意味着情形的不同）
• 打印33867个图的情形。
• 对33867个图，分别进行基于递归和栈的深度优先搜索，若搜索结果完全相同，就说明这两个算法是正确的。
• 在上一步基础上，若基于优化的栈的深度优先搜索结果与上一步的搜索结果相比，只有访问顺序不同，就说明基于优化的栈的算法是正确的。
• 在上一步基础上，若广度优先搜索结果与上一步的遍历结果相比，只有访问顺序不同，就说明广度优先搜索算法是正确的。

 

自动生成33867个不同的图

这个程序的实现思路与上一篇是一样的。在得到了所有具有N个结点的图后，给每个图增加一个结点，就成了N+1个结点的新图，一个这样的新图可以扩展出2^N个新的情形。而最初的具有1个结点的图就只有那么1个。利用数学归纳法，生成33867个不同的图的问题就解决了。

在控制台显示图结构

在控制台显示一个二叉树结构还算常见，但要显示图就复杂一点。我设计了按如下形式显示图结构。

graph 9485:
component 0:
000
 ┕┑
001│
 ┕┙

component 1:
002
 ┝┑
 ┕┿┑
003││
 ┝┙│
 ┕━┿┑
004  ││
 ┝━┙│
 ┕━━┙

component 2:
005

 

受字体影响可能看不出效果，把上述内容复制到notepad里是这样的：

可见这个图是生成的第9485个图。图中的"001""002""003""004"是结点，黑线代表边。它有3个连通分量(component)。其中component0包含2个结点和1条边，component1包含3个结点和3条边，component2包含1个结点，不含边。

这样直观地看到图的结构，就容易进行排错调试了。

 

至于遍历、比较、判定是否正确的程序，就没有什么新意可言了。

总结

没有这样的测试，我是不敢相信我的算法实际可用的。虽然为了测试花掉好几天时间，不过还是很值得的。现在我可以放心大胆地说，我给出的图的广度优先和深度优先搜索算法是真正正确的！

需要工程源码的同学麻烦点个赞并留言你的Email~