递归执行广度优先搜索


152

假设您要递归实现二叉树的广度优先搜索。你会怎么做?

是否可以仅将调用堆栈用作辅助存储?


14
很好的问题。这一点都不简单。基本上,您要求仅使用堆栈来实现BFS。
sisis

4
仅使用堆栈递归?这伤了我的头。
凯文·弗里德海姆

11
我通常使用堆栈来消除递归行为
Newtopian 2010年

如果我在Max堆上使用BFS,我想知道下面给出的解决方案是否正常工作?有什么想法吗 ?
2014年

Answers:


122

(我假设这只是一种思想练习,甚至是一个技巧性的作业/面试问题,但是我想我可以想象一个奇怪的场景,由于某种原因,您不允许任何堆空间使用[一些非常糟糕的习惯内存管理器?一些奇怪的运行时/操作系统问题?],而您仍然可以访问堆栈...)

广度优先遍历通常使用队列,而不是堆栈。队列和堆栈的性质几乎是相反的,因此,除非您这样做,否则尝试将调用堆栈(即堆栈,因此称为名称)用作辅助存储(队列)注定会失败。对于您不应该使用的调用堆栈而言,这太愚蠢了。

同样,您尝试实现的任何非尾递归本质上实际上是在算法中添加了堆栈。这使得它不再在二叉树上进行广度优先搜索,因此传统BFS的运行时和其他条件不再完全适用。当然,您始终可以将任何循环简单地转换为递归调用,但这不是任何有意义的递归。

但是,正如其他人所证明的,有一些方法可以以某种代价实现遵循BFS语义的方法。如果比较的成本很高,而节点遍历的成本很低,那么就像@Simon Buchan一样,您可以简单地运行深度优先的迭代搜索,仅处理叶子。这意味着堆中没有存储增长的队列,只有局部深度变量,并且在遍历树的过程中一遍又一遍地在调用堆栈上建立堆栈。正如@Patrick所指出的,无论如何,数组支持的二叉树通常都以广度优先遍历的顺序存储,因此,在不需要辅助队列的情况下,以广度优先的搜索将是微不足道的。


10
这确实只是一个思想练习。我真的无法想象您会真正想要这样做的情况。感谢深思熟虑的答案!
Nate

2
但是我想我可以想象一个奇怪的场景,由于某种原因而不允许您使用任何堆空间 ”:dunno,我可以想象一个嵌入式环境,其中只有堆栈(以及任何只读内存空间)才可用(实际上,如果您完全知道程序要做什么,那么编写软件就非常容易且高效,而无需使用堆(在嵌入式软件中通常就是这种情况)。因此,对我而言,这不是那种“琐事”。不寻常,也许,但不奇怪。
托马斯

我认为您的答案可能包含对本文的引用(ibm.com/developerworks/aix/library/au-aix-stack-tree-traversal)。它显示了有关您在答案的第二部分中写的内容的实现
2016年

25

如果使用数组支持二叉树,则可以代数确定下一个节点。如果i是节点,则可以在2i + 1(对于左侧节点)和2i + 2(对于右侧节点)找到其子节点。节点的下一个邻居由给出i + 1,除非i是的幂2

这是在数组支持的二进制搜索树上进行广度优先搜索的非常幼稚的实现的伪代码。这假定了一个固定大小的数组,因此也假设了一个固定的深度树。它将查看无父节点,并可能创建难以管理的大堆栈。

bintree-bfs(bintree, elt, i)
    if (i == LENGTH)
        return false

    else if (bintree[i] == elt)
        return true

    else 
        return bintree-bfs(bintree, elt, i+1)        

1
真好 我忽略了我们正在处理二叉树的事实。可以使用DFS分配索引。顺便说一句,您在第一种情况下忘记了返回false。
sisis

我认为我更喜欢排队方法; P。添加了return false。
Patrick McMurchie,2010年

1
聪明。我没有想到将节点存储在数组中并以代数方式引用它们的想法。
Nate

19

我找不到完全递归的方法(没有任何辅助数据结构)。但是,如果队列Q通过引用传递,那么您可以具有以下傻尾递归函数:

BFS(Q)
{
  if (|Q| > 0)
     v <- Dequeue(Q)
     Traverse(v)
     foreach w in children(v)
        Enqueue(Q, w)    

     BFS(Q)
}

6
这是不自然的方法,将递归添加到清理和更正功能。
2013年

完全不同意-我发现它更自然-也更有用;您可以在遍历图层时将此方法扩展为传递工作状态
Tom Golden

15

以下方法使用DFS算法获取特定深度的所有节点-与对该级别进行BFS相同。如果您找出树的深度并对所有级别执行此操作,则结果将与BFS相同。

public void PrintLevelNodes(Tree root, int level) {
    if (root != null) {
        if (level == 0) {
            Console.Write(root.Data);
            return;
        }
        PrintLevelNodes(root.Left, level - 1);
        PrintLevelNodes(root.Right, level - 1);
    }
}

for (int i = 0; i < depth; i++) {
    PrintLevelNodes(root, i);
}

找到一棵树的深度是小菜一碟:

public int MaxDepth(Tree root) {
    if (root == null) {
        return 0;
    } else {
        return Math.Max(MaxDepth(root.Left), MaxDepth(root.Right)) + 1;
    }
}

请多加注意您的代码格式。我做了一些改变。
Micha 2013年

但是,等等...这是DFS而非BFS吗?因为PrintLevelNodes直到level为零才返回。
Herrington Darkholme,2014年

1
@HerringtonDarkholme,正确。它执行DFS搜索,但输出值就像执行某个级别的BFS一样。感谢您指出这一点。
Sanj 2014年

1
@Sanjay,这确实很好地演示了如何在DFS顺序的节点上执行某些操作。不一定要以DFS顺序实际“触摸”节点,而是一定会以DFS顺序递归“操作”节点,在这种情况下将打印它们的值。
bunkerdive

8

Java中的简单BFS和DFS递归:
只需在堆栈/队列中推入/提供树的根节点,然后调用这些函数。

public static void breadthFirstSearch(Queue queue) {

    if (queue.isEmpty())
        return;

    Node node = (Node) queue.poll();

    System.out.println(node + " ");

    if (node.right != null)
        queue.offer(node.right);

    if (node.left != null)
        queue.offer(node.left);

    breadthFirstSearch(queue);
}

public static void depthFirstSearch(Stack stack) {

    if (stack.isEmpty())
        return;

    Node node = (Node) stack.pop();

    System.out.println(node + " ");

    if (node.right != null)
        stack.push(node.right);

    if (node.left != null)
        stack.push(node.left);

    depthFirstSearch(stack);
}

4
将堆栈作为DFS的参数传递有点奇怪,因为那里已经有了隐式堆栈。同样的问题是仅使用调用堆栈作为数据结构。
vladich

4

我发现了一个非常漂亮的递归(甚至是功能性)的广度优先遍历相关算法。不是我的想法,但是我认为应该在本主题中提及它。

Chris Okasaki 仅用3张图片就非常清楚地解释了ICFP 2000的广度优先编号算法,网址为http://okasaki.blogspot.de/2008/07/breadth-first-numbering-algorithm-in.html

我在http://debasishg.blogspot.de/2008/09/breadth-first-numbering-okasakis.html上找到的Debasish Ghosh的Scala实现是:

trait Tree[+T]
case class Node[+T](data: T, left: Tree[T], right: Tree[T]) extends Tree[T]
case object E extends Tree[Nothing]

def bfsNumForest[T](i: Int, trees: Queue[Tree[T]]): Queue[Tree[Int]] = {
  if (trees.isEmpty) Queue.Empty
  else {
    trees.dequeue match {
      case (E, ts) =>
        bfsNumForest(i, ts).enqueue[Tree[Int]](E)
      case (Node(d, l, r), ts) =>
        val q = ts.enqueue(l, r)
        val qq = bfsNumForest(i+1, q)
        val (bb, qqq) = qq.dequeue
        val (aa, tss) = qqq.dequeue
        tss.enqueue[org.dg.collection.BFSNumber.Tree[Int]](Node(i, aa, bb))
    }
  }
}

def bfsNumTree[T](t: Tree[T]): Tree[Int] = {
  val q = Queue.Empty.enqueue[Tree[T]](t)
  val qq = bfsNumForest(1, q)
  qq.dequeue._1
}

+1为漂亮的算法。但是,我发现它仍在使用队列。“规则3”本身的左侧实际上是出队和入队操作。
Luke Lee)

3

愚蠢的方式:

template<typename T>
struct Node { Node* left; Node* right; T value; };

template<typename T, typename P>
bool searchNodeDepth(Node<T>* node, Node<T>** result, int depth, P pred) {
    if (!node) return false;
    if (!depth) {
        if (pred(node->value)) {
            *result = node;
        }
        return true;
    }
    --depth;
    searchNodeDepth(node->left, result, depth, pred);
    if (!*result)
        searchNodeDepth(node->right, result, depth, pred);
    return true;
}

template<typename T, typename P>
Node<T>* searchNode(Node<T>* node, P pred) {
    Node<T>* result = NULL;
    int depth = 0;
    while (searchNodeDepth(node, &result, depth, pred) && !result)
        ++depth;
    return result;
}

int main()
{
    // a c   f
    //  b   e
    //    d
    Node<char*>
        a = { NULL, NULL, "A" },
        c = { NULL, NULL, "C" },
        b = { &a, &c, "B" },
        f = { NULL, NULL, "F" },
        e = { NULL, &f, "E" },
        d = { &b, &e, "D" };

    Node<char*>* found = searchNode(&d, [](char* value) -> bool {
        printf("%s\n", value);
        return !strcmp((char*)value, "F");
    });

    printf("found: %s\n", found->value);

    return 0;
}

3

这是简短的Scala解决方案:

  def bfs(nodes: List[Node]): List[Node] = {
    if (nodes.nonEmpty) {
      nodes ++ bfs(nodes.flatMap(_.children))
    } else {
      List.empty
    }
  }

使用返回值作为累加器的想法非常适合。可以类似的方式用其他语言实现,只需确保您的递归函数处理节点列表即可

测试代码清单(使用@marco测试树):

import org.scalatest.FlatSpec

import scala.collection.mutable

class Node(val value: Int) {

  private val _children: mutable.ArrayBuffer[Node] = mutable.ArrayBuffer.empty

  def add(child: Node): Unit = _children += child

  def children = _children.toList

  override def toString: String = s"$value"
}

class BfsTestScala extends FlatSpec {

  //            1
  //          / | \
  //        2   3   4
  //      / |       | \
  //    5   6       7  8
  //  / |           | \
  // 9  10         11  12
  def tree(): Node = {
    val root = new Node(1)
    root.add(new Node(2))
    root.add(new Node(3))
    root.add(new Node(4))
    root.children(0).add(new Node(5))
    root.children(0).add(new Node(6))
    root.children(2).add(new Node(7))
    root.children(2).add(new Node(8))
    root.children(0).children(0).add(new Node(9))
    root.children(0).children(0).add(new Node(10))
    root.children(2).children(0).add(new Node(11))
    root.children(2).children(0).add(new Node(12))
    root
  }

  def bfs(nodes: List[Node]): List[Node] = {
    if (nodes.nonEmpty) {
      nodes ++ bfs(nodes.flatMap(_.children))
    } else {
      List.empty
    }
  }

  "BFS" should "work" in {
    println(bfs(List(tree())))
  }
}

输出:

List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

2

这是一个python实现:

graph = {'A': ['B', 'C'],
         'B': ['C', 'D'],
         'C': ['D'],
         'D': ['C'],
         'E': ['F'],
         'F': ['C']}

def bfs(paths, goal):
    if not paths:
        raise StopIteration

    new_paths = []
    for path in paths:
        if path[-1] == goal:
            yield path

        last = path[-1]
        for neighbor in graph[last]:
            if neighbor not in path:
                new_paths.append(path + [neighbor])
    yield from bfs(new_paths, goal)


for path in bfs([['A']], 'D'):
    print(path)

2

这是递归BFS的Scala 2.11.4实现。为了简洁起见,我牺牲了尾部调用优化功能,但是TCOd版本非常相似。另请参阅@snv的帖子。

import scala.collection.immutable.Queue

object RecursiveBfs {
  def bfs[A](tree: Tree[A], target: A): Boolean = {
    bfs(Queue(tree), target)
  }

  private def bfs[A](forest: Queue[Tree[A]], target: A): Boolean = {
    forest.dequeueOption exists {
      case (E, tail) => bfs(tail, target)
      case (Node(value, _, _), _) if value == target => true
      case (Node(_, l, r), tail) => bfs(tail.enqueue(List(l, r)), target)
    }
  }

  sealed trait Tree[+A]
  case class Node[+A](data: A, left: Tree[A], right: Tree[A]) extends Tree[A]
  case object E extends Tree[Nothing]
}

2

使用Haskell,以下内容对我来说似乎很自然。在树的各个层次上递归地进行迭代(在这里,我将名称收集到一个大的有序字符串中,以显示通过树的路径):

data Node = Node {name :: String, children :: [Node]}
aTree = Node "r" [Node "c1" [Node "gc1" [Node "ggc1" []], Node "gc2" []] , Node "c2" [Node "gc3" []], Node "c3" [] ]
breadthFirstOrder x = levelRecurser [x]
    where levelRecurser level = if length level == 0
                                then ""
                                else concat [name node ++ " " | node <- level] ++ levelRecurser (concat [children node | node <- level])

2

这是BFS递归遍历Python实现,适用于无循环的图。

def bfs_recursive(level):
    '''
     @params level: List<Node> containing the node for a specific level.
    '''
    next_level = []
    for node in level:
        print(node.value)
        for child_node in node.adjency_list:
            next_level.append(child_node)
    if len(next_level) != 0:
        bfs_recursive(next_level)


class Node:
    def __init__(self, value):
        self.value = value
        self.adjency_list = []

2

我想将美分添加到最上面的答案中,如果该语言支持诸如generator之类的东西,则bfs可以以递归方式完成。

首先,@ Tanzelax的答案是:

广度优先遍历通常使用队列,而不是堆栈。队列和堆栈的性质几乎相反,因此尝试将调用堆栈(即堆栈,因此称为名称)用作辅助存储(队列)注定会失败。

确实,普通函数调用的堆栈不会像普通堆栈那样运行。但是生成器函数将暂停函数的执行,因此它使我们有机会产生下一级节点的子级,而无需深入研究该节点的更深后代。

以下代码是Python中的递归 bfs。

def bfs(root):
  yield root
  for n in bfs(root):
    for c in n.children:
      yield c

直觉是:

  1. bfs first将返回根作为第一个结果
  2. 假设我们已经有了bfs序列,则bfs中的下一级元素是序列中上一个节点的直接子代
  3. 重复以上两个过程

我不了解Python,但我认为您的代码会转换为C#代码。它执行BFS遍历,但由于stackoverflow异常而崩溃。到目前为止,我还没有弄清楚为什么。但是,我修改了算法,使其停止(并且可能会执行得更好)。您可以在这里找到我的工作样本。
亚当·西蒙

1

我必须实现以BFS顺序输出的堆遍历。它实际上不是BFS,但是可以完成相同的任务。

private void getNodeValue(Node node, int index, int[] array) {
    array[index] = node.value;
    index = (index*2)+1;

    Node left = node.leftNode;
    if (left!=null) getNodeValue(left,index,array);
    Node right = node.rightNode;
    if (right!=null) getNodeValue(right,index+1,array);
}

public int[] getHeap() {
    int[] nodes = new int[size];
    getNodeValue(root,0,nodes);
    return nodes;
}

2
对于其他查看者:这是在数组中实现完整树的示例;具体来说,@ Justin正在执行预遍历,在此期间他将节点值(按BFS顺序)保存在数组中的适当BFS索引处。这允许调用函数线性地遍历数组,以BFS顺序打印值。请参阅此一般说明。注意:调用函数必须处理不完整树的情况。
bunkerdive 2014年

1

设v为起始顶点

令G为有问题的图

以下是不使用队列的伪代码

Initially label v as visited as you start from v
BFS(G,v)
    for all adjacent vertices w of v in G:
        if vertex w is not visited:
            label w as visited
    for all adjacent vertices w of v in G:
        recursively call BFS(G,w)

我认为这可能会陷入无限循环-顶点被标记为已访问,但在再次递归之前从未对其进行过访问测试。

这个片段是类似于DFS而非BFS
杰尼

1

二进制(或n进制)树的BFS可以递归地完成而无需排队,如下所示(在Java中):

public class BreathFirst {

    static class Node {
        Node(int value) {
            this(value, 0);
        }
        Node(int value, int nChildren) {
            this.value = value;
            this.children = new Node[nChildren];
        }
        int value;
        Node[] children;
    }

    static void breathFirst(Node root, Consumer<? super Node> printer) {
        boolean keepGoing = true;
        for (int level = 0; keepGoing; level++) {
            keepGoing = breathFirst(root, printer, level);
        }
    }

    static boolean breathFirst(Node node, Consumer<? super Node> printer, int depth) {
        if (depth < 0 || node == null) return false;
        if (depth == 0) {
            printer.accept(node);
            return true;
        }
        boolean any = false;
        for (final Node child : node.children) {
            any |= breathFirst(child, printer, depth - 1);
        }
        return any;
    }
}

遍历打印数字以升序排列的示例1-12:

public static void main(String... args) {
    //            1
    //          / | \
    //        2   3   4
    //      / |       | \
    //    5   6       7  8
    //  / |           | \
    // 9  10         11  12

    Node root = new Node(1, 3);
    root.children[0] = new Node(2, 2);
    root.children[1] = new Node(3);
    root.children[2] = new Node(4, 2);
    root.children[0].children[0] = new Node(5, 2);
    root.children[0].children[1] = new Node(6);
    root.children[2].children[0] = new Node(7, 2);
    root.children[2].children[1] = new Node(8);
    root.children[0].children[0].children[0] = new Node(9);
    root.children[0].children[0].children[1] = new Node(10);
    root.children[2].children[0].children[0] = new Node(11);
    root.children[2].children[0].children[1] = new Node(12);

    breathFirst(root, n -> System.out.println(n.value));
}

0
#include <bits/stdc++.h>
using namespace std;
#define Max 1000

vector <int> adj[Max];
bool visited[Max];

void bfs_recursion_utils(queue<int>& Q) {
    while(!Q.empty()) {
        int u = Q.front();
        visited[u] = true;
        cout << u << endl;
        Q.pop();
        for(int i = 0; i < (int)adj[u].size(); ++i) {
            int v = adj[u][i];
            if(!visited[v])
                Q.push(v), visited[v] = true;
        }
        bfs_recursion_utils(Q);
    }
}

void bfs_recursion(int source, queue <int>& Q) {
    memset(visited, false, sizeof visited);
    Q.push(source);
    bfs_recursion_utils(Q);
}

int main(void) {
    queue <int> Q;
    adj[1].push_back(2);
    adj[1].push_back(3);
    adj[1].push_back(4);

    adj[2].push_back(5);
    adj[2].push_back(6);

    adj[3].push_back(7);

    bfs_recursion(1, Q);
    return 0;
}

0

这是一个使用深度优先递归伪造广度优先遍历的JavaScript实现。我将节点值存储在哈希内部的数组中每个深度处。如果已经存在一个级别(发生冲突),那么我们只需将该级别的数组推入即可。您也可以使用数组而不是JavaScript对象,因为我们的级别是数字的并且可以用作数组索引。您可以返回节点,值,转换为链接列表或任何您想要的东西。为了简单起见,我只是返回值。

BinarySearchTree.prototype.breadthFirstRec = function() {

    var levels = {};

    var traverse = function(current, depth) {
        if (!current) return null;
        if (!levels[depth]) levels[depth] = [current.value];
        else levels[depth].push(current.value);
        traverse(current.left, depth + 1);
        traverse(current.right, depth + 1);
    };

    traverse(this.root, 0);
    return levels;
};


var bst = new BinarySearchTree();
bst.add(20, 22, 8, 4, 12, 10, 14, 24);
console.log('Recursive Breadth First: ', bst.breadthFirstRec());
/*Recursive Breadth First:  
{ '0': [ 20 ],
  '1': [ 8, 22 ],
  '2': [ 4, 12, 24 ],
  '3': [ 10, 14 ] } */

这是使用迭代方法的实际广度优先遍历的示例。

BinarySearchTree.prototype.breadthFirst = function() {

    var result = '',
        queue = [],
        current = this.root;

    if (!current) return null;
    queue.push(current);

    while (current = queue.shift()) {
        result += current.value + ' ';
        current.left && queue.push(current.left);
        current.right && queue.push(current.right);
    }
    return result;
};

console.log('Breadth First: ', bst.breadthFirst());
//Breadth First:  20 8 22 4 12 24 10 14

0

以下是我的代码,用于在不使用循环和队列的情况下完全递归实现双向图的广度优先搜索。

public class Graph { public int V; public LinkedList<Integer> adj[]; Graph(int v) { V = v; adj = new LinkedList[v]; for (int i=0; i<v; ++i) adj[i] = new LinkedList<>(); } void addEdge(int v,int w) { adj[v].add(w); adj[w].add(v); } public LinkedList<Integer> getAdjVerted(int vertex) { return adj[vertex]; } public String toString() { String s = ""; for (int i=0;i<adj.length;i++) { s = s +"\n"+i +"-->"+ adj[i] ; } return s; } } //BFS IMPLEMENTATION public static void recursiveBFS(Graph graph, int vertex,boolean visited[], boolean isAdjPrinted[]) { if (!visited[vertex]) { System.out.print(vertex +" "); visited[vertex] = true; } if(!isAdjPrinted[vertex]) { isAdjPrinted[vertex] = true; List<Integer> adjList = graph.getAdjVerted(vertex); printAdjecent(graph, adjList, visited, 0,isAdjPrinted); } } public static void recursiveBFS(Graph graph, List<Integer> vertexList, boolean visited[], int i, boolean isAdjPrinted[]) { if (i < vertexList.size()) { recursiveBFS(graph, vertexList.get(i), visited, isAdjPrinted); recursiveBFS(graph, vertexList, visited, i+1, isAdjPrinted); } } public static void printAdjecent(Graph graph, List<Integer> list, boolean visited[], int i, boolean isAdjPrinted[]) { if (i < list.size()) { if (!visited[list.get(i)]) { System.out.print(list.get(i)+" "); visited[list.get(i)] = true; } printAdjecent(graph, list, visited, i+1, isAdjPrinted); } else { recursiveBFS(graph, list, visited, 0, isAdjPrinted); } }


0

二进制树的递归广度优先搜索算法的C#实现。

二叉树数据可视化

IDictionary<string, string[]> graph = new Dictionary<string, string[]> {
    {"A", new [] {"B", "C"}},
    {"B", new [] {"D", "E"}},
    {"C", new [] {"F", "G"}},
    {"E", new [] {"H"}}
};

void Main()
{
    var pathFound = BreadthFirstSearch("A", "H", new string[0]);
    Console.WriteLine(pathFound); // [A, B, E, H]

    var pathNotFound = BreadthFirstSearch("A", "Z", new string[0]);
    Console.WriteLine(pathNotFound); // []
}

IEnumerable<string> BreadthFirstSearch(string start, string end, IEnumerable<string> path)
{
    if (start == end)
    {
        return path.Concat(new[] { end });
    }

    if (!graph.ContainsKey(start)) { return new string[0]; }    

    return graph[start].SelectMany(letter => BreadthFirstSearch(letter, end, path.Concat(new[] { start })));
}

如果您希望算法不仅适用于二叉树,而且适用于图,那么可以有两个或更多节点指向相同的另一个节点,则必须通过保存已访问的节点列表来避免自循环。实现可能看起来像这样。

图形数据可视化

IDictionary<string, string[]> graph = new Dictionary<string, string[]> {
    {"A", new [] {"B", "C"}},
    {"B", new [] {"D", "E"}},
    {"C", new [] {"F", "G", "E"}},
    {"E", new [] {"H"}}
};

void Main()
{
    var pathFound = BreadthFirstSearch("A", "H", new string[0], new List<string>());
    Console.WriteLine(pathFound); // [A, B, E, H]

    var pathNotFound = BreadthFirstSearch("A", "Z", new string[0], new List<string>());
    Console.WriteLine(pathNotFound); // []
}

IEnumerable<string> BreadthFirstSearch(string start, string end, IEnumerable<string> path, IList<string> visited)
{
    if (start == end)
    {
        return path.Concat(new[] { end });
    }

    if (!graph.ContainsKey(start)) { return new string[0]; }


    return graph[start].Aggregate(new string[0], (acc, letter) =>
    {
        if (visited.Contains(letter))
        {
            return acc;
        }

        visited.Add(letter);

        var result = BreadthFirstSearch(letter, end, path.Concat(new[] { start }), visited);
        return acc.Concat(result).ToArray();
    });
}

0

我已经使用c ++编写了一个程序,该程序也可以在连接图和不连接图中工作。

    #include <queue>
#include "iostream"
#include "vector"
#include "queue"

using namespace std;

struct Edge {
    int source,destination;
};

class Graph{
    int V;
    vector<vector<int>> adjList;
public:

    Graph(vector<Edge> edges,int V){
        this->V = V;
        adjList.resize(V);
        for(auto i : edges){
            adjList[i.source].push_back(i.destination);
            //     adjList[i.destination].push_back(i.source);
        }
    }
    void BFSRecursivelyJoinandDisjointtGraphUtil(vector<bool> &discovered, queue<int> &q);
    void BFSRecursivelyJointandDisjointGraph(int s);
    void printGraph();


};

void Graph :: printGraph()
{
    for (int i = 0; i < this->adjList.size(); i++)
    {
        cout << i << " -- ";
        for (int v : this->adjList[i])
            cout <<"->"<< v << " ";
        cout << endl;
    }
}


void Graph ::BFSRecursivelyJoinandDisjointtGraphUtil(vector<bool> &discovered, queue<int> &q) {
    if (q.empty())
        return;
    int v = q.front();
    q.pop();
    cout << v <<" ";
    for (int u : this->adjList[v])
    {
        if (!discovered[u])
        {
            discovered[u] = true;
            q.push(u);
        }
    }
    BFSRecursivelyJoinandDisjointtGraphUtil(discovered, q);

}

void Graph ::BFSRecursivelyJointandDisjointGraph(int s) {
    vector<bool> discovered(V, false);
    queue<int> q;

    for (int i = s; i < V; i++) {
        if (discovered[i] == false)
        {
            discovered[i] = true;
            q.push(i);
            BFSRecursivelyJoinandDisjointtGraphUtil(discovered, q);
        }
    }
}

int main()
{

    vector<Edge> edges =
            {
                    {0, 1}, {0, 2}, {1, 2}, {2, 0}, {2,3},{3,3}
            };

    int V = 4;
    Graph graph(edges, V);
 //   graph.printGraph();
    graph.BFSRecursivelyJointandDisjointGraph(2);
    cout << "\n";




    edges = {
            {0,4},{1,2},{1,3},{1,4},{2,3},{3,4}
    };

    Graph graph2(edges,5);

    graph2.BFSRecursivelyJointandDisjointGraph(0);
    return 0;
}
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.