feat:exercises

Author: build

exercises/algorithm/algorithm4.rs

@@ -1,13 +1,6 @@
-/*
-	binary_search tree
-	This problem requires you to implement a basic interface for a binary tree
-*/
-
-//I AM NOT DONE
 use std::cmp::Ordering;
 use std::fmt::Debug;
 
-
 #[derive(Debug)]
 struct TreeNode<T>
 where
@@ -43,20 +36,28 @@ impl<T> BinarySearchTree<T>
 where
     T: Ord,
 {
-
     fn new() -> Self {
         BinarySearchTree { root: None }
     }
 
     // Insert a value into the BST
     fn insert(&mut self, value: T) {
-        //TODO
+        match &mut self.root {
+            Some(node) => {
+                node.insert(value);
+            }
+            None => {
+                self.root = Some(Box::new(TreeNode::new(value)));
+            }
+        }
     }
 
     // Search for a value in the BST
     fn search(&self, value: T) -> bool {
-        //TODO
-        true
+        match &self.root {
+            Some(node) => node.search(value),
+            None => false,
+        }
     }
 }
 
@@ -66,10 +67,47 @@ where
 {
     // Insert a node into the tree
     fn insert(&mut self, value: T) {
-        //TODO
+        match value.cmp(&self.value) {
+            Ordering::Less => {
+                match &mut self.left {
+                    Some(left_node) => {
+                        left_node.insert(value);
+                    }
+                    None => {
+                        self.left = Some(Box::new(TreeNode::new(value)));
+                    }
+                }
+            }
+            Ordering::Greater => {
+                match &mut self.right {
+                    Some(right_node) => {
+                        right_node.insert(value);
+                    }
+                    None => {
+                        self.right = Some(Box::new(TreeNode::new(value)));
+                    }
+                }
+            }
+            Ordering::Equal => {
+            }
+        }
     }
-}
 
+    // Search for a value in the tree
+    fn search(&self, value: T) -> bool {
+        match value.cmp(&self.value) {
+            Ordering::Less => match &self.left {
+                Some(left_node) => left_node.search(value),
+                None => false,
+            },
+            Ordering::Greater => match &self.right {
+                Some(right_node) => right_node.search(value),
+                None => false,
+            },
+            Ordering::Equal => true,
+        }
+    }
+}
 
 #[cfg(test)]
 mod tests {
@@ -79,24 +117,20 @@ mod tests {
     fn test_insert_and_search() {
         let mut bst = BinarySearchTree::new();
 
-        
         assert_eq!(bst.search(1), false);
 
-        
         bst.insert(5);
         bst.insert(3);
         bst.insert(7);
         bst.insert(2);
         bst.insert(4);
 
-        
         assert_eq!(bst.search(5), true);
         assert_eq!(bst.search(3), true);
         assert_eq!(bst.search(7), true);
         assert_eq!(bst.search(2), true);
         assert_eq!(bst.search(4), true);
 
-        
         assert_eq!(bst.search(1), false);
         assert_eq!(bst.search(6), false);
     }
@@ -105,22 +139,17 @@ mod tests {
     fn test_insert_duplicate() {
         let mut bst = BinarySearchTree::new();
 
-        
         bst.insert(1);
         bst.insert(1);
 
-        
         assert_eq!(bst.search(1), true);
 
-        
         match bst.root {
             Some(ref node) => {
                 assert!(node.left.is_none());
                 assert!(node.right.is_none());
-            },
+            }
             None => panic!("Root should not be None after insertion"),
         }
     }
-}    
-
-
+}