Began Lesson 5: Trees

Author: linkel

5-trees/BinaryTree-mine.py

@@ -0,0 +1,62 @@
+class Node(object):
+    def __init__(self, value):
+        self.value = value
+        self.left = None
+        self.right = None
+
+class BinaryTree(object):
+    def __init__(self, root):
+        self.root = Node(root)
+
+    def search(self, find_val):
+        """Return True if the value
+        is in the tree, return
+        False otherwise."""
+        if self.preorder_search(self.root, find_val):
+            return True
+        return False
+
+    def print_tree(self):
+        """Print out all tree nodes
+        as they are visited in
+        a pre-order traversal."""
+        myList = []
+        self.preorder_print(self.root, myList)
+        print('-'.join(myList))
+        return ""
+
+    def preorder_search(self, start, find_val):
+        """Helper method - use this to create a 
+        recursive search solution."""
+        if start:
+            if start.value == find_val:
+                return True
+            return self.preorder_search(start.left, find_val) or self.preorder_search(start.right, find_val)
+        return False
+
+    def preorder_print(self, start, traversal):
+        """Helper method - use this to create a 
+        recursive print solution."""
+        if start:
+            traversal.append(str(start.value))
+            self.preorder_print(start.left, traversal)
+            self.preorder_print(start.right, traversal)
+        return traversal
+
+
+# Set up tree
+tree = BinaryTree(1)
+tree.root.left = Node(2)
+tree.root.right = Node(3)
+tree.root.left.left = Node(4)
+tree.root.left.right = Node(5)
+
+# Test search
+# Should be True
+print tree.search(4)
+# Should be False
+print tree.search(6)
+
+# Test print_tree
+# Should be 1-2-4-5-3
+print tree.print_tree()

5-trees/BinaryTree.py

@@ -0,0 +1,24 @@
+class BinaryTree(object):
+    def __init__(self, root):
+        self.root = Node(root)
+
+    def search(self, find_val):
+        return self.preorder_search(tree.root, find_val)
+
+    def print_tree(self):
+        return self.preorder_print(tree.root, "")[:-1]
+
+    def preorder_search(self, start, find_val):
+        if start:
+            if start.value == find_val:
+                return True
+            else:
+                return self.preorder_search(start.left, find_val) or self.preorder_search(start.right, find_val)
+        return False
+
+    def preorder_print(self, start, traversal):
+        if start:
+            traversal += (str(start.value) + "-")
+            traversal = self.preorder_print(start.left, traversal)
+            traversal = self.preorder_print(start.right, traversal)
+        return traversal

5-trees/TreeNotes.md

@@ -0,0 +1,74 @@
+### Trees
+
+Trees are like linked lists except they can have more than one next. 
+
+- Trees must be completely connected
+- Trees must not have cycles
+
+The level of a tree starts counting at 1 from the root node.
+The height of a tree starts counting from the leaf nodes as 0, upwards.
+The depth of a tree is the number of edges (connections), which starts at 0 from the root node.
+
+Identical terms:
+- Parent/Child
+- Ancestor/Descendent
+- Internal/Leaf
+
+### Quiz
+
+        a
+      /   \
+     b     c
+    /    / 
+   d   e   
+         \ 
+           f
+
+Level of D?  3
+Parent of C? A
+Height of B? 2
+Depth of F?  3
+
+### Tree Traversal
+
+DFS - depth first search, can be
+- preorder: root, L, R
+- inorder: L, root, R
+- postorder: L, R, root (commonly used for deleting)
+
+BFS - breadth first search, popularly
+- search by level, left to right each level
+
+### Quiz
+
+        a
+      /   \
+     b     c
+    / \   
+   d   e   
+         \ 
+           f
+
+Write out the post order traversal.
+D, F, E, B, C, A
+
+### Binary Trees
+
+Each node can have at most 2 children. 
+
+**Searching:**
+Any of the DFS or BFS traversals work here. O(n), having to look through til found.
+
+**Deleting:**
+Often starts off with a search to find the thing to delete.
+When deleting, have to consider the children if you delete an internal node (parent).
+If it's got one kid, you can just promote the kid up. 
+If it's got two, you will have to decide how to shift around the elements. You can search til you hit a leaf and promote the leaf up if you don't care about order. 
+
+**Inserting:**
+If there's no order, just stick it in as a child somewhere. Move down tree from root looking for an open spot.
+Worse case is O(height). What's the height of the binary tree?
+
+A perfect tree has all children for every parent til the even leaf nodes at the end. Perfect trees have nodes equal to 2^(level-1). 
+
+Powers of 2 remind us of log(n).