算法：圖（Graph）的遍歷、最小生成樹和拓撲排序

背景

不同的數據結構有不同的用途，像：數組、鏈表、隊列、棧多數是用來做為基本的工具使用，二叉樹多用來作為已排序元素列表的存儲，B 樹用在存儲中，本文介紹的 Graph 多數是為了解決現實問題（說到底，所有的數據結構都是這個目的），如：網絡布局、任務安排等。

圖的基本概念

示例

頂點（Vertex）

上圖的 1、2、3、4、5、6 就是頂點。

鄰接（Adjoin）

如果 A 和 B 通過定向邊相連，且方向為 A -> B，則 B 為 A 的鄰接，如果相連的邊是沒有方向的，則 A 和 B 互為鄰接。

邊（Edge）

頂點之間的連線就是邊。

連通圖（Connected Graph）

不考慮邊的方向性，從任何一個節點都可以遍歷到其它節點。本文的所有算法（除了拓撲排序）只適合連通圖。

定向圖（Directed Graph）

圖中的所有邊都帶方向。

權重圖（Weighted Graph）

圖中的所有邊都有權重。

圖的程序表示

如果圖 T 有 A、B、C 三個節點，有 A -> B，B -> C，C -> A 三個邊（沒有方向），如何在程序中表示 T 呢？

鄰接矩陣

    A   B   C
A  0   1   0
B  0   0   1
C  1   0   0

矩陣的行代表了定向邊的起始頂點，矩陣的列代表了定向邊的介紹頂點，矩陣中的值：1 代表了列是行的鄰接，0 則反之。如果邊沒有方向，則矩陣是相對於正對角線是對稱的。

鄰接列表

A：[ B ]
B：[ C ]
C：[ A ]

這個就不多說了，多數書籍使用都是鄰接矩陣。

代碼

        class Vertex<T>
        {
            public T Value { get; set; }

            public bool WasVisited { get; set; }
        }

        class Graph<T>
        {
            #region 私有字段

            private int _maxSize;
            private Vertex<T>[] _vertexs;
            private bool[][] _edges;
            private int _vertexCount = 0;

            #endregion

            #region 構造方法

            public Graph(int maxSize)
            {
                _maxSize = maxSize;
                _vertexs = new Vertex<T>[_maxSize];
                _edges = new bool[_maxSize][];
                for (var i = 0; i < _maxSize; i++)
                {
                    _edges[i] = new bool[_maxSize];
                }
            }

            #endregion

            #region 添加頂點

            public Graph<T> AddVertex(T value)
            {
                _vertexs[_vertexCount++] = new Vertex<T> { Value = value };

                return this;
            }

            #endregion

            #region 添加邊

            public Graph<T> AddUnDirectedEdge(T startItem, T endItem)
            {
                var startIndex = this.GetVertexIndex(startItem);
                var endIndex = this.GetVertexIndex(endItem);

                _edges[startIndex][endIndex] = true;
                _edges[endIndex][startIndex] = true;

                return this;
            }

            public Graph<T> AddDirectedEdge(T startItem, T endItem)
            {
                var startIndex = this.GetVertexIndex(startItem);
                var endIndex = this.GetVertexIndex(endItem);

                _edges[startIndex][endIndex] = true;

                return this;
            }

            #endregion
        }

圖的常見算法

遍歷

本文的遍歷算法只適合一般的無向圖。

深度優先遍歷

深度優先遍歷的原則是：盡可能的離開始節點遠，二叉樹的三種遍歷算法都屬於這種算法。

示例

從 A 開始的遍歷順序為（鄰接的遍歷順序為字母升序）：ABCEDBF。

棧版本

            #region 深度優先遍歷：棧版本

            public void DepthFirstSearch(T startItem, Action<T> action)
            {
                var startIndex = this.GetVertexIndex(startItem);
                var stack = new Stack<int>();

                this.DepthFirstSearchVisit(stack, startIndex, action);
                while (stack.Count > 0)
                {
                    var adjoinVertexIndex = this.GetNextUnVisitedAdjoinVertexIndex(stack.Peek());
                    if (adjoinVertexIndex >= 0)
                    {
                        this.DepthFirstSearchVisit(stack, adjoinVertexIndex, action);
                    }
                    else
                    {
                        stack.Pop();
                    }
                }

                this.ResetVisited();
            }

            private void DepthFirstSearchVisit(Stack<int> stack, int index, Action<T> action)
            {
                _vertexs[index].WasVisited = true;
                action(_vertexs[index].Value);
                stack.Push(index);
            }

            #endregion

遞歸版本

            #region 深度優先遍歷：遞歸版本

            public void DepthFirstSearchRecursion(T startItem, Action<T> action)
            {
                var startIndex = this.GetVertexIndex(startItem);

                this.DepthFirstSearchRecursionVisit(startIndex, action);

                this.ResetVisited();
            }

            private void DepthFirstSearchRecursionVisit(int index, Action<T> action)
            {
                _vertexs[index].WasVisited = true;
                action(_vertexs[index].Value);

                var adjoinVertexIndex = this.GetNextUnVisitedAdjoinVertexIndex(index);
                while (adjoinVertexIndex >= 0)
                {
                    this.DepthFirstSearchRecursionVisit(adjoinVertexIndex, action);
                    adjoinVertexIndex = this.GetNextUnVisitedAdjoinVertexIndex(index);
                }
            }

            #endregion

廣度優先遍歷

廣度優先遍歷的原則是：盡可能的離開始節點近。這個算法沒有辦法通過遞歸實現，多數都是使用的隊列（終於發現了隊列的又一個用處）。

示例

從 A 開始的遍歷順序為（鄰接的遍歷順序為字母升序）：ABCEDFB。

代碼

            #region 廣度優先遍歷

            public void BreadthFirstSearch(T startItem, Action<T> action)
            {
                var startIndex = this.GetVertexIndex(startItem);
                var queue = new Queue<int>();

                this.BreadthFirstSearchVisit(queue, startIndex, action);
                while (queue.Count > 0)
                {
                    var adjoinVertexIndexs = this.GetNextUnVisitedAdjoinVertexIndexs(queue.Dequeue());
                    foreach (var adjoinVertexIndex in adjoinVertexIndexs)
                    {
                        this.BreadthFirstSearchVisit(queue, adjoinVertexIndex, action);
                    }
                }

                this.ResetVisited();
            }

            private void BreadthFirstSearchVisit(Queue<int> queue, int index, Action<T> action)
            {
                _vertexs[index].WasVisited = true;
                action(_vertexs[index].Value);
                queue.Enqueue(index);
            }

            #endregion

最小生成樹

本文的最小生成樹算法只適合一般的無向圖。

將 N 個頂點連接起來的最小樹叫：最小生成樹。

給定一個顆有 N 個頂點的連通圖，則最小生成樹的邊為：N - 1。

不同的遍歷算法生成的最小生成樹是不同的，下面使用廣度優先遍歷來生成最小樹。

示例

從 A 開始的遍歷順序為（鄰接的遍歷順序為字母升序）：A->B、B->C、C->E、E->D、E->F、D->B。

代碼

            #region 最小生成樹

            public void DisplayMinimumSpanningTree(T startItem)
            {
                var startIndex = this.GetVertexIndex(startItem);
                var queue = new Queue<int>();

                _vertexs[startIndex].WasVisited = true;
                queue.Enqueue(startIndex);
                while (queue.Count > 0)
                {
                    var currentIndex = queue.Dequeue();
                    var adjoinVertexIndexs = this.GetNextUnVisitedAdjoinVertexIndexs(currentIndex);
                    foreach (var adjoinVertexIndex in adjoinVertexIndexs)
                    {
                        Console.WriteLine(_vertexs[currentIndex].Value + "->" + _vertexs[adjoinVertexIndex].Value);

                        _vertexs[adjoinVertexIndex].WasVisited = true;
                        queue.Enqueue(adjoinVertexIndex);
                    }
                }

                this.ResetVisited();
            }

            #endregion

拓撲排序

拓撲排序只適合定向圖，且圖中不存在循環結構。其算法非常簡單，依次獲取圖中的沒有鄰接頂點的頂點，然后刪除該頂點。

示例

上圖出現了循環結構，假如沒有頂點 C，拓撲排序的結果為（頂點的遍歷順序為字母升序）：EFDAB。

算法

            #region 拓撲排序

            public List<T> TopologySort()
            {
                var cloneVertexs = (Vertex<T>[])_vertexs.Clone();
                var cloneEdges = (bool[][])_edges.Clone();
                var cloneVertexCount = _vertexCount;

                var results = new List<T>();
                while (_vertexCount > 0)
                {
                    var successor = this.NextSuccessor();
                    if (successor == -1)
                    {
                        throw new InvalidOperationException("出現循環了！");
                    }

                    results.Insert(0, _vertexs[successor].Value);

                    this.RemoveVertex(successor);
                    _vertexCount--;
                }

                _vertexs = cloneVertexs;
                _edges = cloneEdges;
                _vertexCount = cloneVertexCount;

                return results;
            }

            private int NextSuccessor()
            {
                for (var row = 0; row < _vertexCount; row++)
                {
                    if (_edges[row].Take(_vertexCount).All(x => !x))
                    {
                        return row;
                    }
                }

                return -1;
            }

            private void RemoveVertex(int successor)
            {
                for (int i = successor; i < _vertexCount - 1; i++)
                {
                    _vertexs[i] = _vertexs[i + 1];
                }

                for (int row = successor; row < _vertexCount - 1; row++)
                {
                    for (int column = 0; column < _vertexCount; column++)
                    {
                        _edges[row][column] = _edges[row + 1][column];
                    }
                }

                for (int column = successor; column < _vertexCount - 1; column++)
                {
                    for (int row = 0; row < _vertexCount; row++)
                    {
                        _edges[row][column] = _edges[row][column + 1];
                    }
                }
            }

            #endregion

完整代碼

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DataStuctureStudy.Graphs
{
    class GraphTest
    {
        public static void Test()
        {
            var graph = new Graph<String>(50);
            graph
                .AddVertex("A")
                .AddVertex("B")
                .AddVertex("C")
                .AddVertex("D")
                .AddVertex("E")
                .AddVertex("F")
                .AddVertex("G")
                .AddVertex("H")
                .AddVertex("I");
            graph
                .AddDirectedEdge("A", "B").AddDirectedEdge("A", "C").AddDirectedEdge("A", "D").AddDirectedEdge("A", "E")
                .AddDirectedEdge("B", "F")
                .AddDirectedEdge("D", "G")
                .AddDirectedEdge("F", "H")
                .AddDirectedEdge("G", "I");

            Console.WriteLine("深度遍歷，棧版本：");
            graph.DepthFirstSearch("A", Console.Write);
            Console.WriteLine();
            Console.WriteLine();

            Console.WriteLine("深度遍歷，遞歸版本：");
            graph.DepthFirstSearchRecursion("A", Console.Write);
            Console.WriteLine();
            Console.WriteLine();

            Console.WriteLine("廣度遍歷：");
            graph.BreadthFirstSearch("A", Console.Write);
            Console.WriteLine();
            Console.WriteLine();

            Console.WriteLine("最小生成樹：");
            graph.DisplayMinimumSpanningTree("A");
            Console.WriteLine();
            Console.WriteLine();

            Console.WriteLine("拓撲排序：");
            var results = graph.TopologySort();
            Console.WriteLine(String.Join("->", results.ToArray()));
            Console.WriteLine();
        }

        class Vertex<T>
        {
            public T Value { get; set; }

            public bool WasVisited { get; set; }
        }

        class Graph<T>
        {
            #region 私有字段

            private int _maxSize;
            private Vertex<T>[] _vertexs;
            private bool[][] _edges;
            private int _vertexCount = 0;

            #endregion

            #region 構造方法

            public Graph(int maxSize)
            {
                _maxSize = maxSize;
                _vertexs = new Vertex<T>[_maxSize];
                _edges = new bool[_maxSize][];
                for (var i = 0; i < _maxSize; i++)
                {
                    _edges[i] = new bool[_maxSize];
                }
            }

            #endregion

            #region 添加頂點

            public Graph<T> AddVertex(T value)
            {
                _vertexs[_vertexCount++] = new Vertex<T> { Value = value };

                return this;
            }

            #endregion

            #region 添加邊

            public Graph<T> AddUnDirectedEdge(T startItem, T endItem)
            {
                var startIndex = this.GetVertexIndex(startItem);
                var endIndex = this.GetVertexIndex(endItem);

                _edges[startIndex][endIndex] = true;
                _edges[endIndex][startIndex] = true;

                return this;
            }

            public Graph<T> AddDirectedEdge(T startItem, T endItem)
            {
                var startIndex = this.GetVertexIndex(startItem);
                var endIndex = this.GetVertexIndex(endItem);

                _edges[startIndex][endIndex] = true;

                return this;
            }

            #endregion

            #region 深度優先遍歷：棧版本

            public void DepthFirstSearch(T startItem, Action<T> action)
            {
                var startIndex = this.GetVertexIndex(startItem);
                var stack = new Stack<int>();

                this.DepthFirstSearchVisit(stack, startIndex, action);
                while (stack.Count > 0)
                {
                    var adjoinVertexIndex = this.GetNextUnVisitedAdjoinVertexIndex(stack.Peek());
                    if (adjoinVertexIndex >= 0)
                    {
                        this.DepthFirstSearchVisit(stack, adjoinVertexIndex, action);
                    }
                    else
                    {
                        stack.Pop();
                    }
                }

                this.ResetVisited();
            }

            private void DepthFirstSearchVisit(Stack<int> stack, int index, Action<T> action)
            {
                _vertexs[index].WasVisited = true;
                action(_vertexs[index].Value);
                stack.Push(index);
            }

            #endregion

            #region 深度優先遍歷：遞歸版本

            public void DepthFirstSearchRecursion(T startItem, Action<T> action)
            {
                var startIndex = this.GetVertexIndex(startItem);

                this.DepthFirstSearchRecursionVisit(startIndex, action);

                this.ResetVisited();
            }

            private void DepthFirstSearchRecursionVisit(int index, Action<T> action)
            {
                _vertexs[index].WasVisited = true;
                action(_vertexs[index].Value);

                var adjoinVertexIndex = this.GetNextUnVisitedAdjoinVertexIndex(index);
                while (adjoinVertexIndex >= 0)
                {
                    this.DepthFirstSearchRecursionVisit(adjoinVertexIndex, action);
                    adjoinVertexIndex = this.GetNextUnVisitedAdjoinVertexIndex(index);
                }
            }

            #endregion

            #region 廣度優先遍歷

            public void BreadthFirstSearch(T startItem, Action<T> action)
            {
                var startIndex = this.GetVertexIndex(startItem);
                var queue = new Queue<int>();

                this.BreadthFirstSearchVisit(queue, startIndex, action);
                while (queue.Count > 0)
                {
                    var adjoinVertexIndexs = this.GetNextUnVisitedAdjoinVertexIndexs(queue.Dequeue());
                    foreach (var adjoinVertexIndex in adjoinVertexIndexs)
                    {
                        this.BreadthFirstSearchVisit(queue, adjoinVertexIndex, action);
                    }
                }

                this.ResetVisited();
            }

            private void BreadthFirstSearchVisit(Queue<int> queue, int index, Action<T> action)
            {
                _vertexs[index].WasVisited = true;
                action(_vertexs[index].Value);
                queue.Enqueue(index);
            }

            #endregion

            #region 最小生成樹

            public void DisplayMinimumSpanningTree(T startItem)
            {
                var startIndex = this.GetVertexIndex(startItem);
                var queue = new Queue<int>();

                _vertexs[startIndex].WasVisited = true;
                queue.Enqueue(startIndex);
                while (queue.Count > 0)
                {
                    var currentIndex = queue.Dequeue();
                    var adjoinVertexIndexs = this.GetNextUnVisitedAdjoinVertexIndexs(currentIndex);
                    foreach (var adjoinVertexIndex in adjoinVertexIndexs)
                    {
                        Console.WriteLine(_vertexs[currentIndex].Value + "->" + _vertexs[adjoinVertexIndex].Value);

                        _vertexs[adjoinVertexIndex].WasVisited = true;
                        queue.Enqueue(adjoinVertexIndex);
                    }
                }

                this.ResetVisited();
            }

            #endregion

            #region 拓撲排序

            public List<T> TopologySort()
            {
                var cloneVertexs = (Vertex<T>[])_vertexs.Clone();
                var cloneEdges = (bool[][])_edges.Clone();
                var cloneVertexCount = _vertexCount;

                var results = new List<T>();
                while (_vertexCount > 0)
                {
                    var successor = this.NextSuccessor();
                    if (successor == -1)
                    {
                        throw new InvalidOperationException("出現循環了！");
                    }

                    results.Insert(0, _vertexs[successor].Value);

                    this.RemoveVertex(successor);
                    _vertexCount--;
                }

                _vertexs = cloneVertexs;
                _edges = cloneEdges;
                _vertexCount = cloneVertexCount;

                return results;
            }

            private int NextSuccessor()
            {
                for (var row = 0; row < _vertexCount; row++)
                {
                    if (_edges[row].Take(_vertexCount).All(x => !x))
                    {
                        return row;
                    }
                }

                return -1;
            }

            private void RemoveVertex(int successor)
            {
                for (int i = successor; i < _vertexCount - 1; i++)
                {
                    _vertexs[i] = _vertexs[i + 1];
                }

                for (int row = successor; row < _vertexCount - 1; row++)
                {
                    for (int column = 0; column < _vertexCount; column++)
                    {
                        _edges[row][column] = _edges[row + 1][column];
                    }
                }

                for (int column = successor; column < _vertexCount - 1; column++)
                {
                    for (int row = 0; row < _vertexCount; row++)
                    {
                        _edges[row][column] = _edges[row][column + 1];
                    }
                }
            }

            #endregion

            #region 幫助方法

            private int GetVertexIndex(T item)
            {
                for (var i = 0; i < _vertexCount; i++)
                {
                    if (_vertexs[i].Value.Equals(item))
                    {
                        return i;
                    }
                }
                return -1;
            }

            private int GetNextUnVisitedAdjoinVertexIndex(int index)
            {
                for (var i = 0; i < _vertexCount; i++)
                {
                    if (_edges[index][i] && _vertexs[i].WasVisited == false)
                    {
                        return i;
                    }
                }

                return -1;
            }

            private List<int> GetNextUnVisitedAdjoinVertexIndexs(int index)
            {
                var results = new List<int>();

                for (var i = 0; i < _vertexCount; i++)
                {
                    if (_edges[index][i] && _vertexs[i].WasVisited == false)
                    {
                        results.Add(i);
                    }
                }

                return results;
            }

            private void ResetVisited()
            {
                for (var i = 0; i < _vertexCount; i++)
                {
                    _vertexs[i].WasVisited = false;
                }
            }

            #endregion
        }
    }
}

備注

本文沒有解釋權重圖，下篇再介紹。