Update algorithm5.rs

Author: hellolutar

exercises/algorithm/algorithm5.rs

@@ -1,87 +1,83 @@
 /*
-	bfs
-	This problem requires you to implement a basic BFS algorithm
+	dfs
+	This problem requires you to implement a basic DFS traversal
 */
 
-//I AM NOT DONE
-use std::collections::VecDeque;
+use std::collections::HashSet;
 
-// Define a graph
 struct Graph {
     adj: Vec<Vec<usize>>, 
 }
 
 impl Graph {
-    // Create a new graph with n vertices
     fn new(n: usize) -> Self {
         Graph {
             adj: vec![vec![]; n],
         }
     }
 
-    // Add an edge to the graph
     fn add_edge(&mut self, src: usize, dest: usize) {
-        self.adj[src].push(dest); 
+        self.adj[src].push(dest);
         self.adj[dest].push(src); 
     }
 
-    // Perform a breadth-first search on the graph, return the order of visited nodes
-    fn bfs_with_return(&self, start: usize) -> Vec<usize> {
-        
-		//TODO
+    fn dfs_util(&self, v: usize, visited: &mut HashSet<usize>, visit_order: &mut Vec<usize>) {
+        visited.insert(v);
+        visit_order.push(v);
+        self.adj[v].iter().for_each(|&next|{
+            if !visited.contains(&next) {
+                self.dfs_util(next, visited, visit_order);
+            }
+        });
+    }
 
-        let mut visit_order = vec![];
+    // Perform a depth-first search on the graph, return the order of visited nodes
+    fn dfs(&self, start: usize) -> Vec<usize> {
+        let mut visited = HashSet::new();
+        let mut visit_order = Vec::new(); 
+        self.dfs_util(start, &mut visited, &mut visit_order);
         visit_order
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
-    fn test_bfs_all_nodes_visited() {
-        let mut graph = Graph::new(5);
-        graph.add_edge(0, 1);
-        graph.add_edge(0, 4);
-        graph.add_edge(1, 2);
-        graph.add_edge(1, 3);
-        graph.add_edge(1, 4);
-        graph.add_edge(2, 3);
-        graph.add_edge(3, 4);
-
-        let visited_order = graph.bfs_with_return(0);
-        assert_eq!(visited_order, vec![0, 1, 4, 2, 3]);
-    }
-
-    #[test]
-    fn test_bfs_different_start() {
+    fn test_dfs_simple() {
         let mut graph = Graph::new(3);
         graph.add_edge(0, 1);
         graph.add_edge(1, 2);
 
-        let visited_order = graph.bfs_with_return(2);
-        assert_eq!(visited_order, vec![2, 1, 0]);
+        let visit_order = graph.dfs(0);
+        assert_eq!(visit_order, vec![0, 1, 2]);
     }
 
     #[test]
-    fn test_bfs_with_cycle() {
-        let mut graph = Graph::new(3);
+    fn test_dfs_with_cycle() {
+        let mut graph = Graph::new(4);
         graph.add_edge(0, 1);
+        graph.add_edge(0, 2);
         graph.add_edge(1, 2);
-        graph.add_edge(2, 0);
+        graph.add_edge(2, 3);
+        graph.add_edge(3, 3); 
 
-        let visited_order = graph.bfs_with_return(0);
-        assert_eq!(visited_order, vec![0, 1, 2]);
+        let visit_order = graph.dfs(0);
+        assert_eq!(visit_order, vec![0, 1, 2, 3]);
     }
 
     #[test]
-    fn test_bfs_single_node() {
-        let mut graph = Graph::new(1);
+    fn test_dfs_disconnected_graph() {
+        let mut graph = Graph::new(5);
+        graph.add_edge(0, 1);
+        graph.add_edge(0, 2);
+        graph.add_edge(3, 4); 
 
-        let visited_order = graph.bfs_with_return(0);
-        assert_eq!(visited_order, vec![0]);
+        let visit_order = graph.dfs(0);
+        assert_eq!(visit_order, vec![0, 1, 2]); 
+        let visit_order_disconnected = graph.dfs(3);
+        assert_eq!(visit_order_disconnected, vec![3, 4]); 
     }
 }