广度优先搜索不使用队列

广度 首先，Look (BFS) 是一种图表遍历计算，用于研究图表中广度运动中的中心。 BFS 的正常使用利用线路信息结构来跟踪即将到来的集线器。无论如何，可以想象在不使用明确线路的情况下利用其他信息结构来执行 BFS。

在没有线路的情况下实现 BFS 的一种可选方法是利用两个集群或记录：一个用于正在调查的当前级别的集线器，另一个用于要调查的下一级集线器。起初，当前级别列表包含源中心。

计算首先强调当前级别列表并转到每个集线器。对于每个经过的枢纽，其相邻的枢纽都会受到检查。如果未访问相邻的集线器，则将其标记为已访问并添加到其他级别列表中。该句柄将继续进行，直到当前级别列表中的所有集线器都经过为止。

一旦当前级别列表完全遍历完毕，计算将继续到另一个级别列表，并重新哈希前往集线器并检修下一个级别列表的方法。此准备工作将持续进行，直到不再有未访问的节点为止。

使用的方法

广度优先方法

广度优先方法

BFS 算法从源集线器开始，调查其邻居，最近又转移到另一级别的邻居。使用线路信息结构来跟踪您访问的枢纽。在每个周期中，计算都会访问一个集线器，将其标记为已完成，并对未访问的相邻集线器进行排队。此准备工作将持续进行，直到所有可到达的中心都被访问为止。

代码初始化一个向量 adj 来表示图表的传染性列表。向量的每个文件都与一个中心进行比较，每个记录的值包含相邻的中心。 BFS 遍历由 BFS 工作执行，它采用源集线器、集线器数量 N、经过集线器的向量 vis、单独的 dp 以及用于跟踪要访问的集线器的向量 v。 bfsTraversal 工作初始化已消失的集线器并删除向量，然后调用 BFS 工作来执行遍历。

算法

• 创建图表的传染列表表示形式。

• 初始化一行来存储要访问的集线器。

• 初始化消失集群以跟踪消失节点。

• 初始化删除集群以在每个集线器上存储从源集线器删除的内容。将源集线器的分隔符设置为0。

• 将源集线器排入队列并检查其是否已访问。

• 虽然管线不可净化，但请执行以下操作：

• 删除队列头部的集线器。对于已出队且尚未遍历的每个邻居集线器，请执行以下操作： 将相邻集​​线器排队。将相邻的枢纽标记为已访问。将邻居集线器删除更新为出队集线器删除（也是 1）。

• 重复步骤 6，直到该行为空。

• BFS 遍历完成后，单独的集群将包含从源节点到图中所有其他中心的间隔。

• （可选）您还可以在 BFS 遍历中跟踪每个集线器的父集线器，以便以最简单的方式从源集线器到所有其他集线器。

示例

#include <iostream>
#include <queue>
#include <unordered_set>
using namespace std;

void bfsTraversal(int adjacencyList[][2], int numVertices, int source) {
   bool visited[numVertices + 1] = {false};
   int distances[numVertices + 1] = {0};

   queue<int> vertices;
   vertices.push(source);
   visited[source] = true;

   while (!vertices.empty()) {
      int node = vertices.front();
      cout << node << ", ";
      vertices.pop();

      for (int i = 0; i < 2; i++) {
         int next = adjacencyList[node][i];
            
         if (!visited[next]) {
            vertices.push(next);
            distances[next] = distances[node] + 1;
            visited[next] = true;
         }
      }
   }
}

int main() {
    int adjacencyList[][2] = {{0, 0}, {1, 2}, {3, 4}, {0, 0}, {0, 0}};
    int numVertices = 4;
    int source = 2;

    bfsTraversal(adjacencyList, numVertices, source);

    return 0;
}

输出

2,3,4,0

示例

#include <iostream>
#include <vector>
using namespace std;

void bfsTraversal(vector<vector<int>>& adjacencyList, int N, int source) {
    vector<bool> visited(N + 1, false);
    vector<int> distances(N + 1, 0);
    vector<int> vertices;

    vertices.push_back(source);
    visited[source] = true;

    int curr = 0;
    while (curr < vertices.size()) {
        int node = vertices[curr];
        cout << node << ", ";

        for (int i = 0; i < adjacencyList[node].size(); i++) {
            int next = adjacencyList[node][i];

            if (!visited[next]) {
                vertices.push_back(next);
                distances[next] = distances[node] + 1;
                visited[next] = true;
            }
        }

        curr++;
    }

    cout << "\nDistances from source " << source << ":\n";
    for (int i = 1; i <= N; i++) {
        cout << "Node " << i << ": " << distances[i] << endl;
    }
}

int main() {
    int N = 8;
    vector<vector<int>> adjacencyList(N + 1);
    adjacencyList[0] = {1, 2};
    adjacencyList[1] = {2};
    adjacencyList[2] = {0, 3};
    adjacencyList[3] = {3};
    adjacencyList[4] = {5};
    adjacencyList[5] = {6, 7};
    adjacencyList[6] = {};
    adjacencyList[7] = {};
    adjacencyList[8] = {};

    int source = 5;

    bfsTraversal(adjacencyList, N, source);

    return 0;
}

输出

5, 6, 7, 
Distances from source 5:
Node 1: 0
Node 2: 0
Node 3: 0
Node 4: 0
Node 5: 0
Node 6: 1
Node 7: 1
Node 8: 0

结论

本文对不使用行信息结构的广度优先查找 (BFS) 计算进行了说明。 BFS 计算通常用于从给定的源中心开始以逐级方式导航图表。通常，一条线路用于存储要前往的枢纽。无论如何，本文研究了一种可选方法，该方法利用基本列表或集群来存储下一级的集线器。

这种选择性的使用完成了图表的广度优先研究。本文追溯了 BFS 计算的步骤，例如初始化传染性记录、维护 go-to 和分离簇以及使用圆圈来强调中心级别。它还提供了 C 代码说明，说明了不使用一行的 BFS 遍历。该代码准确地研究图表，打印 BFS 遍历排列，并计算从源集线器到所有其他节点的距离。总的来说，本文在不使用线条的情况下对 BFS 计算进行了清晰的说明和可行的用法，展示了一种以广度优先的方式导航图表的可选方法。

以上是广度优先搜索不使用队列的详细内容。更多信息请关注PHP中文网其他相关文章！