1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

/*
 * Copyright (c) 2017, 2018 Frank Fischer <frank-fischer@shadow-soft.de>
 *
 * This program is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see  <http://www.gnu.org/licenses/>
 */

//! Breath-first-search algorithms.

use graph::{IndexDigraph, IndexGraph, IndexNodeVec};

/// Do a depth-first-search on an undirected graph starting in `u`.
///
/// The function returns the incoming edge of each node.
///
/// # Example
///
/// ```
/// use rs_graph::{LinkedListGraph, Graph, IndexGraph, classes, dfs};
///
/// let g: LinkedListGraph = classes::peterson();
/// let u = g.id2node(0);
/// let tree = dfs::undirected(&g, u);
///
/// let dist = |mut v| {
///     let mut d = 0;
///     while let Some(e) = tree[v] {
///         let (x,y) = g.enodes(e);
///         d += 1;
///         v = if x == v { y } else { x };
///     }
///     d
/// };
/// let dists: Vec<_> = g.nodes().map(|v| dist(v)).collect();
/// assert!(tree[u].is_none());
/// for n in 0..10 {
///     assert_eq!(dists.iter().filter(|&&d| d == n).count(), 1);
/// }
/// ```
pub fn undirected<'g, G>(g: &'g G, u: G::Node) -> IndexNodeVec<'g, G, Option<G::Edge>>
where
    G: IndexGraph<'g>,
{
    let mut preds = idxnodevec![g; None];
    let mut stack = Vec::new();

    stack.push(g.neighs(u));

    while let Some(mut vneighs) = stack.pop() {
        if let Some((e, w)) = vneighs.next() {
            stack.push(vneighs);
            if w != u && preds[w].is_none() {
                preds[w] = Some(e);
                stack.push(g.neighs(w));
            }
        }
    }

    preds
}

/// Do a depth-first-search on an directed graph starting in `u`.
///
/// The search traverses edges only in forward direction.
///
/// The function returns the incoming edge of each node.
pub fn directed<'g, G>(g: &'g G, u: G::Node) -> IndexNodeVec<'g, G, Option<G::Edge>>
where
    G: IndexDigraph<'g>,
{
    let mut preds = idxnodevec![g; None];
    let mut stack = Vec::new();

    stack.push(g.outedges(u));

    while let Some(mut voutedges) = stack.pop() {
        if let Some((e, w)) = voutedges.next() {
            stack.push(voutedges);
            if w != u && preds[w].is_none() {
                preds[w] = Some(e);
                stack.push(g.outedges(w));
            }
        }
    }

    preds
}