解决图的编程问题（含有：深度优先搜索算法，广度优先搜索算法，Dijkstra最短路径算法）

红太狼 2021-09-18 10:46 273阅读 0赞

![20190309142321281.png][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2_size_16_color_FFFFFF_t_70][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2_size_16_color_FFFFFF_t_70 1][]

# （一）用邻接矩阵解决图的编程问题 （此代码里面含有Dijkstra最短路径算法，在最后面） #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2_size_16_color_FFFFFF_t_70 2][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2_size_16_color_FFFFFF_t_70 3][]

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 用邻接矩阵解决图的编程问题
    {
        class Program
        {
            static void Main(string[] args)
            {
            }
        }
        public class Node<T>
        {
            private T data;//数据域
    
            public T Data { get => data; set => data = value; }
    
            public Node(T v)
            {
                data = v;
            }
        }
    
        //图的基本操作
        public interface IGraph<T>
        {
            void SetNode(int index, Node<T> v);//设置索引为index的顶点的信息
    
            void SetEdge(Node<T> v1, Node<T> v2, int v);//在结点v1和v2之间添加权值为v的边        
            void SetEdge(Node<T> v1, Node<T> v2);//设置顶点v1,v2之间的边
            void SetEdge(int index1, int index2);//设置索引为index1和index2的两个顶点之间的边
    
            int GetEdge(Node<T> v1, Node<T> v2);//获取结点v1,v2之间的边    
            int GetEdge(int index1, int index2);//获取索引index1和index2的两个顶点之间的边
    
            void DelEdge(Node<T> v1, Node<T> v2);//删除结点v1，v2之间的边
    
            int GetNumOfVertex();//获取顶点的数目
            int GetNumOfEdge();//获取边的数目
    
            Node<T> GetNode(int index);//根据索引获取图中的顶点
            int GetIndex(Node<T> v);//获取顶点v在顶点数组中的索引
    
            bool IsEdge(Node<T> v1, Node<T> v2);//判断结点v1,v2之间是否存在边
            bool IsNode(Node<T> v);//判断v是否是图的顶点
        }
    
        public class GraphAdjMatrix<T> : IGraph<T>
        {
            private Node<T>[] nodes;//顶点数组
            private int[,] matrix;//邻接矩阵数组
            private int numEdges;//边的数目
    
            //初始化邻接矩阵
            public GraphAdjMatrix(int n)
            {
                nodes = new Node<T>[n];
                matrix = new int[n, n];
            }
    
            /// <summary>
            /// 获取边的数目
            /// </summary>
            /// <returns></returns>
            public int GetNumOfEdge()
            {
                return numEdges;
            }
    
            /// <summary>
            /// 获取顶点的数目
            /// </summary>
            /// <returns></returns>
            public int GetNumOfVertex()
            {
                return nodes.Length;
            }
    
            /// <summary>
            /// 获取索引index1和index2的两个顶点之间的边
            /// </summary>
            /// <param name="index1"></param>
            /// <param name="index2"></param>
            /// <returns></returns>
            public int GetEdge(int index1, int index2)
            {
                return matrix[index1, index2];
            }
    
            /// <summary>
            /// 设置索引为index1和index2的两个顶点之间的边
            /// </summary>
            /// <param name="index1"></param>
            /// <param name="index2"></param>
            public void SetEdge(int index1, int index2)
            {
                matrix[index1, index2] = 1;
            }
            /// <summary>
            /// 设置索引为index的顶点的信息
            /// </summary>
            /// <param name="index"></param>
            /// <param name="v"></param>
            public void SetNode(int index, Node<T> v)
            {
                nodes[index] = v;
            }
    
            /// <summary>
            /// 获取索引为index的顶点的信息
            /// </summary>
            /// <param name="index"></param>
            /// <returns></returns>
            public Node<T> GetNode(int index)
            {
                return nodes[index];
            }
    
            /// <summary>
            /// 判断结点v是否是图的顶点
            /// </summary>
            /// <param name="v"></param>
            /// <returns></returns>
            public bool IsNode(Node<T> v)
            {
                foreach (Node<T> node in nodes)
                {
                    if (v.Equals(node))
                    {
                        return true;
                    }
                }
                return false;
            }
    
            /// <summary>
            /// 获取顶点v在顶点数组中的索引
            /// </summary>
            /// <param name="v"></param>
            /// <returns></returns>
            public int GetIndex(Node<T> v)
            {
                for (int i = 0; i < nodes.Length; i++)
                {
                    if (nodes[i].Equals(v))
                    {
                        return i;
                    }
                }
                return -1;
            }
    
            /// <summary>
            /// 判断结点v1,v2之间是否存在边
            /// </summary>
            /// <param name="v1"></param>
            /// <param name="v2"></param>
            /// <returns></returns>
            public bool IsEdge(Node<T> v1, Node<T> v2)
            {
                if (!IsNode(v1) || !IsNode(v2))//如果结点v1,v2不是图的顶点
                {
                    Console.WriteLine("Node is not belong to Graph");
                    return false;
                }
                if (matrix[GetIndex(v1), GetIndex(v2)] == 1)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
    
            /// <summary>
            /// 在结点v1和v2之间添加权值为v的边 
            /// </summary>
            /// <param name="v1"></param>
            /// <param name="v2"></param>
            /// <param name="v"></param>
            public void SetEdge(Node<T> v1, Node<T> v2, int v)
            {
                if (!IsNode(v1) || !IsNode(v2))//如果结点v1,v2不是图的顶点
                {
                    Console.WriteLine("Node is not belong to Graph");
                    return;
                }
    
                matrix[GetIndex(v1), GetIndex(v2)] = v;
                matrix[GetIndex(v2), GetIndex(v1)] = v;
                numEdges++;
    
                //为计算最短路径新加的代码，用来将没有边的两个顶点间的权值设为无穷大
                for (int i = 0; i < GetNumOfVertex (); i++)
                {
                    for (int j = i+1; j < GetNumOfVertex (); j++)//???
                    {
                        if(matrix[i, j] == 0)
                        {
                            matrix[i, j] = int.MaxValue;//用整数的最大值代表无穷大
                            matrix[j, i] = int.MaxValue;
                        }
                    }
                }
            }
    
            /// <summary>
            /// 设置顶点v1,v2之间的边
            /// </summary>
            /// <param name="v1"></param>
            /// <param name="v2"></param>
            public void SetEdge(Node<T> v1, Node<T> v2)
            {
                SetEdge(v1, v2, 1);
            }
    
            /// <summary>
            /// 获取结点v1,v2之间的边 
            /// </summary>
            /// <param name="v1"></param>
            /// <param name="v2"></param>
            /// <returns></returns>
            public int GetEdge(Node<T> v1, Node<T> v2)
            {
                if (!IsNode(v1) || !IsNode(v2))
                {
                    Console.WriteLine("Node is not belong to Graph");
                    return 0;
                }
                return matrix[GetIndex(v1), GetIndex(v2)];
            }
    
            /// <summary>
            /// 删除结点v1，v2之间的边
            /// </summary>
            /// <param name="v1"></param>
            /// <param name="v2"></param>
            public void DelEdge(Node<T> v1, Node<T> v2)
            {
                if (!IsNode(v1) || !IsNode(v2))
                {
                    Console.WriteLine("Node is not belong to Graph");
                    return;
                }
                if (matrix[GetIndex(v1), GetIndex(v2)] == 1)
                {
                    matrix[GetIndex(v1), GetIndex(v2)] = 0;
                    matrix[GetIndex(v2), GetIndex(v1)] = 0;
                    numEdges--;
                }
            }
    
            #region Dijkstra最短路径算法
            /// <summary>
            /// Dijkstra最短路径算法
            /// </summary>
            /// <param name="distance"></param>
            /// <param name="n"></param>
            public void Dijkstra(ref int[] distance, Node<T> n)
            {
                int v = 0;
                bool[] final = new bool[nodes.Length];
                for (int i = 0; i < nodes.Length; i++)
                {
                    final[i] = false;
                    distance[i] = matrix[GetIndex(n), i];
                }
                distance[GetIndex(n)] = 0;//n为源点
                final[GetIndex(n)] = true;
    
                for (int i = 0; i < nodes.Length; i++)//处理从源点到其余顶点的最短路径
                {
                    int min = int.MaxValue;
                    for (int j = 0; j < nodes.Length; j++)//比较从源点到其余顶点的路径长度
                    {
                        if (!final[j])//从源点到j顶点的最短路径还没有找到
                        {
                            if (distance[j] < min)//从源点到j顶点的路径长度最小
                            {
                                v = j;
                                min = distance[j];
                            }
                        }
                    }
    
                    final[v] = true;//源点到顶点k的路径长度最小
                    for (int w = 0; w < nodes.Length; w++)//更新当前最短路径及距离
                    {
                        if (final[w] == false)
                        {
                            if (matrix[v, w] != int.MaxValue && (min + matrix[v, w] < distance[w]))
                            {
                                distance[w] = min + matrix[v, w];
                            }
                        }
                    }
                }
            }
            #endregion
    
        }
    }

# （二）用邻接表解决图的编程问题（已将深度优先搜索算法和广度优先搜索算法写进去了，在代码的最后面） #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2_size_16_color_FFFFFF_t_70 4][]

using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 用邻接表解决图的编程问题
    {
        class Program
        {
            static void Main(string[] args)
            {
            }
        }
    
        public class Node<T>
        {
            private T data;//数据域
    
            public T Data { get => data; set => data = value; }
    
            public Node(T v)
            {
                data = v;
            }
        }
    
        //邻接表结点类
        public class AdjListNode<T>
        {
            private int adjvex;//邻接顶点序号。注意：不是表示该结点相邻的结点的序号，而是表示自己的序号！不要被误导了
            private int info;//存储边或弧相关的信息，如权值
            private AdjListNode<T> nextadj;//下一个邻接表结点
    
            public int Adjvex { get => adjvex; set => adjvex = value; }
            public int Info { get => info; set => info = value; }
            public AdjListNode<T> Nextadj { get => nextadj; set => nextadj = value; }
    
            public AdjListNode (int adjvex)
            {
                this.adjvex = adjvex;
                nextadj = null;
            }
            public AdjListNode (int adjvex,int info)
            {
                this.adjvex = adjvex;
                this.info = info;
                nextadj = null;
            }
        }
    
        //顶点结点类 
        public  class VexNode<T>
        {
            private Node<T> data;//图的顶点
            private AdjListNode<T> firstadj;//邻接表的第1个结点
    
            public Node<T> Data { get => data; set => data = value; }
            public AdjListNode<T> Firstadj { get => firstadj; set => firstadj = value; }
    
            //初始化顶点结构
            public VexNode (Node <T> node)
            {
                data = node;
                firstadj = null;
            }
            public VexNode (Node <T> node,AdjListNode <T> alNode)
            {
                data = node;
                firstadj = alNode;
            }
        }
    
        //图的基本操作
        public interface IGraph<T>
        {
            void SetNode(int index, Node<T> v);//设置索引为index的顶点的信息
    
            void SetEdge(Node<T> v1, Node<T> v2, int v);//在结点v1和v2之间添加权值为v的边        
            void SetEdge(Node<T> v1, Node<T> v2);//设置顶点v1,v2之间的边
            void SetEdge(int index1, int index2);//设置索引为index1和index2的两个顶点之间的边
    
            int GetEdge(Node<T> v1, Node<T> v2);//获取结点v1,v2之间的边    
            int GetEdge(int index1, int index2);//获取索引index1和index2的两个顶点之间的边
    
            void DelEdge(Node<T> v1, Node<T> v2);//删除结点v1，v2之间的边
    
            int GetNumOfVertex();//获取顶点的数目
            int GetNumOfEdge();//获取边的数目
    
            Node<T> GetNode(int index);//根据索引获取图中的顶点
            int GetIndex(Node<T> v);//获取顶点v在顶点数组中的索引
    
            bool IsEdge(Node<T> v1, Node<T> v2);//判断结点v1,v2之间是否存在边
            bool IsNode(Node<T> v);//判断v是否是图的顶点
        }
    
        public class GraphAdjList<T> : IGraph<T>
        {
            private VexNode<T>[] adjList;//邻接表数组
    
            /// <summary>
            /// 初始化邻接表
            /// </summary>
            /// <param name="nodes"></param>
            public GraphAdjList(Node<T>[] nodes)
            {
                adjList = new VexNode<T>[nodes.Length];
                for (int i = 0; i < nodes .Length ; i++)
                {
                    adjList[i] = new VexNode<T>(nodes[i]);
                }
            }
    
            /// <summary>
            /// 获取顶点的数目
            /// </summary>
            /// <returns></returns>
            public int GetNumOfVertex()
            {
                return adjList.Length;
            }
    
            /// <summary>
            /// 设置索引为index的顶点的信息
            /// </summary>
            /// <param name="index"></param>
            /// <param name="v"></param>
            public void SetNode(int index, Node<T> v)
            {
                adjList[index] = new VexNode<T>(v);
            }
    
            /// <summary>
            /// 获取索引为index的顶点的信息
            /// </summary>
            /// <param name="index"></param>
            /// <returns></returns>
            public Node<T> GetNode(int index)
            {
                return adjList[index].Data;
            }
    
            /// <summary>
            /// 判断结点v是否是图的顶点
            /// </summary>
            /// <param name="v"></param>
            /// <returns></returns>
            public bool IsNode(Node<T> v)
            {
                foreach (VexNode <T> node in adjList )
                {
                    if(v.Equals (node .Data))
                    {
                        return true;
                    }
                }
                return false;
            }
    
            /// <summary>
            /// 获取顶点v在邻接表数组中的索引
            /// </summary>
            /// <param name="v"></param>
            /// <returns></returns>
            public int GetIndex(Node<T> v)
            {
                for (int i = 0; i < adjList .Length ; i++)
                {
                    if(adjList [i].Data.Data.Equals (v.Data ))
                    {
                        return i;
                    }
                }
                return -1;
            }
    
            /// <summary>
            /// 判断结点v1,v2之间是否存在边
            /// </summary>
            /// <param name="v1"></param>
            /// <param name="v2"></param>
            /// <returns></returns>
            public bool IsEdge(Node<T> v1, Node<T> v2)
            {
                if(!IsNode (v1)||!IsNode(v2))
                {
                    Console.WriteLine("Node is not belong to Graph");
                    return false;
                }
    
                AdjListNode<T> p = adjList[GetIndex(v1)].Firstadj;
                while (p!=null)
                {
                    if(p.Adjvex ==GetIndex(v2))//???
                    {
                        return true;
                    }
                    p = p.Nextadj;
                }
                return false;
            }
    
            /// <summary>
            /// 获取边的数目
            /// </summary>
            /// <returns></returns>
            public int GetNumOfEdge()
            {
                int i = 0;
                foreach (VexNode <T> node in adjList )
                {
                    AdjListNode<T> p = node.Firstadj;
                    while (p!=null)
                    {
                        i++;
                        p = p.Nextadj;
                    }
                }
                return i / 2;
            }
    
            /// <summary>
            /// 在结点v1和v2之间添加权值为v的边
            /// </summary>
            /// <param name="v1"></param>
            /// <param name="v2"></param>
            /// <param name="v"></param>
            public void SetEdge(Node<T> v1, Node<T> v2, int v)
            {
                if(!IsNode (v1 )||!IsNode (v2 )||IsEdge(v1, v2))
                {
                    Console.WriteLine("Node is not belong to Graph");
                    return;
                }
                if (v == 0)
                {
                    return;
                }
                AdjListNode<T> p;
    
                p = new AdjListNode<T>(GetIndex(v2), v);
                if (adjList [GetIndex (v1)].Firstadj ==null)
                {
                    adjList[GetIndex(v1)].Firstadj = p;
                }
                else 
                {
                    p.Nextadj = adjList[GetIndex(v1)].Firstadj;
                    adjList[GetIndex(v1)].Firstadj = p;
                }
    
                p = new AdjListNode<T>(GetIndex(v1), v);
                if (adjList[GetIndex(v2)].Firstadj == null)
                {
                    adjList[GetIndex(v2)].Firstadj = p;
                }
                else 
                {
                    p.Nextadj = adjList[GetIndex(v2)].Firstadj;
                    adjList[GetIndex(v2)].Firstadj = p;
                }
    
            }
    
            /// <summary>
            /// 设置顶点v1,v2之间的边
            /// </summary>
            /// <param name="v1"></param>
            /// <param name="v2"></param>
            public void SetEdge(Node<T> v1, Node<T> v2)
            {
                SetEdge(v1, v2, 1);
            }
    
            /// <summary>
            /// 设置索引为index1和index2的两个顶点之间的边
            /// </summary>
            /// <param name="index1"></param>
            /// <param name="index2"></param>
            public void SetEdge(int index1, int index2)
            {
                SetEdge(GetNode(index1), GetNode(index2), 1);
            }
    
            /// <summary>
            /// 获取索引index1和index2的两个顶点之间的边
            /// </summary>
            /// <param name="index1"></param>
            /// <param name="index2"></param>
            /// <returns></returns>
            public int GetEdge(int index1, int index2)
            {
                if(!IsNode (GetNode (index1 ))||!IsNode (GetNode (index2)))
                {
                    Console.WriteLine("Node is not belong to Graph");
                    return 0;
                }
                AdjListNode<T> p = adjList[index1].Firstadj;
                while (p!=null)
                {
                    if(p.Adjvex ==index2)
                    {
                        return p.Info;
                    }
                    p = p.Nextadj;
                }
                return 0;
            }
    
            /// <summary>
            /// 获取结点v1,v2之间的边  
            /// </summary>
            /// <param name="v1"></param>
            /// <param name="v2"></param>
            /// <returns></returns>
            public int GetEdge(Node<T> v1, Node<T> v2)
            {
    
                AdjListNode<T> p = adjList[GetIndex(v1)].Firstadj;
                while (p!=null)
                {
                    if(p.Adjvex ==GetIndex (v2))
                    {
                        return p.Info;
                    }
                    p = p.Nextadj;
                }
                return 0;
            }
    
            /// <summary>
            /// 删除结点v1，v2之间的边
            /// </summary>
            /// <param name="v1"></param>
            /// <param name="v2"></param>
            public void DelEdge(Node<T> v1, Node<T> v2)//???
            {
                if (!IsNode(v1) || !IsNode(v2))
                {
                    Console.WriteLine("Node is not belong to Graph");
                    return ;
                }
                if(IsEdge(v1, v2))
                {
                    AdjListNode<T> p = adjList[GetIndex(v1)].Firstadj;
                    AdjListNode<T> pre = null;
                    while (p!=null)
                    {
                        if(p.Adjvex !=GetIndex (v2))
                        {
                            pre = p;
                            p = p.Nextadj;
                        }
                    }
                    pre.Nextadj = p.Nextadj;
                    p = adjList[GetIndex(v2)].Firstadj;
                    pre = null;
                    while (p!=null)
                    {
                        if(p.Adjvex !=GetIndex(v1))
                        {
                            pre = p;
                            p = p.Nextadj;
                        }
                    }
                    pre.Nextadj = p.Nextadj;
                }
               
            }
    
            #region 图的遍历：深度优先搜索算法，广度优先搜索算法
            private bool[] visited;
            /// <summary>
            /// 深度优先搜索算法
            /// </summary>
            /// <param name="v"></param>
            /// <returns></returns>
            public Node<T>[] DFSAL(Node<T> v)
            {
                int i = GetIndex(v);
                int m = 0;
                Node<T>[] nodes = new Node<T>[GetNumOfVertex()];
                visited[i] = true;
                Stack stack = new Stack();//需要导入命名空间：System.Collections
                stack.Push(i);
                while (stack.Count > 0)
                {
                    int k = (int)stack.Pop();
                    nodes[m++] = adjList[k].Data;
                    AdjListNode<T> p = adjList[k].Firstadj;
                    while (p != null)
                    {
                        if (visited[p.Adjvex] == false)
                        {
                            visited[p.Adjvex] = true;
                            stack.Push(p.Adjvex);
                        }
                        p = p.Nextadj;
                    }
                }
                for (int j = 0; j < visited.Length; j++)
                {
                    if (visited[j] == false)
                    {
                        DFSAL(GetNode(j));
                    }
                }
                return nodes;
            }
    
            /// <summary>
            /// 广度优先搜索算法
            /// </summary>
            /// <param name="v"></param>
            /// <returns></returns>
            public Node<T>[] BFSAL(Node<T> v)
            {
                int i = GetIndex(v);
                int m = 0;
                Node<T>[] nodes = new Node<T>[GetNumOfVertex()];
                visited[i] = true;
                Queue queue = new Queue();//需要导入命名空间：System.Collections
                queue.Enqueue(i);
                while (queue.Count > 0)
                {
                    int k = (int)queue.Dequeue();
                    nodes[m++] = adjList[k].Data;
                    AdjListNode<T> p = adjList[k].Firstadj;
                    while (p != null)
                    {
                        if (visited[p.Adjvex] == false)
                        {
                            visited[p.Adjvex] = true;
                            queue.Enqueue(p.Adjvex);
                        }
                        p = p.Nextadj;
                    }
                }
                for (int j = 0; j < visited.Length; j++)
                {
                    if (visited[j] == false)
                    {
                        BFSAL(GetNode(j));
                    }
                }
                return nodes;
            }
            #endregion
    
        }
    }

# （三）解决图的遍历问题（深度优先搜索，广度优先搜索） #

## 1.深度优先搜索（代码在上面） ##

![20190309143020898.png][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2_size_16_color_FFFFFF_t_70 5][]

## 2.广度优先搜索（代码在上面） ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2_size_16_color_FFFFFF_t_70 6][]

[20190309142321281.png]: https://img-blog.csdnimg.cn/20190309142321281.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190309142240766.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2_size_16_color_FFFFFF_t_70 1]: /images/20210725/a725afcf8e164e87b609e350c69ad5dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20190309142504234.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2_size_16_color_FFFFFF_t_70 3]: /images/20210725/e972a2671eaa4a40a81ccd8a9b3d0d45.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2_size_16_color_FFFFFF_t_70 4]: /images/20210725/1166a32185b94c02954c8cddb8c98d7e.png
[20190309143020898.png]: https://img-blog.csdnimg.cn/20190309143020898.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2_size_16_color_FFFFFF_t_70 5]: /images/20210725/48b296690c444d539e4cae6658a3d22c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzIzMjU2_size_16_color_FFFFFF_t_70 6]: /images/20210725/7e9ecd025b334df084b65cc1ce44af39.png

发表评论取消回复

表情：

评论列表（有 0 条评论，273人围观）

还没有评论，来说两句吧...

相关阅读

相关【算法】算法学习四：图 | 广度优先搜索 | 深度优先搜索

文章目录一、什么是图？二、广度优先搜索三、什么是队列四、广度优先搜索的实现 4.1 实现全部的代码 4.2 队列

向右看齐/ 2023年10月10日 21:39/ 0 赞/ 70 阅读

相关基本图算法（广度优先搜索和深度优先搜索）

图算法对于计算机学科至关重要。成百上千的计算问题最后都可以归约为图论问题。本文主要是对《算法导论》图算法的学习笔记进行整理。首先，我们先对图算法中的一些表达方式进行统一：给

痛定思痛。/ 2022年08月25日 02:20/ 0 赞/ 253 阅读

相关图的深度优先和广度优先搜索算法

图的深度优先和广度优先搜索算法本文取自《数据结构与算法》(C语言版)(第三版)，出版社是清华大学出版社。本博文作为学习资料整理。附书的截图： ![Ce

清疚/ 2022年08月21日 03:22/ 0 赞/ 225 阅读

相关【经典算法】:图的深度优先搜索与广度优先搜索的实现

非常简单，深度优先搜索可以用递归或者栈来实现，广度优先搜索用队列来实现，仅仅是数据结构换了一下而已，其他任何的东西都没有变。实现样例代码： include<ios

旧城等待，/ 2022年06月07日 03:21/ 0 赞/ 189 阅读

相关搜索算法之深度优先搜索和广度优先搜索

所谓深度优先搜索：就是一条道走到黑，不碰南墙不回头的那种。广度优先搜索：就是从你所站的位置向周围扩散性的搜索，通俗来讲，就是你在黑夜里眼睛掉了，你肯定是趴在地

梦里梦外;/ 2022年06月01日 06:36/ 0 赞/ 455 阅读

相关 BFS（广度优先搜索算法）和DFS（深度优先搜索算法）

注意：①BFS和DFS都是对图的遍历(按照某种次序访问图的每一顶点一次仅且一次) ②存储图的两种方式：邻接表和邻接矩阵（本质就是二维数组）一

港控/mmm°/ 2022年05月18日 08:16/ 0 赞/ 325 阅读

相关经典搜索算法之深度优先搜索和广度优先搜索

1.深度优先搜索（DFS）深度优先搜索是从一个顶点开始，沿着一条路一直走到底，如果发现不能到达目标解，那就返回到上一个节点，然后从另一条路开始走到底，即尽可能的往深

忘是亡心i/ 2022年05月16日 04:20/ 0 赞/ 346 阅读

相关算法 -- 广度优先搜索

广度优先搜索（BFS）：是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra[单源最短路径][Link 1]算法和Prim[最小生成树][Link

ゞ浴缸里的玫瑰/ 2022年05月13日 06:46/ 0 赞/ 235 阅读

相关解决图的编程问题（含有：深度优先搜索算法，广度优先搜索算法，Dijkstra最短路径算法）

![20190309142321281.png][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly

红太狼/ 2021年09月18日 10:46/ 0 赞/ 274 阅读

相关 BFS广度优先搜索 DFS深度优先搜索回溯算法

一、BFS广度优先搜索 ![这里写图片描述][SouthEast] ![这里写图片描述][SouthEast 1] ![这里写图片描述][SouthEast 2]

﹏ヽ暗。殇╰゛Y/ 2021年09月14日 03:06/ 0 赞/ 441 阅读