Binary search tree lesson

Author: linkel

5-trees/BST-mine.py

@@ -0,0 +1,58 @@
+class Node(object):
+    def __init__(self, value):
+        self.value = value
+        self.left = None
+        self.right = None
+
+class BST(object):
+    def __init__(self, root):
+        self.root = Node(root)
+
+    def insert(self, new_val):
+        def insertNode(node, new_value):
+            if new_value < node.value and node.left == None:
+                node.left = Node(new_val)
+            elif new_value > node.value and node.right == None:
+                node.right = Node(new_val)
+            elif node.value > new_val and node.left:
+                insertNode(node.left, new_value)
+            elif node.value < new_val and node.right:
+                insertNode(node.right, new_value)
+        insertNode(self.root, new_val)
+
+    def printSelf(self):
+        def printNode(node):
+            if node:
+                print(node.value)
+                printNode(node.left)
+                printNode(node.right)
+        printNode(self.root)
+        
+    def search(self, find_val):
+        def preorder(node, find_value):
+            if node:
+                if node.value == find_value:
+                    return True
+                return preorder(node.left, find_value) or preorder(node.right, find_value)
+            return False
+        return preorder(self.root, find_val)
+
+# Kind of wondering how insertion works if you have to rearrange order in the tree.
+# This problem didn't check for any of that.
+
+# Set up tree
+tree = BST(4)
+
+# Insert elements
+tree.insert(2)
+tree.insert(1)
+tree.insert(3)
+tree.insert(5)
+
+#tree.printSelf()
+
+# Check search
+# Should be True
+print tree.search(4)
+# Should be False
+print tree.search(6)

5-trees/BST.py

@@ -0,0 +1,31 @@
+class BST(object):
+    def __init__(self, root):
+        self.root = Node(root)
+
+    def insert(self, new_val):
+        self.insert_helper(self.root, new_val)
+
+    def insert_helper(self, current, new_val):
+        if current.value < new_val:
+            if current.right:
+                self.insert_helper(current.right, new_val)
+            else:
+                current.right = Node(new_val)
+        else:
+            if current.left:
+                self.insert_helper(current.left, new_val)
+            else:
+                current.left = Node(new_val)
+
+    def search(self, find_val):
+        return self.search_helper(self.root, find_val)
+
+    def search_helper(self, current, find_val):
+        if current:
+            if current.value == find_val:
+                return True
+            elif current.value < find_val:
+                return self.search_helper(current.right, find_val)
+            else:
+                return self.search_helper(current.left, find_val)
+        return False

5-trees/BSTNotes.md

@@ -0,0 +1,11 @@
+### Binary Search Trees
+
+The difference is that everything to the left of the root node is smaller than it and everything to its right is bigger.
+
+Searching this tree if it is pretty balanced then is O(log(n)), because it depends on the height of the tree (which in a previous calculation was shown to be log(n)). 
+
+In the worst case, where it is completely unbalanced, it is basically like a line and it would be linear O(n) time. 
+
+
+
+I'm kind of curious on how shuffling the tree around works if I make inserts that require that reshuffling. The quiz where the implementation was done did not address this.