Unity中广度优先搜索

广度优先搜索算法(Breadth-First-Search)，是一种图形搜索算法。简单的说，BFS是从根节点开始，沿着树(图)的宽度遍历树(图)的节点。如果所有节点均被访问，则算法中止。BFS同样属于盲目搜索。一般用队列数据结构来辅助实现BFS算法。

广度优先遍历的步骤：

1.  首先将根节点放入队列中。
2. 从队列中取出第一个节点，并检验它是否为目标。
3. 如果找到目标，则结束搜寻并回传结果。
4. 否则将它所有尚未检验过的直接子节点加入队列中。
5. 若队列为空，表示整张图都检查过了——亦即图中没有欲搜寻的目标。结束搜寻并回传“找不到目标”。
6. 重复步骤2。

简单例子：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class BFS : MonoBehaviour
{
    void Start()
    {
        int[,] aa = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
        BFSSort(aa, 0);
    }

    public void BFSSort(int[,] graph, int start)
    {
        Queue<int> queue = new Queue<int>();
        HashSet<int> seen = new HashSet<int>();

        queue.Enqueue(start);
        seen.Add(start);

        while (queue.Count > 0)
        {
            int vertex = queue.Dequeue();
            for (int i = 0; i < graph.GetLength(0); i++)
            {
                if (!seen.Contains(i))
                {
                    queue.Enqueue(i);
                    seen.Add(i);
                }
                Debug.Log(graph[vertex, i]);
            }
        }
    }
}

Unity中实现找到所有的子节点

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 获取所有关键
/// </summary>
public class BreathFirst : MonoBehaviour
{
    List<Transform> BreadthFirstList = new List<Transform>();//层次遍历所得到的List
 
    /// <summary>
    /// 首先把物体的第一层子物体放入一个List，便于之后使用
    /// </summary>
    void Start()
    {
        List<Transform> joinsList = new List<Transform>();
        foreach (Transform itemJoins in transform)
        {
            joinsList.Add(itemJoins);
        }
        BreadthFirst_1(joinsList);
 
        foreach (var item in BreadthFirstList)
        {
            Debug.Log(item);
        }
    }
 
    /// <summary>
    /// 递归遍历每一层
    /// </summary>
    /// <param name="joins"></param>
    void BreadthFirst_1(List<Transform> joins)
    {
        List<Transform> joinsChildListss = new List<Transform>();
        foreach (Transform item in joins)
        {
            BreadthFirstList.Add(item);//将每一层依次放入列表中
            if (item.childCount != 0)//判断每一次的序列项是否存在子物体，存在就将所有子物体放入一个新的List
            {
                foreach (Transform itemss in item)
                {
                    joinsChildListss.Add(itemss);
                }
            }
        }
        if (joinsChildListss != null && joinsChildListss.Count != 0)//判断是否是最后一层
            BreadthFirst_1(joinsChildListss);
    }
}
 

 

参考自：https://blog.csdn.net/qq_45746318/article/details/107438415

https://blog.csdn.net/aiyan1111111/article/details/78426161?utm_source=blogxgwz7

https://blog.csdn.net/A13155283231/article/details/78864723

------------------------------------深度优先与广度优先的区别------------------------------------------------

1） 二叉树的深度优先遍历的非递归的通用做法是采用栈，广度优先遍历的非递归的通用做法是采用队列。

 2） 深度优先遍历：对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。要特别注意的是，二叉树的深度优先遍历比较特殊，可以细分为先序遍历、中序遍历、后序遍历。具体说明如下：

• 先序遍历：对任一子树，先访问根，然后遍历其左子树，最后遍历其右子树。
• 中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树。
• 后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。

        广度优先遍历：又叫层次遍历，从上往下对每一层依次访问，在每一层中，从左往右（也可以从右往左）访问结点，访问完一层就进入下一层，直到没有结点可以访问为止。　　　

 3）深度优先搜素算法：不全部保留结点，占用空间少；有回溯操作(即有入栈、出栈操作)，运行速度慢。

       广度优先搜索算法：保留全部结点，占用空间大； 无回溯操作(即无入栈、出栈操作)，运行速度快。

          通常 深度优先搜索法不全部保留结点，扩展完的结点从数据库中弹出删去，这样，一般在数据库中存储的结点数就是深度值，因此它占用空间较少。

所以，当搜索树的结点较多，用其它方法易产生内存溢出时，深度优先搜索不失为一种有效的求解方法。 　

          广度优先搜索算法，一般需存储产生的所有结点，占用的存储空间要比深度优先搜索大得多，因此，程序设计中，必须考虑溢出和节省内存空间的问题。

但广度优先搜索法一般无回溯操作，即入栈和出栈的操作，所以运行速度比深度优先搜索要快些

 

深度优先搜索的应用：

1. 查找图中的路径
2. 寻找连通分量
3. 判断是否有环
4. 判断是否为二分图

广度优先搜索的应用：

1. 查找最短路径
2. 求任意两顶点间最小距离

 参考自：https://zhuanlan.zhihu.com/p/158671778