Struct petgraph::visit::Bfs

pub struct Bfs<N, VM> {
    pub stack: VecDeque<N>,
    pub discovered: VM,
}

A breadth first search (BFS) of a graph.

Using a Bfs you can run a traversal over a graph while still retaining mutable access to it, if you use it like the following example:

use petgraph::{Graph, Bfs};

let mut graph = Graph::<_,()>::new();
let a = graph.add_node(0);

let mut bfs = Bfs::new(&graph, a);
while let Some(nx) = bfs.next(&graph) {
    // we can access `graph` mutably here still
    graph[nx] += 1;
}

assert_eq!(graph[a], 1);

Note: The algorithm may not behave correctly if nodes are removed during iteration. It may not necessarily visit added nodes or edges.

Fields

stack
discovered

Methods

impl<G: Visitable> Bfs<G, G> where G: Clone

fn new(graph: &G, start: G) -> Self

Create a new Bfs, using the graph's visitor map, and put start in the stack of nodes to visit.

impl<N, VM> Bfs<N, VM> where N: Clone, VM: VisitMap<N>

fn next<'a, G>(&mut self, graph: &'a G) -> Option<N> where G: Graphlike<NodeId=N>, G: for<'b> NeighborIter<'b>

Return the next node in the dfs, or None if the traversal is done.

Trait Implementations

Derived Implementations

impl<N: Clone, VM: Clone> Clone for Bfs<N, VM> where N: Clone, VM: Clone

fn clone(&self) -> Bfs<N, VM>

fn clone_from(&mut self, source: &Self)