【数据结构】有向图、无向图以及最短路(Dijkstra)算法的C#实现（Template模式）

 为了写个“运筹学”的小工具，发现必须用到数据结构中的图。找了一圈没有找到自己满意的，只能自己写一个。

所有代码基于C#，完全模板实现。

 

首先是顶点的定义，顶点可以是任意类型，但其ID为Int32，该ID只是Graph内部使用。

。

    public sealed class GraphVertex<M>
    {
        #region Constructor
        public GraphVertex()
        {
        }
        #endregion

        #region Fields
        private Int32 nID = default(Int32);
        private M objData = default(M);
        #endregion

        #region Properties
        public Int32 ID
        {
            get { return nID; }
            set { nID = value; }
        }
        public M Data
        {
            get { return objData; }
            set { objData = value; }
        }
        #endregion
    }

 

然后是Edge的定义，这里有一个辅助的Struct：GraphEdgeCore，其负责真正的边的识别：

：

    public struct GraphEdgeCore : IEquatable<GraphEdgeCore>
    {
        public GraphEdgeCore(Int32 i1, Int32 i2)
        {
            ID1 = i1;
            ID2 = i2;
        }

        public Int32 ID1;
        public Int32 ID2;

        public Boolean IsValidated()
        {
            if (ID1 == -1 || ID2 == -1)
                return false;
            if (ID1 == ID2)
                return false;

            return true;
        }

        #region IEquatable<GraphEdgeCore> Members
        public bool Equals(GraphEdgeCore other)
        {
            if (ID1 != other.ID1) return false;
            if (ID2 != other.ID2) return false;

            return true;
        }
        #endregion

        #region Operators
        public static Boolean operator == (GraphEdgeCore ec1, GraphEdgeCore ec2)
        {
            return ec1.Equals(ec2);
        }

        public static Boolean operator != (GraphEdgeCore ec1, GraphEdgeCore ec2)
        {
            return !(ec1 == ec2);
        }
        #endregion

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
        public override bool Equals(object obj)
        {
            return (this == (GraphEdgeCore)obj);
        }
    }

    public sealed class GraphEdge<N>
    {
        #region Constructor
        public GraphEdge(Int32 n1, Int32 n2, N obj)
        {
            edge.ID1 = n1;
            edge.ID2 = n2;
            objData = obj;
        }
        #endregion

        #region Fields
        private GraphEdgeCore edge;
        private N objData = default(N);
        #endregion

        #region Properties
        public GraphEdgeCore EdgeCore
        {
            get { return edge; }
        }

        public N Data
        {
            get { return objData; }
            set { objData = value; }
        }
        #endregion
    }
 

 

最大的难点来了：既然全部是模板，就不可避免会遇到权重的比较，因为是模板，所以必须定义一个额外的辅助类来实现：

    public abstract class ACGraphEdgeWeightAssistant<N> //: IComparable, IComparable<ACGraphEdgeWeightAssistant<N>>
    {
        #region Properties
        public abstract N MinimumValue { get; }
        public abstract N MaximumValue { get; }
        #endregion

        #region Abstract methods
        public abstract N Add(N n1, N n2);
        public abstract N Subtract(N n1, N n2);
        public abstract Boolean Equals(N n1, N n2);
        public abstract Int32 Compare(N n1, N n2);
        public abstract Boolean IsMaximumValue(N nVal);        
        #endregion

        //#region IComparable<ACGraphEdgeWeightAssistant<N>> Members
        //public int CompareTo(ACGraphEdgeWeightAssistant<N> other)
        //{
        //    throw new NotImplementedException();
        //}
        //#endregion

        //#region IComparable Members
        //public int CompareTo(object obj)
        //{
        //    return CompareTo(obj as ACGraphEdgeWeightAssistant<N>);
        //}
        //#endregion
    }
 

 

最后是图的定义：

    public sealed class Graph<M, N> // where N : ValueType
    {
        #region Constructor
        public Graph(ACGraphEdgeWeightAssistant<N> objAss)
        {
            System.Diagnostics.Debug.Assert(objAss != null);
            pAssist = objAss;
        }
        #endregion

        #region Fields
        private Dictionary<Int32, GraphVertex<M>> dictNodes = new Dictionary<int, GraphVertex<M>>();
        private List<GraphEdge<N>> listEdges = new List<GraphEdge<N>>();
        private Int32 nVertexID = 0;

        // Assistant for working for N
        private ACGraphEdgeWeightAssistant<N> pAssist = null;
        #endregion

        #region Properties
        public Int32 NodesAmount
        {
            get { return dictNodes.Count; }
        }
        public Int32 EdgesAmount
        {
            get { return listEdges.Count; }
        }
        #endregion

        #region Public methods
        public void InsertVertex(GraphVertex<M> objVertex)
        {
            System.Diagnostics.Debug.Assert(objVertex != null);
            objVertex.ID = nVertexID++;

            dictNodes.Add(objVertex.ID, objVertex);
        }
        public void InsertEdge(GraphEdge<N> objEdge)
        {
            System.Diagnostics.Debug.Assert(objEdge != null);

            if (!objEdge.EdgeCore.IsValidated())
                return;

            if (!dictNodes.ContainsKey(objEdge.EdgeCore.ID1))
                return;
            if (!dictNodes.ContainsKey(objEdge.EdgeCore.ID2))
                return;

            listEdges.Add(objEdge);
        }
        public GraphEdge<N>[] GetEdges(GraphEdgeCore objEdgeCore)
        {
            List<GraphEdge<N>> lists = new List<GraphEdge<N>>();
            foreach (GraphEdge<N> ge in listEdges)
            {
                if (ge.EdgeCore == objEdgeCore)
                    lists.Add(ge);
            }

            return lists.ToArray();
        }
        public GraphEdge<N>[] GetEdges(Int32 nID, Boolean bSource)
        {
            List<GraphEdge<N>> lists = new List<GraphEdge<N>>();
            foreach (GraphEdge<N> ge in listEdges)
            {
                if (bSource)
                {
                    if (ge.EdgeCore.ID1 == nID)
                        lists.Add(ge);
                }
                else
                {
                    if (ge.EdgeCore.ID2 == nID)
                        lists.Add(ge);
                }
            }

            return lists.ToArray();
        }
        public GraphEdge<N>[] GetAllEdges()
        {
            return listEdges.ToArray();
        }
        public GraphVertex<M>[] GetAllVerteics()
        {
            List<GraphVertex<M>> listVer = new List<GraphVertex<M>>();
            foreach (GraphVertex<M> gv in dictNodes.Values)
                listVer.Add(gv);

            return listVer.ToArray();
        }

        // Get shortest path
        // Note: call this method before you make sure that the weight should not negative.
        public void DijkstraShortestPath(Int32 nSource, Int32 nTarget, List<GraphPath<N>> listPaths)
        {
            System.Diagnostics.Debug.Assert(listPaths != null);
            listPaths.Clear();
            GraphPath<N> gp = null;

            if (!dictNodes.ContainsKey(nSource))
                return;
            if (!dictNodes.ContainsKey(nTarget))
                return;
            if (nSource == nTarget)
            {
                gp = new GraphPath<N>();
                gp.CurrentCost = pAssist.MinimumValue;
                gp.PathNodes.Add(nSource);
                listPaths.Add(gp);

                return;
            }

            Dictionary<Int32, N> dictPSet = new Dictionary<Int32, N>();
            Dictionary<Int32, N> dictTSet = new Dictionary<Int32, N>();

            // Initialize
            dictPSet.Add(nSource, pAssist.MinimumValue);
            foreach (Int32 nVer in dictNodes.Keys)
            {
                if (nVer != nSource)
                    dictTSet.Add(nVer, pAssist.MaximumValue);
            }

            while (!dictPSet.ContainsKey(nTarget))
            {
                // Go through each item in P Set
                foreach (Int32 nID in dictPSet.Keys)
                {
                    foreach (GraphEdge<N> ge in GetEdges(nID, true))
                    {
                        if (dictTSet.ContainsKey(ge.EdgeCore.ID2))
                        {
                            // Update the T value: min { P(X) + W, T(X) }
                            N nTValue = dictTSet[ge.EdgeCore.ID2];
                            N nPValue = dictPSet[nID];
                            N nVal = pAssist.Add(nPValue, ge.Data);

                            if (pAssist.IsMaximumValue(nTValue))
                            {
                                dictTSet[ge.EdgeCore.ID2] = nVal;
                            }
                            else
                            {
                                if (pAssist.Compare(nTValue, nVal) > 0)
                                {
                                    dictTSet[ge.EdgeCore.ID2] = nVal;
                                }
                            }
                        }
                    }
                }

                // Get the minimum of TSet
                Int32 nTID = default(Int32);
                N ntmp = pAssist.MaximumValue;
                foreach (KeyValuePair<Int32, N> kvp in dictTSet)
                {
                    if (pAssist.Compare(kvp.Value, ntmp) < 0)
                    {
                        ntmp = kvp.Value;
                        nTID = kvp.Key;
                    }
                }

                if (nTID == default(Int32))
                    break;

                dictTSet.Remove(nTID);
                dictPSet.Add(nTID, ntmp);
            }

            // OKay, we get the final result, parse the result out
            gp = new GraphPath<N>();
            gp.CurrentID = nTarget;
            gp.CurrentCost = dictPSet[nTarget];
            gp.PathNodes.Add(nTarget);
            listPaths.Add(gp);

            Boolean bEnd = false;
            Boolean bExisted = false;
            List<GraphPath<N>> listTempPaths = new List<GraphPath<N>>();
            
            while (!bEnd)
            {
                bExisted = false;
                listTempPaths.Clear();

                foreach (GraphPath<N> gpath in listPaths)
                {
                    if (gpath.DeadPath)
                        continue;

                    foreach (GraphEdge<N> ge in GetEdges(gpath.CurrentID, false))
                    {
                        //dictPSet[ge.Data]
                        if (dictPSet.ContainsKey(ge.EdgeCore.ID1)
                            &&
                            pAssist.Compare(gpath.CurrentCost, pAssist.Add(ge.Data, dictPSet[ge.EdgeCore.ID1])) == 0)
                        {
                            if (!bExisted)
                            {
                                gpath.CurrentID = ge.EdgeCore.ID1;
                                gpath.PathNodes.Add(ge.EdgeCore.ID1);
                                gpath.CurrentCost = dictPSet[ge.EdgeCore.ID1];
                                bExisted = true;
                            }
                            else
                            {
                                // Existed already in current
                                GraphPath<N> gp2 = new GraphPath<N>(gpath);
                                gp2.CurrentID = ge.EdgeCore.ID1;
                                gp2.PathNodes.Add(ge.EdgeCore.ID1);
                                gp2.CurrentCost = dictPSet[ge.EdgeCore.ID1];
                                listTempPaths.Add(gp2);
                            }
                        }
                    }

                    if (!bExisted)
                    {
                        gpath.DeadPath = true;
                    }
                }

                foreach (GraphPath<N> gpath in listTempPaths)
                    listPaths.Add(gpath);

                foreach (GraphPath<N> gpath in listPaths)
                {
                    if ((!gpath.DeadPath) && gpath.PathNodes.Contains(nSource))
                    {
                        bEnd = true;
                        break;
                    }
                }
            }

            // Finalize the result output
            foreach (GraphPath<N> gpth in listPaths)
            {
                if (gpth.DeadPath)
                    listPaths.Remove(gpth);
                else
                    gpth.CurrentCost = dictPSet[nTarget];
            }
        }
        #endregion
    }

其中，代表路径使用了另外一个类：

    public sealed class GraphPath<N> : ICloneable
    {
        #region Constructor
        public GraphPath() { }
        public GraphPath(GraphPath<N> other)
            : this()
        {
            if (other != null)
            {
                nCurID = other.nCurID;
                curCost = other.curCost;
                foreach (Int32 n in other.listPath)
                    listPath.Add(n);
            }
        }
        #endregion

        #region Fields
        private List<Int32> listPath = new List<Int32>();
        private Int32 nCurID = default(Int32);
        private N curCost = default(N);
        private Boolean bDeadPath = false;
        #endregion

        #region Properties
        public List<Int32> PathNodes
        {
            get { return listPath; }
        }
        public Int32 CurrentID
        {
            get { return nCurID; }
            set { nCurID = value; }
        }
        public N CurrentCost
        {
            get { return curCost; }
            set { curCost = value; }
        }
        public Boolean DeadPath
        {
            get { return bDeadPath; }
            set { bDeadPath = value; }
        }
        #endregion

        #region ICloneable Members
        public object Clone()
        {
            return new GraphPath<N>(this);
        }
        #endregion
    }

 

使用实例：

 

    public sealed class ACGraphEdgeWeightSingleAssistant : ACGraphEdgeWeightAssistant<Single>
    {
        public override float MinimumValue
        {
            get { return 0; }
        }

        public override float MaximumValue
        {
            get { return Single.MaxValue; }
        }

        public override float Add(float n1, float n2)
        {
            return n1 + n2;
        }

        public override float Subtract(float n1, float n2)
        {
            return n1 - n2;
        }

        public override bool Equals(float n1, float n2)
        {
            return n1 == n2;
        }

        public override int Compare(float n1, float n2)
        {
            if (n1 > n2) return 1;
            if (n1 < n2) return -1;
            return 0;
        }

        public override bool IsMaximumValue(float nVal)
        {
            return nVal == Single.MaxValue;
        }
    }

            ACGraphEdgeWeightSingleAssistant objWSA = new ACGraphEdgeWeightSingleAssistant();
            Dictionary<Char, Int32> dictVer = new Dictionary<Char, Int32>();
            Graph<Char, Single> gph = new Graph<Char, Single>(objWSA);GraphVertex<Char> gv = new GraphVertex<char>();
            gv.Data = '1'; gph.InsertVertex(gv);
            dictVer.Add('1', gv.ID);
            gv = new GraphVertex<char>(); gv.Data = '2'; gph.InsertVertex(gv); dictVer.Add('2', gv.ID);
            gv = new GraphVertex<char>(); gv.Data = '3'; gph.InsertVertex(gv); dictVer.Add('3', gv.ID);
            gv = new GraphVertex<char>(); gv.Data = '4'; gph.InsertVertex(gv); dictVer.Add('4', gv.ID);
            gv = new GraphVertex<char>(); gv.Data = '5'; gph.InsertVertex(gv); dictVer.Add('5', gv.ID);
            gv = new GraphVertex<char>(); gv.Data = '6'; gph.InsertVertex(gv); dictVer.Add('6', gv.ID);
            GraphEdge<Single> ge = new GraphEdge<float>(dictVer['1'], dictVer['2'], 4);
            gph.InsertEdge(ge);
            ge = new GraphEdge<float>(dictVer['1'], dictVer['3'], 3);
            gph.InsertEdge(ge);
            ge = new GraphEdge<float>(dictVer['2'], dictVer['4'], 3);
            gph.InsertEdge(ge);
            ge = new GraphEdge<float>(dictVer['2'], dictVer['5'], 2);
            gph.InsertEdge(ge);
            ge = new GraphEdge<float>(dictVer['3'], dictVer['5'], 3);
            gph.InsertEdge(ge);
            ge = new GraphEdge<float>(dictVer['4'], dictVer['6'], 2);
            gph.InsertEdge(ge);
            ge = new GraphEdge<float>(dictVer['5'], dictVer['6'], 2);
            gph.InsertEdge(ge);

            List<GraphPath<Single>> listPaths = new List<GraphPath<Single>>();
gph.DijkstraShortestPath(dictVer['1'], dictVer['6'], listPaths);

 

 

注意：对Dijkstra算法来说，其基本要求权重必须非负！根据上述代码可以轻易的实现对权重无要求的Floyd算法。

 

By Alva Chien.
2009.07.12