以邻接表为存储结构的---图的算法实现

来源：互联网发布：minecraft mac forge 编辑：程序博客网时间：2024/06/04 17:55
 using System;
using System.Collections.Generic;
using System.Collections.Specialized;
namespace HBDiscover
{
    public class AdjacencyList<T>
    {
        List<Vertex<T>> items; //图的顶点集合 
        public bool IsCycle; //是否是环 
        public AdjacencyList() : this(10) { } //构造方法 
        public AdjacencyList(int capacity) //指定容量的构造方法 
        {
            items = new List<Vertex<T>>(capacity);
        }
        public void AddVertex(T item) //添加一个顶点 
        {   //不允许插入重复值 
            if (Contains(item))
            {
                throw new ArgumentException("插入了重复顶点！");
            }
            items.Add(new Vertex<T>(item));
        }
        public void AddVertex(params T[] vexs) //添加一个顶点 
        {
            foreach (T temp in vexs)
            {
                AddVertex(temp);
            }
        }
        public void AddEdge(T from, T to, int weight) //添加无向边 
        {
            Vertex<T> fromVer = Find(from); //找到起始顶点 
            if (fromVer == null)
            {
                throw new ArgumentException("头顶点并不存在！");
            }
            Vertex<T> toVer = Find(to); //找到结束顶点 
            if (toVer == null)
            {
                throw new ArgumentException("尾顶点并不存在！");
            }
            //无向边的两个顶点都需记录边信息 
            AddDirectedEdge(fromVer, toVer, weight);
            AddDirectedEdge(toVer, fromVer, weight);
        }
        public void AddEdge(T from, T to) //添加无向边 
        {
            AddEdge(from, to, 0);
        }
        public void AddDirectedEdge(T from, T to, int weight) //添加无向边 
        {
            Vertex<T> fromVer = Find(from); //找到起始顶点 
            if (fromVer == null)
            {
                throw new ArgumentException("头顶点并不存在！");
            }
            Vertex<T> toVer = Find(to); //找到结束顶点 
            if (toVer == null)
            {
                throw new ArgumentException("尾顶点并不存在！");
            }
            AddDirectedEdge(fromVer, toVer, weight);
        }
        public void AddDirectedEdge(T from, T to)
        {
            AddDirectedEdge(from, to, 0);
        }
        public bool Contains(T item) //查找图中是否包含某项 
        {
            return Find(item) != null;
        }
        private Vertex<T> Find(T item) //查找指定项并返回 
        {
            foreach (Vertex<T> v in items)
            {
                if (v.data.Equals(item))
                {
                    return v;
                }
            }
            return null;
        }
        //添加有向边 
        private void AddDirectedEdge(Vertex<T> fromVer, Vertex<T> toVer,int weight)
        {
            if (fromVer.firstEdge == null) //无邻接点时 
            {
                fromVer.firstEdge = new Edge(fromVer,toVer, weight);
            }
            else
            {
                Edge edge = fromVer.firstEdge;
                while(edge.next!=null)
                {   
                    //检查是否添加了重复边 
                    if (edge.adjvex.data.Equals(toVer.data))
                    {
                        throw new ArgumentException("添加了重复的边！");
                    }
                    edge = edge.next;
                }
                edge.next = new Edge(fromVer, toVer, weight); //添加到链表未尾 
                //Edge toVerEdge = toVer.firstEdge; 
                //while (toVerEdge!= null) 
                //{ 
                //    //检查是否添加了重复边 
                //    if (toVerEdge.adjvex.data.Equals(fromVer.data)) 
                //    { 
                //        //是一个环 
                //        IsCycle = true; 
                //    } 
                //    toVerEdge = toVerEdge.next; 
                //} 
            }
            fromVer.OutDegree += 1;
            toVer.InDegree += 1;
        }
        //添加有向边 
        private void AddDirectedEdge(Vertex<T> fromVer, Vertex<T> toVer)
        {
            AddDirectedEdge(fromVer, toVer,0);
        }
        public override string ToString() //仅用于测试 
        {   //打印每个节点和它的邻接点 
            string s = string.Empty;
            foreach (Vertex<T> v in items)
            {
                s += v.data.ToString() + ":";
                if (v.firstEdge != null)
                {
                    Edge tmp = v.firstEdge;
                    while (tmp != null)
                    {
                        s += tmp.adjvex.data.ToString();
                        tmp = tmp.next;
                    }
                }
                s += "/r/n";
            }
            return s;
        }
        //嵌套类，表示链表中的边表结点 
        [Serializable()]
        public class Edge : IComparable<Edge>
        {
            public Vertex<T> adjvex; //边的一个邻接点域 
            public Vertex<T> parentVex; //边的一个邻接点域 
            public Edge next; //下一个边 
            public int Wegit;
            public Edge(Vertex<T> value)
            {
                adjvex = value;
            }
            public Edge(Vertex<T> _parentVex, Vertex<T> _adjvex, int weight)
            {
                Wegit = weight;
                adjvex = _adjvex;
                parentVex = _parentVex;
            }
            public int CompareTo(Edge other)
            {
                return Wegit.CompareTo(other.Wegit);
            }
        }
        //嵌套类，表示存放于数组中的表头(顶点)结点 
        [Serializable()]
        public class Vertex<TValue>
        {
            public TValue data; //数据 
            public Edge firstEdge; //邻接点链表头指针 
            public Boolean visited; //访问标志,遍历时使用 
            public int InDegree;//入度 
            public int OutDegree;//出度 
            public Vertex(TValue value) //构造方法 
            {
                data = value;
            }
            //清除顶点的所有边 
            public void ClearEdges()
            {
                Edge edge = this.firstEdge;
                while (edge != null)
                {
                    edge.adjvex.InDegree -= 1;
                    edge=edge.next;
                }
                this.firstEdge = null;
            }
        }
        ///////////////////////////////// 图的遍历 ///////////////////////////////////////////////// 
        /// <summary> 
        /// 深度优先遍历图 
        /// </summary> 
        /// <param name="vex"></param> 
        /// <param name="strBuilder"></param> 
        /// <returns></returns> 
        private void DepthSearch(Vertex<T> vex,System.Text.StringBuilder strBuilder)
        {
            strBuilder.Append(Convert.ToString(vex.data));
            vex.visited = true;
            Edge edge = vex.firstEdge;
            while (edge!=null)
            {
                if(!edge.adjvex.visited)
                    DepthSearch(edge.adjvex, strBuilder);
                edge = edge.next;
            }
        }
        public string DepthSearch()
        {
            return DepthSearch(this.items[0]);
        }
        public string DepthSearch(Vertex<T> vex)
        {
            System.Text.StringBuilder strBuilder = new System.Text.StringBuilder();
            DepthSearch(vex, strBuilder);
            return strBuilder.ToString();
        }
        /// <summary> 
        /// 广度优先遍历图 
        /// </summary> 
        /// <param name="vex"></param> 
        /// <param name="strBuilder"></param> 
        /// <returns></returns> 
        private void BreadthSearch(Vertex<T> vex, System.Text.StringBuilder strBuilder)
        {
            Queue<Vertex<T>> queue = new Queue<Vertex<T>>();
            queue.Enqueue(vex);
            vex.visited = true;
            strBuilder.Append(vex.data.ToString());
            while (queue.Count > 0)
            {
                Edge edge = queue.Dequeue().firstEdge;
                while(edge != null)
                {
                    Vertex<T> tempVex = edge.adjvex;
                    if (!tempVex.visited)
                    {
                        queue.Enqueue(tempVex);
                        tempVex.visited = true;
                        strBuilder.Append(tempVex.data.ToString());
                    }
                    edge = edge.next;
                }
            }
        }
        public string BreadthSearch(Vertex<T> vex)
        {
            System.Text.StringBuilder strBuilder = new System.Text.StringBuilder();
            BreadthSearch(vex, strBuilder);
            return strBuilder.ToString();
        }
        public string BreadthSearch()
        {
            return BreadthSearch(this.items[0]);
        }
        public void ResetVisitedStatus()
        {
            foreach (Vertex<T> vex in this.items)
            {
                vex.visited = false;
            }
        }
        ////////////////////////////////// 最小生成树部份(Minimal Spanning Trees) ///////////////////// 
        public string GetMstByKruskal()
        {
            string strValue = string.Empty;
            List<Edge> list = new List<Edge>();
            foreach (Vertex<T> vex in this.items)
            {
                Edge edge = vex.firstEdge;
                vex.visited = true;
                while (edge != null)
                {
                    if(edge.adjvex!=null && !edge.adjvex.visited)
                        list.Add(edge);
                    edge = edge.next;
                }
            }
            list.Sort();
            ResetVisitedStatus();
            int i, k;
            for (i=0,k=0;i<list.Count && k<this.items.Count-1;i++)
            {
                Edge edge = list[i];
                if (edge.adjvex.visited)
                    continue;
                strValue += edge.parentVex.data.ToString() + ":" + edge.adjvex.data.ToString()+"|";
                k++;
            }
            return strValue;
        }
        public string GetMstByPrim()
        {
            List<Vertex<T>> vexList = new List<Vertex<T>>();
            //最小边的父顶点 
            Vertex<T> minEdgeParentVex = this.items[0];
            List<Edge> edgeList = new List<Edge>();
            string strValue = string.Empty;
            vexList.Add(this.items[0]);
            while (vexList.Count < this.items.Count)
            {
                Edge minEdge = null;  
                //找到的最小边和它的父顶点 
                foreach (Vertex<T> vex in vexList)
                {
                    Edge edge = vex.firstEdge;
                    while (edge != null)
                    {
                        if (!edge.adjvex.visited)
                        {
                            if (minEdge == null)
                            {
                                minEdge = edge;
                                minEdgeParentVex = vex;
                            }
                            else
                            {
                                if (edge.Wegit < minEdge.Wegit)
                                {
                                    minEdge = edge;
                                    minEdgeParentVex = vex;
                                }
                            }
                        }
                        edge = edge.next;
                    }
                }
                minEdgeParentVex.visited = true;
                minEdge.adjvex.visited = true;
                edgeList.Add(minEdge);
                vexList.Add(minEdge.adjvex);
                strValue += minEdge.parentVex.data + ":" + minEdge.adjvex.data.ToString() + "|";
            }
            return strValue;
        }  
        ///////////////////////////////// 最短路径 /////////////////////////////////////////// 
        private class PassedPathInfo
        {
            public int Weight;
            public List<T> PassedVertexs;
            public PassedPathInfo(int _Weight,T firstPath)
            {
                Weight = _Weight;
                PassedVertexs = new List<T>();
                PassedVertexs.Add(firstPath);
            }
            public PassedPathInfo(int _Weight,List<T> list)
            {
                Weight = _Weight;
                PassedVertexs = list;
            }
            public void ClearPath()
            {
                PassedVertexs.Clear();
            }
            public void AddWeight(int _Weight)
            {
                Weight += _Weight;
            }
            public void AddPath(T path)
            {
                PassedVertexs.Add(path);
            }
        }
        /// <summary> 
        /// dijkstra 算法 
        /// </summary> 
        /// <param name="originVertex"></param> 
        /// <param name="destVertex"></param> 
        /// <returns></returns> 
        public string GetMinPath(T originVertex,T destVertex)
        {
            if(originVertex.Equals(destVertex))
                throw new Exception("起始顶点不能是目标定顶");
            Vertex<T> originVex = this.Find(originVertex);
            Vertex<T> destVex = this.Find(destVertex);
            if (originVex == null || destVex == null)
            {
                throw new Exception("起始顶点或目标定顶未找到");
            }
            Dictionary<T, PassedPathInfo> vexPssedPaths = new Dictionary<T, PassedPathInfo>();
            RecursiveFindMinPath(vexPssedPaths, originVex);
            if (!vexPssedPaths.ContainsKey(destVertex))
                throw new Exception("起始顶点不能到达目标顶点");
            //return vexPssedPaths[destVertex].Weight.ToString(); 
            string strValue = string.Empty;
            Dictionary<T, PassedPathInfo>.Enumerator e = vexPssedPaths.GetEnumerator();
            while (e.MoveNext())
            {
                strValue += e.Current.Key + ":"+e.Current.Value.Weight.ToString()+"|";
                if (e.Current.Value.PassedVertexs != null)
                {
                    foreach (T vexStr in e.Current.Value.PassedVertexs)
                    {
                        strValue += "-->";
                        strValue += vexStr;
                    }
                }
                else
                {
                    strValue += "无路径";
                }
                strValue += "/r/n";
            }
            return strValue;
        }
      
        private void RecursiveFindMinPath(Dictionary<T, PassedPathInfo> vexPssedPaths, Vertex<T> originVex)
        {
            Edge edge = originVex.firstEdge;
            while (edge != null)
            {
                if (edge.adjvex.visited)
                {
                    edge = edge.next;
                    continue;
                }
                //当前边的父顶点是否已经完成访问,在路径集合体内就表示已经访问过了 
                bool bParentVexVisited = vexPssedPaths.ContainsKey(edge.parentVex.data);
                //当前边的子顶点是否已经完成访问,在路径集合体内就表示已经访问过了 
                bool bChildVexVisited = vexPssedPaths.ContainsKey(edge.adjvex.data);
                //当前边的子顶点的路径信息对象 
                PassedPathInfo childPassedPath = bChildVexVisited ? vexPssedPaths[edge.adjvex.data] : null;
                //当前边的父顶点的路径信息对象 
                PassedPathInfo parentPassedPath = bParentVexVisited ? vexPssedPaths[edge.parentVex.data] : null;
                //如果当前边的父顶点的路径信息对象不为空则copy一分副本 
                List<T> parentPathListCopy = bParentVexVisited ? new List<T>(parentPassedPath.PassedVertexs) ?? null:null;
                
                //如果下一个顶点没有路径信息的话 
                if (!bChildVexVisited)
                {           
                    //父顶点和子顶点都没有访问(父顶点是源点) 
                    if (!bParentVexVisited)
                    {
                        List<T> list = new List<T>() { edge.parentVex.data, edge.adjvex.data };
                        vexPssedPaths.Add(edge.adjvex.data, new PassedPathInfo(edge.Wegit, list));
                    }
                    else
                    {
                        //父顶点与当前路径的权值与路径相加赋给子顶点对象 
                        parentPathListCopy.Add(edge.adjvex.data);
                        vexPssedPaths.Add(edge.adjvex.data, new PassedPathInfo(parentPassedPath.Weight + edge.Wegit,parentPathListCopy));
                    }
                }
                else //子顶点已经有路径时 
                {
                    if (!bParentVexVisited)
                    {
                        if (edge.Wegit < childPassedPath.Weight)
                        {
                            parentPathListCopy.Add(edge.adjvex.data);
                            childPassedPath.Weight = parentPassedPath.Weight + edge.Wegit;
                            childPassedPath.PassedVertexs = parentPathListCopy;
                        }
                    }
                    else
                    {
                        int temp = parentPassedPath.Weight + edge.Wegit;
                        if (temp < childPassedPath.Weight)
                        {
                            parentPathListCopy.Add(edge.adjvex.data);
                            childPassedPath.Weight = temp;
                            childPassedPath.PassedVertexs = parentPathListCopy;
                        }
                    }
                }
                edge = edge.next;
            }
            originVex.visited = true;
            /*在经从源顶点经过的路径中找到最小的路径,找最小只是为了以后算法优化
              不用把所有源点到其它顶点的路径都找出来*/
            Dictionary<T, PassedPathInfo>.Enumerator e = vexPssedPaths.GetEnumerator();
            Vertex<T> vex=null;
            int minWeight = int.MaxValue;
            while (e.MoveNext())
            {
                Vertex<T> temp = this.Find(e.Current.Key);
                if (!temp.visited && e.Current.Value.Weight < minWeight)
                {
                    minWeight = e.Current.Value.Weight;
                    vex = temp;
                }
            }
            if (vex != null)
                RecursiveFindMinPath(vexPssedPaths, vex);
        }
        //////////////////////////////// 拓谱排序 ///////////////////////////////////// 
        public string TopologicalSort()
        {
            if (this.IsCycle)
                return "此图是一个环";
            List<Vertex<T>> deepCopyVexList = (List<Vertex<T>>)HBDiscover.Utility
                .CloneHelpers.DeepClone(this.items);
            string strResult = string.Empty;
            List<Vertex<T>> topoVexList = new List<AdjacencyList<T>.Vertex<T>>();
            while (topoVexList.Count < this.items.Count)
            {
                foreach (Vertex<T> tempVex in deepCopyVexList)
                {
                    if (!tempVex.visited  && tempVex.InDegree <= 0)
                    {
                        tempVex.ClearEdges();
                        topoVexList.Add(tempVex);
                        strResult += tempVex.data.ToString();
                        tempVex.visited = true;
                    }
                }
            }
            return strResult;
        }
    }
}