Merge branch 'main' into ruff-format

Author: IvanIsCoding

rustworkx-core/src/traversal/dfs_edges.rs

@@ -12,7 +12,7 @@
 
 use std::hash::Hash;
 
-use hashbrown::{HashMap, HashSet};
+use hashbrown::HashSet;
 
 use petgraph::visit::{
     EdgeCount, IntoNeighbors, IntoNodeIdentifiers, NodeCount, NodeIndexable, Visitable,
@@ -75,7 +75,10 @@ where
     let mut out_vec: Vec<(usize, usize)> = if source.is_some() {
         Vec::new()
     } else {
-        Vec::with_capacity(core::cmp::min(graph.node_count() - 1, graph.edge_count()))
+        Vec::with_capacity(core::cmp::min(
+            graph.node_count().saturating_sub(1),
+            graph.edge_count(),
+        ))
     };
     for start in nodes {
         if visited.contains(&start) {
@@ -84,32 +87,25 @@ where
         visited.insert(start);
         let mut children: Vec<G::NodeId> = graph.neighbors(start).collect();
         children.reverse();
-        let mut stack: Vec<(G::NodeId, Vec<G::NodeId>)> = vec![(start, children)];
-        // Used to track the last position in children vec across iterations
-        let mut index_map: HashMap<G::NodeId, usize> = HashMap::with_capacity(node_count);
-        index_map.insert(start, 0);
-        while !stack.is_empty() {
-            let temp_parent = stack.last().unwrap();
-            let parent = temp_parent.0;
-            let children = temp_parent.1.clone();
-            let count = *index_map.get(&parent).unwrap();
+        // Stack stores (node, children, next_child_index)
+        let mut stack: Vec<(G::NodeId, Vec<G::NodeId>, usize)> = vec![(start, children, 0)];
+        while let Some((parent, children, idx)) = stack.last_mut() {
             let mut found = false;
-            let mut index = count;
-            for child in &children[index..] {
-                index += 1;
-                if !visited.contains(child) {
-                    out_vec.push((graph.to_index(parent), graph.to_index(*child)));
-                    visited.insert(*child);
-                    let mut grandchildren: Vec<G::NodeId> = graph.neighbors(*child).collect();
+            while *idx < children.len() {
+                let child = children[*idx];
+                *idx += 1;
+                if !visited.contains(&child) {
+                    let parent_id = *parent;
+                    out_vec.push((graph.to_index(parent_id), graph.to_index(child)));
+                    visited.insert(child);
+                    let mut grandchildren: Vec<G::NodeId> = graph.neighbors(child).collect();
                     grandchildren.reverse();
-                    stack.push((*child, grandchildren));
-                    index_map.insert(*child, 0);
-                    *index_map.get_mut(&parent).unwrap() = index;
+                    stack.push((child, grandchildren, 0));
                     found = true;
                     break;
                 }
             }
-            if !found || children.is_empty() {
+            if !found {
                 stack.pop();
             }
         }

src/connectivity/mod.rs

@@ -618,10 +618,10 @@ pub fn is_semi_connected(graph: &digraph::PyDiGraph) -> PyResult<bool> {
     }
 
     let mut temp_graph = DiGraph::new();
-    let mut node_map = Vec::new();
+    let mut node_map = vec![NodeIndex::end(); graph.graph.node_bound()];
 
-    for _node in graph.graph.node_indices() {
-        node_map.push(temp_graph.add_node(()));
+    for node in graph.graph.node_indices() {
+        node_map[node.index()] = temp_graph.add_node(());
     }
 
     for edge in graph.graph.edge_indices() {

tests/digraph/test_dfs_edges.py

@@ -29,3 +29,37 @@ def test_digraph_dfs_edges(self):
         edges = rustworkx.digraph_dfs_edges(graph, 0)
         expected = [(0, 1), (1, 2), (2, 4), (1, 3)]
         self.assertEqual(expected, edges)
+
+    def test_digraph_dfs_edges_empty(self):
+        graph = rustworkx.PyDiGraph()
+        edges = rustworkx.digraph_dfs_edges(graph)
+        self.assertEqual([], edges)
+
+    def test_digraph_dfs_edges_single_node(self):
+        graph = rustworkx.generators.directed_empty_graph(1)
+        edges = rustworkx.digraph_dfs_edges(graph, 0)
+        self.assertEqual([], edges)
+
+    def test_digraph_dfs_edges_node_gaps(self):
+        graph = rustworkx.PyDiGraph()
+        graph.add_nodes_from(range(5))
+        graph.add_edge(0, 2, None)
+        graph.add_edge(2, 4, None)
+        graph.remove_node(1)
+        graph.remove_node(3)
+        edges = rustworkx.digraph_dfs_edges(graph, 0)
+        self.assertEqual([(0, 2), (2, 4)], edges)
+
+    def test_digraph_dfs_edges_star(self):
+        graph = rustworkx.generators.directed_star_graph(101)
+        hub = 0
+        spokes = list(range(1, 101))
+        edges = rustworkx.digraph_dfs_edges(graph, hub)
+        # Should visit all spokes exactly once
+        self.assertEqual(len(edges), 100)
+        # All edges should originate from hub
+        for src, _ in edges:
+            self.assertEqual(src, hub)
+        # All spokes should be visited
+        visited = {tgt for _, tgt in edges}
+        self.assertEqual(visited, set(spokes))

tests/digraph/test_is_semi_connected.py

@@ -74,3 +74,14 @@ def test_is_semi_connected_directed_star_graph(self):
     def test_is_semi_connected_directed_grid_graph(self):
         graph = rustworkx.generators.directed_grid_graph(10, 10)
         self.assertEqual(rustworkx.is_semi_connected(graph), naive_semi_connected(graph))
+
+    def test_is_semi_connected_with_node_gaps(self):
+        graph = rustworkx.PyDiGraph()
+        graph.add_nodes_from(list(range(5)))
+        graph.remove_node(1)
+        # Remaining nodes 0, 2, 3, 4 form a path
+        graph.add_edge(0, 2, None)
+        graph.add_edge(2, 3, None)
+        graph.add_edge(3, 4, None)
+
+        self.assertEqual(rustworkx.is_semi_connected(graph), naive_semi_connected(graph))

tests/graph/test_dfs_edges.py

@@ -29,3 +29,37 @@ def test_graph_disconnected_dfs_edges(self):
         edges = rustworkx.graph_dfs_edges(graph)
         expected = [(0, 1), (2, 3)]
         self.assertEqual(expected, edges)
+
+    def test_graph_dfs_edges_empty(self):
+        graph = rustworkx.PyGraph()
+        edges = rustworkx.graph_dfs_edges(graph)
+        self.assertEqual([], edges)
+
+    def test_graph_dfs_edges_single_node(self):
+        graph = rustworkx.generators.empty_graph(1)
+        edges = rustworkx.graph_dfs_edges(graph, 0)
+        self.assertEqual([], edges)
+
+    def test_graph_dfs_edges_node_gaps(self):
+        graph = rustworkx.PyGraph()
+        graph.add_nodes_from(range(5))
+        graph.add_edge(0, 2, None)
+        graph.add_edge(2, 4, None)
+        graph.remove_node(1)
+        graph.remove_node(3)
+        edges = rustworkx.graph_dfs_edges(graph, 0)
+        self.assertEqual([(0, 2), (2, 4)], edges)
+
+    def test_graph_dfs_edges_star(self):
+        graph = rustworkx.generators.star_graph(101)
+        hub = 0
+        spokes = list(range(1, 101))
+        edges = rustworkx.graph_dfs_edges(graph, hub)
+        # Should visit all spokes exactly once
+        self.assertEqual(len(edges), 100)
+        # All edges should originate from hub
+        for src, tgt in edges:
+            self.assertEqual(src, hub)
+        # All spokes should be visited
+        visited = {tgt for _, tgt in edges}
+        self.assertEqual(visited, set(spokes))