add algorithms

Author: rumycoding

exercises/algorithm/algorithm4.rs

@@ -1,13 +1,12 @@
 /*
-	binary_search tree
-	This problem requires you to implement a basic interface for a binary tree
+    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,34 +42,80 @@ 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
+        let current = &self.root;
+
+        if current.is_none() {
+            self.root = Some(Box::new(TreeNode::new(value)));
+            return;
+        }
+
+        self.root.as_mut().unwrap().insert(value);
     }
 
     // Search for a value in the BST
     fn search(&self, value: T) -> bool {
-        //TODO
-        true
+        if self.root.is_none() {
+            return false;
+        }
+
+        return self.root.as_ref().unwrap().search(value);
     }
 }
 
 impl<T> TreeNode<T>
 where
     T: Ord,
 {
+    fn search(&self, value: T) -> bool {
+        if self.value == value {
+            return true;
+        }
+
+        if self.value > value {
+            if self.right.is_none() {
+                return false;
+            }
+
+            return self.right.as_ref().unwrap().search(value);
+        }
+
+        if self.left.is_none() {
+            return false;
+        }
+
+        return self.left.as_ref().unwrap().search(value);
+    }
+
     // Insert a node into the tree
     fn insert(&mut self, value: T) {
-        //TODO
+        let current_val = &(self.value);
+
+        if value <= *current_val {
+            if self.left.is_none() {
+                self.left = Some(Box::new(TreeNode::new(value)));
+                return;
+            }
+
+            self.left.as_mut().unwrap().insert(value);
+        } else {
+            if self.right.is_none() {
+                self.right = Some(Box::new(TreeNode::new(value)));
+                return;
+            }
+
+            self.right.as_mut().unwrap().insert(value);
+        }
+
+        return;
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -79,24 +124,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 +146,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"),
         }
     }
-}    
-
-
+}