几个有关图的算法1(图定义和BFS)

这几个算法主要是后面会有用,所以这里给出.

1)图的结构定义(跟前面的差不多,只是为了方便算法,这里做了增加:

 /// <summary>
    /// 图类，由节点和边构成.
    /// </summary>
    public class Graphic
    {
        /// <summary>
        /// 用于图形访问临时公共变量
        /// </summary>
        public int FinishOrder { get; set; }
        /// <summary>
        /// 用于图形访问临时公共变量
        /// </summary>
        public int EnterOrder { get; set; }

        public List<Node> Nodes { get; set; }
        public List<Edge> Edges { get; set; }
        public Graphic()
        {
            Nodes = new List<Node>();
            Edges = new List<Edge>();
        }
        public void Add(Node Node)
        {
            if (this.Nodes.IndexOf(Node) < 0)
            {
                this.Nodes.Add(Node);
            }
        }
        public void Add(Edge Edge)
        {
            if (this.Edges.IndexOf(Edge) < 0)
            {
                this.Edges.Add(Edge);
            }

        }

    }
    /// <summary>
    /// 树类，包括节点和边构成
    /// </summary>
    public class Tree
    {
        public List<Node> Nodes { get; set; }
        public List<Edge> Edges { get; set; }
        public Tree()
        {
            Nodes = new List<Node>();
            Edges = new List<Edge>();
        }
        public void Add(Node Node)
        {
            if (this.Nodes.IndexOf(Node) < 0)
            {
                this.Nodes.Add(Node);
            }
        }
        public void Add(Edge Edge)
        {
            if (this.Edges.IndexOf(Edge) < 0)
            {
                this.Edges.Add(Edge);
            }

        }
    }

    /// <summary>
    /// 节点类
    /// </summary>
    public class Node
    {
        public string Symbol { get; set; }
        public Node Parent { get; set; }
        /// <summary>
        /// 用于算法临时存放，一般为key值.
        /// </summary>
        public decimal TempVal { get; set; }
        public int VisitedSign { get; set; }
        /// <summary>
        /// 用于算法临时存放
        /// </summary>
        public Edge TempEdge { get; set; }
        /// <summary>
        /// 邻接节点
        /// </summary>
        public Dictionary<Node, Edge> AdjNodes;
        public Node(string Symbol)
        {
            this.Symbol = Symbol;
            AdjNodes = new Dictionary<Node, Edge>();
        }
        /// <summary>
        /// 用于深度搜索标记
        /// </summary>
        public int EnterTime { get; set; }
        /// <summary>
        /// 用于深度搜索标记
        /// </summary>
        public int FinishTime { get; set; }

        public int FinishOrder { get; set; }
        public int EnterOrder { get; set; }
    }
    /// <summary>
    /// 边类，包括两个节点和权重.
    /// </summary>
    public class Edge
    {
        public Node Node1 { get; set; }
        public Node Node2 { get; set; }
        public decimal Weight { get; set; }
        public int EdgeType { get; set; }
        public Edge(Node N1, Node N2, decimal Weight)
        {
            this.Node1 = N1;
            this.Node2 = N2;
            this.Weight = Weight;

        }
    }

BFS算法及路径打印:

/// <summary>
    /// 图的搜索算法
    /// </summary>
    public partial class GraphicSearchAlg
    {
        /// <summary>
        /// 广度优先搜索算法,这里只是计算深度.
        /// </summary>
        /// <param name="g">图,基于邻接表示</param>
        /// <param name="s">源点</param>
        public void BFS(Graphic g, Node s)
        {
            //初始化
            foreach (var theNode in g.Nodes)
            {
                theNode.VisitedSign = 0;//0 white,1 gray,2 black
                theNode.TempVal = decimal.MaxValue;
                theNode.Parent = null;
            }
            s.TempVal = 0;
            s.VisitedSign = 1;

            Queue<Node> theQueue = new Queue<Node>();
            theQueue.Enqueue(s);
            while (theQueue.Count > 0)
            {
                Node theNode = theQueue.Dequeue();
                foreach (var theAdjNode in theNode.AdjNodes.Keys)
                {
                    if (theAdjNode.VisitedSign == 0)
                    {
                        theAdjNode.VisitedSign = 1;
                        theAdjNode.TempVal = theNode.TempVal + 1;
                        theAdjNode.Parent = theNode;
                        theQueue.Enqueue(theAdjNode);
                    }
                }
                theNode.VisitedSign = 2;
            }
        }
        /// <summary>
        /// 根据广度优先搜索结果，输出点s到v的路径 
        /// </summary>
        /// <param name="g"></param>
        /// <param name="s"></param>
        /// <param name="v"></param>
        /// <returns></returns>
        public List<Node> PrintPath(Graphic g, Node s, Node v)
        {
            List<Node> thePath = new List<Node>();
            if(s==v)
            {
                thePath.Add(s);
                return thePath;
            }
            if (v.Parent == null)
            {
                return thePath;
            }
            thePath.AddRange(PrintPath(g,s,v.Parent));
            return thePath;
        }
        /// <summary>
        /// 深度优先搜索算法,这里只是计算深度.
        /// </summary>
        /// <param name="g">图,基于邻接表示</param>
        /// <param name="s">源点</param>
       
    }