fix few details, transversals

src/trees/binary_tree.py

@@ -115,7 +115,7 @@ class NodeBT(object):
                 else:
                     return False
         else:
-            raise Exception('Tree is empty')
+            print('Tree is empty')
 
 
 
@@ -136,14 +136,17 @@ class BinaryTree(object):
 
     def isLeaf(self, value):
         node = self.root._searchForNode(value)
-        return node._isLeaf()
+        if node:
+            return node._isLeaf()
+        else:
+            print "Node not found."
 
     def getNodeLevel(self, item):
         node = self.root._searchForNode(item)
         if node:
             return node.level
         else:
-            raise Exception('Node not found')
+            print('Node not found')
 
     def isRoot(self, value):
         return self.root.item == value

src/trees/transversal_BST_ancestor.py

@@ -0,0 +1,42 @@
+#!/usr/bin/python
+
+__author__ = "Mari Wahl"
+__email__ = "marina.w4hl@gmail.com"
+
+''' find the lowest ancestor in a BST '''
+
+from transversal_BST_recursively import BSTwithTransversalRecursively
+
+
+
+def find_ancestor(path, low_value, high_value):
+    while path:
+        current_value = path[0]
+        if current_value < low_value:
+            try:
+                path = path[2:]
+            except:
+                return current_value
+        elif current_value > high_value:
+            try:
+                path = path[1:]
+            except:
+                return current_value
+        elif low_value <= current_value <= high_value:
+            return current_value
+
+
+
+
+if __name__ == '__main__':
+    bst = BSTwithTransversalRecursively()
+    l = [10, 5, 15, 1, 6, 11, 50]
+    for i in l:
+        bst.addNode(i)
+    path = bst.preorder()
+    print("The path inorder: ", path)
+
+    print("The path between 1 and 6 is :", find_ancestor(path, 1, 6))
+    print("The path between 1 and 11 is: ", find_ancestor(path, 1, 11))
+    print("The path between 11 and 50 is: ", find_ancestor(path, 11, 50))
+    print("The path between 5 and 15 is: ", find_ancestor(path, 5, 15))

src/trees/transversal_BST_iteratively.py

@@ -0,0 +1,91 @@
+#!/usr/bin/python
+
+__author__ = "Mari Wahl"
+__email__ = "marina.w4hl@gmail.com"
+
+
+from collections import deque
+from binary_search_tree import BinarySearchTree, NodeBST
+
+
+
+class BSTwithTransversalIterative(BinarySearchTree):
+
+    def inorder(self):
+        current = self.root
+        nodes, stack = [], []
+        while stack or current:
+            if current:
+                stack.append(current)
+                current = current.left
+            else:
+                current = stack.pop()
+                nodes.append(current.item) # thats what change
+                current = current.right
+        return nodes
+
+
+    def preorder(self):
+        current = self.root
+        nodes, stack = [], []
+        while stack or current:
+            if current:
+                nodes.append(current.item) # thats what change
+                stack.append(current)
+                current = current.left
+            else:
+                current = stack.pop()
+                current = current.right
+        return nodes
+
+
+    def preorder2(self):
+        nodes = []
+        stack = [self.root]
+        while stack:
+            current = stack.pop()
+            if current:
+                nodes.append(current.item)
+                stack.append(current.right)
+                stack.append(current.left)
+        return nodes
+
+
+    def BFT(self):
+        current = self.root
+        nodes = []
+        queue = deque()
+        queue.append(current)
+        while queue:
+            current = queue.popleft()
+            nodes.append(current.item)
+            if current.left:
+                queue.append(current.left) # LEFT FIRST!
+            if current.right:
+                queue.append(current.right)
+        return nodes
+
+
+
+
+
+
+if __name__ == '__main__':
+
+    bst = BSTwithTransversalIterative()
+    l = [10, 5, 6, 3, 8, 2, 1, 11, 9, 4]
+    for i in l:
+        bst.addNode(i)
+
+    print "Is 8 a leaf? ", bst.isLeaf(8)
+    print "Whats the level of node 8? ", bst.getNodeLevel(8)
+    print "Is node 10 a root? ", bst.isRoot(10)
+    print "Is node 1 a root? ", bst.isRoot(1)
+    print "Whats the tree height? ", bst.getHeight()
+    print "Is this tree BST? ", bst.isBST()
+    print "Is this tree balanced? ", bst.isBalanced()
+
+    print("Pre-order I: ", bst.preorder())
+    print("Pre-order II: ", bst.preorder2())
+    print("In-order: ", bst.inorder())
+    print("BFT: ", bst.BFT())

src/trees/transversal_BST_recursively.py

@@ -0,0 +1,88 @@
+#!/usr/bin/python
+
+__author__ = "Mari Wahl"
+__email__ = "marina.w4hl@gmail.com"
+
+
+from binary_search_tree import BinarySearchTree, NodeBST
+
+
+
+class BSTwithTransversalRecursively(BinarySearchTree):
+
+    def __init__(self):
+        self.root = None
+        self.nodes_BFS = []
+        self.nodes_pre = []
+        self.nodes_post = []
+        self.nodes_in = []
+
+    def BFT(self):
+        self.root.level = 0
+        queue = [self.root]
+        current_level = self.root.level
+
+        while len(queue) > 0:
+            current_node = queue.pop(0)
+            if current_node.level > current_level:
+                current_level += 1
+            self.nodes_BFS.append(current_node.item)
+
+            if current_node.left:
+                current_node.left.level = current_level + 1
+                queue.append(current_node.left)
+
+            if current_node.right:
+                current_node.right.level = current_level + 1
+                queue.append(current_node.right)
+
+        return self.nodes_BFS
+
+    def inorder(self, node=None, level=0):
+        if not node and level == 0:
+            node = self.root
+        if node:
+            self.inorder(node.left,  level+1)
+            self.nodes_in.append(node.item)
+            self.inorder(node.right, level+1)
+        return self.nodes_in
+
+    def preorder(self, node=None, level=0):
+        if not node and level == 0:
+            node = self.root
+        if node:
+            self.nodes_pre.append(node.item)
+            self.preorder(node.left, level+1)
+            self.preorder(node.right, level+1)
+        return self.nodes_pre
+
+    def postorder(self, node=None, level=0):
+        if not node and level == 0:
+            node = self.root
+        if node:
+            self.postorder(node.left,  level+1)
+            self.postorder(node.right,  level+1)
+            self.nodes_post.append(node.item)
+        return self.nodes_post
+
+
+
+if __name__ == '__main__':
+
+    bst = BSTwithTransversalRecursively()
+    l = [10, 5, 6, 3, 8, 2, 1, 11, 9, 4]
+    for i in l:
+        bst.addNode(i)
+
+    print "Is 8 a leaf? ", bst.isLeaf(8)
+    print "Whats the level of node 8? ", bst.getNodeLevel(8)
+    print "Is node 10 a root? ", bst.isRoot(10)
+    print "Is node 1 a root? ", bst.isRoot(1)
+    print "Whats the tree height? ", bst.getHeight()
+    print "Is this tree BST? ", bst.isBST()
+    print "Is this tree balanced? ", bst.isBalanced()
+
+    print("Pre-order: ", bst.preorder())
+    print("Post-order: ", bst.postorder())
+    print("In-order: ", bst.inorder())
+    print("BFT: ", bst.BFT())

src/trees/traversals/BST.py

@@ -1,68 +0,0 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
-
-from BT import BT
-
-class BST(BT):
-    def __init__(self, value=None):
-        self.value = value
-        self.left = None
-        self.right = None
-
-    def insert_left(self, new_node):
-        self.insert(value)
-        
-    def insert_right(self, new_node):
-        self.insert(value)
-
-
-    def insert(self, value):
-        if  self.value == None:
-            self.value = value
-        else:
-            if value > self.value:
-                self.right = self.right and self.right.insert(value) or BST(value)
-            else:
-                self.left = self.left and self.left.insert(value) or BST(value)
-        return self
-
-    def find(self, value):
-        if value == self.value:
-            return self
-        elif value > self.value and self.right:
-            return self.right.find(value)
-        elif self.left:
-            return self.left.find(value)
-        return None
-
-
-
-
-def main():
-    """
-    BST
-          4
-       2     6
-     1   3 5   7
-    """
-    tree = BST()
-    tree.insert(4)
-    tree.insert(2)
-    tree.insert(6)
-    tree.insert(1)
-    tree.insert(3)
-    tree.insert(7)
-    tree.insert(5)
-    print(tree.get_right())
-    print(tree.get_right().get_left())
-    print(tree.get_right().get_right())
-    print(tree.get_left())
-    print(tree.get_left().get_left())
-    print(tree.get_left().get_right() == 1)
-    assert(tree.find(30) == None)
-
-
-if __name__ == '__main__':
-    main()
-

src/trees/traversals/BST_ancestor.py

@@ -1,46 +0,0 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
-
-from BST_traversal import TranversalBST
-
-def find_ancestor(path, low_value, high_value):
-    ''' find the lowest ancestor in a BST '''       
-    while path:
-        current_value = path[0]
-        if current_value < low_value:
-            try:
-                path = path[2:]
-            except:
-                return current_value
-        elif current_value > high_value:
-            try:
-                path = path[1:]
-            except:
-                return current_value
-        elif low_value <= current_value <= high_value:
-            return current_value
-    return None
-
-
-def test_find_ancestor():
-    """
-            10 
-       5       15
-    1   6     11    50
-    """     
-    t = TranversalBST()
-    l1 = [10, 5, 15, 1, 6, 11, 50]
-    for i in l1: t.insert(i)
-    path = t.preorder()
-    assert(find_ancestor(path, 1, 6) == 5)
-    assert(find_ancestor(path, 1, 11) == 10) 
-    assert(find_ancestor(path, 11, 50) == 15)   
-    assert(find_ancestor(path, 5, 15) == 10)  
-    
-    
-    print("Tests passsed!")
-    
-if __name__ == '__main__':
-    test_find_ancestor()
-

src/trees/traversals/BST_traversal.py

@@ -1,88 +0,0 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
-
-from BST import BST
-
-class TranversalBST(object):
-    def __init__(self):
-        self.bst = BST(None)
-        self.nodes = []
-        
-    def insert(self, value):
-        if not self.bst.value:
-            self.bst.value = value
-        else:
-            self.bst.insert(value)
-
-    def contains(self, value):
-        return bool(self.bst.find(value))
-
-    def get(self, index):
-        for i, value in enumerate(self.inorder()):
-            if i == index:
-                return value
-
-    def inorder(self):
-        current = self.bst  
-        self.nodes = []
-        stack = []
-        while len(stack) > 0 or current is not None:
-            if current is not None:
-                stack.append(current)   
-                current = current.left
-            else:
-                current = stack.pop()
-                self.nodes.append(current.value)
-                current = current.right
-        return self.nodes
-
-
-    def preorder(self):
-        self.nodes = []
-        stack = [self.bst]  
-        while len(stack) > 0:
-            curr = stack.pop()
-            if curr is not None:
-                self.nodes.append(curr.value)
-                stack.append(curr.right)
-                stack.append(curr.left)
-        return self.nodes
-
-
-    def preorder2(self):
-        self.nodes = []
-        current = self.bst  
-        stack = []
-        while len(stack) > 0 or current is not None:
-            if current is not None:
-                self.nodes.append(current.value)
-                stack.append(current)   
-                current = current.left
-            else:
-                current = stack.pop()               
-                current = current.right            
-        return self.nodes
-
-
-
-def main():
-    """
-            10 
-       5       15
-    1   6     11    50
-    """     
-    t = TranversalBST()
-    t.insert(10)
-    t.insert(5)
-    t.insert(15)
-    t.insert(1)
-    t.insert(6)
-    t.insert(11)
-    t.insert(50)
-    print(t.preorder())
-    print(t.preorder2())
-    print(t.inorder())
-
-if __name__ == '__main__':
-    main()    

src/trees/traversals/BST_with_Nodes_traversal.py

@@ -1,68 +0,0 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
-
-from BST_with_Nodes import BSTwithNodes, Node
-
-class BSTTraversal(BSTwithNodes):
-    def __init__(self): 
-        self.root = None
-        self.nodes_BFS = []
-        self.nodes_DFS_pre = []
-        self.nodes_DFS_post = []
-        self.nodes_DFS_in = []
-
-    def BFS(self): 
-        self.root.level = 0 
-        queue = [self.root]
-        current_level = self.root.level
-
-        while len(queue) > 0:                 
-            current_node = queue.pop(0)
-            if current_node.level > current_level:
-                current_level += 1
-            self.nodes_BFS.append(current_node.value)
-
-            if current_node.left:
-                current_node.left.level = current_level + 1
-                queue.append(current_node.left)
-                  
-            if current_node.right:
-                current_node.right.level = current_level + 1
-                queue.append(current_node.right)
-      
-        return self.nodes_BFS 
-
-    def DFS_inorder(self, node):      
-        if node is not None:         
-            self.DFS_inorder(node.left)
-            self.nodes_DFS_in.append(node.value)
-            self.DFS_inorder(node.right)
-        return self.nodes_DFS_in
-
-    def DFS_preorder(self, node):          
-        if node is not None:    
-            self.nodes_DFS_pre.append(node.value)
-            self.DFS_preorder(node.left)
-            self.DFS_preorder(node.right)
-        return self.nodes_DFS_pre
-
-    def DFS_postorder(self, node):           
-        if node is not None:
-            self.DFS_postorder(node.left)
-            self.DFS_postorder(node.right)
-            self.nodes_DFS_post.append(node.value)
-        return self.nodes_DFS_post
-
-def main():
-    tree = BSTTraversal()     
-    l1 = [10, 5, 15, 1, 6, 11, 50]
-    for i in l1: tree.insert(i)
-    
-    print('Breadth-First Traversal: ', tree.BFS())    
-    print('Inorder Traversal: ', tree.DFS_inorder(tree.root))   
-    print('Preorder Traversal: ', tree.DFS_preorder(tree.root))
-    print('Postorder Traversal: ', tree.DFS_postorder(tree.root)) 
-
-if __name__ == '__main__':
-    main()

src/trees/traversals/BST_with_extra_methods.py

@@ -1,95 +0,0 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
-
-from BST_traversal import TranversalBST
-from BST import BST
-
-class BSTwithExtra(TranversalBST):
-    def __init__(self):
-        self.bst = BST(None)
-        self.nodes = []  
-                      
-    def get_inorder(self, k):
-        for i, value in enumerate(self.inorder()):
-            if value == k:
-                return i
-                
-    def get_preorder(self, k):
-        for i, value in enumerate(self.preorder()):
-            if value == k:
-                return i
-                                    
-
-    def is_balanced(self, threshold=1):
-        maxd = self.get_max_depth()
-        mind = self.get_min_depth()
-        print('Max depth: ' + str(maxd))
-        print('Min depth: ' + str(mind))
-        return maxd -mind
-
-    def get_min_depth(self, node=None, initial=1):
-        if node is None and initial == 1:
-            node = self.bst
-        if node.left and node.right:
-            return 1 + min(self.get_min_depth(node.left, 0),
-                       self.get_min_depth(node.right, 0))
-        else:
-            if node.left:
-                return 1 + self.get_max_depth(node.left, 0)
-            elif node.right:
-                return 1 + self.get_max_depth(node.right, 0)
-            else:
-                return 0
-    
-    def get_max_depth(self, node=None, initial=1):
-        if node is None and initial == 1:
-            node = self.bst
-        if node.left and node.right:
-            return 1 + max(self.get_max_depth(node.left, 0),
-                       self.get_max_depth(node.right, 0))
-        else:
-            if node.left:
-                return 1 + self.get_max_depth(node.left, 0)
-            elif node.right:
-                return 1 + self.get_max_depth(node.right, 0)
-            else:
-                return 0
-
-def main():
-    """
-            10 
-       5       15
-    1   6     11    50
-                        60
-                            70
-                                80
-    """     
-    t = BSTwithExtra()
-    l1 = [10, 5, 15, 1, 6, 11, 50, 60, 70, 80]
-    for i in l1: t.insert(i)
-    print(t.inorder())
-    print(t.preorder())
-    assert(t.get_max_depth() == 5)
-    assert(t.get_min_depth() == 2)
-    assert(t.is_balanced() == 3)    
-    assert(t.get_inorder(10) == 3)
-    assert(t.get_preorder(10) == 0)    
-    
-    
-    """
-            1 
-       2       3
-    4   5     6    7
-    """  
-    t2 = BSTwithExtra()
-    l2 = [1, 2, 3, 4, 5, 6, 7, 8]
-    for i in l2: t2.insert(i)
-    print(t2.inorder())
-    print(t2.preorder())
-    assert(t2.is_balanced() == 0)    
-   
-    print("Tests Passed!")
-
-if __name__ == '__main__':
-    main()

src/trees/traversals/binary_tree.py

@@ -1,464 +0,0 @@
-#!/usr/bin/python
-
-__author__ = "Mari Wahl"
-__email__ = "marina.w4hl@gmail.com"
-
-
-
-''' Implementation of a binary tree and its properties. For example, the following bt:
-
-                               1                ---> level 0
-                        2             3         ---> level 1
-                  4         5                   ---> level 2
-              6      7                          ---> level 3
-            8   9                               ---> level 4
-
-    has the following properties:
-
-        - SIZE OR NUMBER OF NODES: n = 9
-        - NUMBER OF BRANCHES OR INTERNAL NODES: b = n-1 = 8
-        - VALUE OF ROOT = 1
-        - MAX_DEPTH OR HEIGHT: h = 4
-        - IS BALANCED? NO
-        - IS BST? NO
-        - INORDER DFT: 8, 6, 9, 4, 7, 2, 5, 1, 3
-        - POSTORDER DFT: 8, 9, 6, 7, 4, 5, 2, 3, 1
-        - PREORDER DFT: 1, 2, 4, 6, 8, 9, 7, 5, 3
-        - BFT:  1, 2, 3, 4, 5, 6, 7, 8, 9
-'''
-
-from collections import deque
-class NodeBT(object):
-    def __init__(self, item=None, level=0):
-        ''' Construtor for a Node in the Tree '''
-        self.item = item
-        self.level = level
-        self.left = None
-        self.right = None
-        self.traversal = []
-        #self.parent = None # not used here but can be necessary for some problems
-
-    '''
-        METHODS TO MODIFY NODES
-    '''
-
-    def _addNextNode(self, value, level_here=1):
-        ''' Aux for self.addNode(value)'''
-        self.traversal = []
-        new_node = NodeBT(value, level_here)
-        if not self.item:
-            self.item = new_node
-        elif not self.left:
-            self.left = new_node
-        elif not self.right:
-            self.right = new_node
-        else:
-            self.left = self.left._addNextNode(value, level_here+1)
-        return self
-
-
-
-    '''
-        METHODS TO PRINT/SHOW NODES' ATTRIBUTES
-    '''
-
-    def __repr__(self):
-        ''' Private method for this class'string representation'''
-        return '{}'.format(self.item)
-
-    def _getDFTpreOrder(self, node):
-        ''' Traversal Pre-Order, O(n)'''
-        if node:
-            if node.item: self.traversal.append(node.item)
-            self._getDFTpreOrder(node.left)
-            self._getDFTpreOrder(node.right)
-        return self
-
-    def _printDFTpreOrder(self, noderoot):
-        ''' Fill the pre-order traversal array '''
-        self.traversal = []
-        self._getDFTpreOrder(noderoot)
-        return self.traversal
-
-    def _getDFTinOrder(self, node):
-        ''' Traversal in-Order, O(n)'''
-        if node:
-            self._getDFTinOrder(node.left)
-            if node.item: self.traversal.append(node.item)
-            self._getDFTinOrder(node.right)
-        return self
-
-    def _printDFTinOrder(self, noderoot):
-        ''' Fill the in-order traversal array '''
-        self.traversal = []
-        self._getDFTinOrder(noderoot)
-        return self.traversal
-
-    def _getDFTpostOrder(self, node):
-        ''' Traversal post-Order, O(n)'''
-        if node:
-            self._getDFTpostOrder(node.left)
-            self._getDFTpostOrder(node.right)
-            if node.item: self.traversal.append(node.item)
-        return self
-
-    def _getBFT(self, node):
-        ''' Traversal bft, O(n)'''
-        if node:
-            queue = deque()
-            queue.append(node)
-            while len(queue) > 0:
-                current = queue.popleft()
-                if current.item: self.traversal.append(current)
-                if current.left: queue.append(current.left)
-                if current.right: queue.append(current.right)
-        return self
-
-    def _printBFT(self, noderoot):
-        ''' Fill the in-order traversal array '''
-        self.traversal = []
-        self._getBFT(noderoot)
-        return self.traversal
-
-
-    def _printDFTpostOrder(self, noderoot):
-        ''' Fill the post-order traversal array '''
-        self.traversal = []
-        self._getDFTpostOrder(noderoot)
-        return self.traversal
-
-    def _searchForNode(self, value):
-        ''' Traverse the tree looking for the node'''
-        if self.item == value: return self
-        else:
-            found = None
-            if self.left: found = self.left._searchForNode(value)
-            if self.right: found =  found or self.right._searchForNode(value)
-            return found
-
-    def _findNode(self, value):
-        ''' Find whether a node is in the tree.
-            if the traversal was calculated, it is just a membership
-            checking, which is O(1), otherwise it is necessary to traverse
-            the binary tree, so best case is O(1) and worst is O(n). '''
-        if self.traversal: return value in self.traversal
-        else: return self._searchForNode(value)
-
-    def _isLeaf(self):
-        ''' Return True if the node is a leaf '''
-        return not self.right and not self.left
-
-    def _getMaxHeight(self):
-        ''' Get the max height at the node, O(n)'''
-        levelr, levell = 0, 0
-        if self.right:
-            levelr = self.right._getMaxHeight() + 1
-        if self.left:
-            levell = self.left._getMaxHeight() + 1
-        return max(levelr, levell)
-
-    def _getMinHeight(self, level=0):
-        ''' Get the min height at the node, O(n)'''
-        levelr, levell = -1, -1
-        if self.right:
-            levelr = self.right._getMinHeight(level +1)
-        if self.left:
-            levell = self.left._getMinHeight(level +1)
-        return min(levelr, levell) + 1
-
-    def _isBalanced(self):
-        ''' Find whether the tree is balanced, by calculating heights first, O(n2) '''
-        if self._getMaxHeight() - self._getMinHeight() < 2:
-            return False
-        else:
-            if self._isLeaf():
-                return True
-            elif self.left and self.right:
-                return self.left._isBalanced() and   self.right._isBalanced()
-            elif not self.left and self.right:
-                return  self.right._isBalanced()
-            elif not self.right and self.left:
-                 return  self.right._isBalanced()
-
-
-
-    def _isBalancedImproved(self):
-        ''' Find whehter the tree is balanced in each node, O(n) '''
-        return 'To Be written'
-
-    ''' There are two solutions to check whether a bt is a bst:
-    (1) Do an inorder, check if the inorder is sorted. However inorder
-        can't handle the difference between duplicate values on the left
-        or on the right (if it is in the right, the tree is not bst).
-    '''
-
-
-    def _isBST(self):
-        ''' Find whether the tree is a BST, inorder '''
-        if self.item:
-            if self._isLeaf(): return True
-            elif self.left:
-                if self.left.item < self.item: return self.left._isBST()
-                else: return False
-            elif self.right:
-                if self.right.item > self.item: return self.right._isBST()
-                else: return False
-        else:
-            raise Exception('Tree is empty')
-
-
-    def _getAncestorBST(self, n1, n2):
-        ''' Return the ancestor of two nodes if it is a bst.
-            we are supposing the values in the tree are unique.'''
-        if n1 == self.item or n2 == self.item : return self.item
-        elif self.item < n1 and self.item < n2:
-            self.right.getAncestorBST(n1, n2)
-        elif self.item > n1 and self.item > n2:
-            self.left.getAncestorBST(n1, n2)
-        else:
-            return self.item
-
-
-
-
-class BinaryTree(object):
-    '''
-    >>> bt = BinaryTree()
-    >>> for i in range(1, 10): bt.addNode(i)
-    >>> bt.hasNode(7)
-    True
-    >>> bt.hasNode(12)
-    False
-    >>> bt.printTree()
-    [1, 2, 4, 6, 8, 9, 7, 5, 3]
-    >>> bt.printTree('pre')
-    [1, 2, 4, 6, 8, 9, 7, 5, 3]
-    >>> bt.printTree('bft')
-    [1, 2, 3, 4, 5, 6, 7, 8, 9]
-    >>> bt.printTree('post')
-    [8, 9, 6, 7, 4, 5, 2, 3, 1]
-    >>> bt.printTree('in')
-    [8, 6, 9, 4, 7, 2, 5, 1, 3]
-    >>> bt.hasNode(9)
-    True
-    >>> bt.hasNode(11)
-    False
-    >>> bt.isLeaf(8)
-    True
-    >>> bt.getNodeLevel(1)
-    0
-    >>> bt.getNodeLevel(8)
-    4
-    >>> bt.getSizeTree()
-    9
-    >>> bt.isRoot(10)
-    False
-    >>> bt.isRoot(1)
-    True
-    >>> bt.getHeight()
-    4
-    >>> bt.isBST(1)
-    False
-    >>> bt.isBalanced()
-    False
-    >>> bt.isBalanced(2)
-    False
-    >>> bt.getAncestor(8, 5)
-    2
-    >>> bt.getAncestor(8, 5, 'pre-post')
-    2
-    >>> bt.getAncestor(8, 5, 'post-in')
-    2
-    '''
-
-
-
-    def __init__(self):
-        ''' Constructor for the Binary Tree, which is a container of Nodes'''
-        self.root = None
-
-
-    '''
-        METHODS TO MODIFY THE TREE
-    '''
-
-    def addNode(self, value):
-        ''' Add new node to the tree, by the left first, O(n) '''
-        if not self.root: self.root = NodeBT(value)
-        else: self.root._addNextNode(value)
-
-    '''
-        METHODS TO PRINT/SHOW TREES' ATTRIBUTES
-    '''
-
-    def __repr__(self):
-        ''' Private method for this class'string representation'''
-        return '{}'.format(self.item)
-
-    def printTree(self, order = 'pre'):
-        ''' Print Tree in the chosen order '''
-        if self.root:
-            if order == 'pre': return self.root._printDFTpreOrder(self.root)
-            elif order == 'in': return self.root._printDFTinOrder(self.root)
-            elif order == 'post': return self.root._printDFTpostOrder(self.root)
-            elif order == 'bft': return self.root._printBFT(self.root)
-        else: raise Exception('Tree is empty')
-
-    def hasNode(self, value):
-        ''' Verify whether the node is in the Tree '''
-        return bool(self.root._findNode(value))
-
-    def isLeaf(self, value):
-        ''' Return True if the node is a Leaf '''
-        node = self.root._searchForNode(value)
-        return node._isLeaf()
-
-    def getNodeLevel(self, item):
-        ''' Return the level of the node, best O(1), worst O(n) '''
-        node = self.root._searchForNode(item)
-        if node: return node.level
-        else: raise Exception('Node not found')
-
-    def getSizeTree(self):
-        ''' Return how many nodes in the tree, O(n) '''
-        return len(self.root._printDFTpreOrder(self.root))
-
-    def isRoot(self, value):
-        '''Return the root of the tree '''
-        return self.root.item == value
-
-    def getHeight(self):
-        ''' Returns the height/depth of the tree, best/worst O(n)  '''
-        return self.root._getMaxHeight()
-
-    def isBalanced(self, method=1):
-        ''' Return True if the tree is balanced'''
-        if method == 1:
-            ''' O(n2)'''
-            return self.root._isBalanced()
-        else:
-            ''' O(n)'''
-            return self.root._isBalancedImproved()
-
-
-
-    ''' The following methods are for searching the lowest common ancestor
-    in a BT. Since a simple BT does not have ordering, it can be O(n). If
-    we have a link for the ancestors, the steps are:
-        (1) search both trees in order to find the nodes separately
-        (2) list all ancestors
-        (3) find first that mach
-        obs: if we do this too many times we can do a pre and use the methods here'''
-
-    def isBST(self, method=1):
-        ''' Return True if the tree is BST'''
-        if method == 1:
-            inorder = self.root._printDFTinOrder(self.root)
-            return inorder == sorted(inorder)
-        elif method == 2:
-            return self.root._isBST()
-
-
-    def _getAncestorPreIn(self, preorder, inorder, value1, value2):
-        ''' Return the ancestor of two nodes with pre and in'''
-        root = preorder[0]
-        preorder = preorder[1:]
-        i = 0
-        item = inorder[0]
-        value1left, value2left = False, False
-        while item != root and i < len(inorder):
-            if item == value1: value1left = True
-            elif item == value2: value2left = True
-            i += 1
-            item = inorder[i]
-        if (value1left and not value2left) or (value2left and not value1left):
-            return root
-        else:
-            return self._getAncestorPreIn(preorder, inorder[:i] + inorder[i+1:], value1, value2)
-
-    def _getAncestorPrePost(self, preorder, postorder, value1, value2):
-        ''' Return the ancestor of two nodes with pre and post'''
-        root = preorder[0]
-        preorder = preorder[1:]
-        postorder = postorder[:-1]
-        value1right, value2right = False, False
-        i = len(postorder)-1
-        itempre = preorder[0]
-        itempos = postorder[i]
-        while itempre != itempos and i > 0:
-            if itempos == value1: value1right = True
-            elif itempos == value2: value2right = True
-            i -= 1
-            itempos = postorder[i]
-
-        if (value1right and not value2right) or (value2right and not value1right):
-            return root
-        else:
-            return self._getAncestorPrePost(preorder, postorder[:i] + postorder[i+1:], value1, value2)
-
-    def _getAncestorInPost(self, inorder, postorder, value1, value2):
-        ''' Return the ancestor of two nodes with in and post'''
-        root = postorder[-1]
-        postorder = postorder[:-1]
-        value1left, value2left = False, False
-        i = 0
-        item = inorder[i]
-        while item != root and i < len(inorder):
-            if item == value1: value1left = True
-            elif item == value2: value2left = True
-            i += 1
-            item = inorder[i]
-
-        if (value1left and not value2left) or (value2left and not value1left):
-            return root
-        else:
-            return self._getAncestorInPost(postorder, inorder[:i] + inorder[i+1:], value1, value2)
-
-
-
-
-
-    def _getAncestorBST2(self, preorder, value1, value2):
-        ''' Return the ancestor of two nodes if it is a bst, using traversal'''
-        while preorder:
-            current = preorder[0]
-            if current < value1:
-                try: preorder = preorder[2:]
-                except: return current
-            elif current > value2:
-                try: preorder = preorder[1:]
-                except: return current
-            elif value1 <= current <= value2:
-                return current
-        return None
-
-    def getAncestor(self, value1, value2, method='pre-in'):
-        ''' Return the commom ancestor for two nodes'''
-        if method == 'pre-in':
-            ''' Using pre and inorder, best/worst O(n)'''
-            preorder = self.root._printDFTpreOrder(self.root)
-            inorder = self.root._printDFTinOrder(self.root)
-            return self._getAncestorPreIn(preorder, inorder, value1, value2)
-        if method == 'pre-post':
-            ''' Using pre and postorder, best/worst O(n)'''
-            preorder = self.root._printDFTpreOrder(self.root)
-            postorder = self.root._printDFTpostOrder(self.root)
-            return self._getAncestorPrePost(preorder, postorder, value1, value2)
-        if method == 'post-in':
-            ''' Using in and postorder, best/worst O(n)'''
-            inorder = self.root._printDFTinOrder(self.root)
-            postorder = self.root._printDFTpostOrder(self.root)
-            return self._getAncestorInPost(inorder, postorder, value1, value2)
-        if method == 'bst':
-            if self.isBST():
-                return self.root._getAncestorBST(value1, value2)
-
-                #preorder = self.root._printDFTpreOrder(self.root)
-                #return self._getAncestorBST2(preorder, value1, value2)
-            else:
-                return Exception('The tree is not a BST')
-
-
-if __name__ == '__main__':
-    import doctest
-    doctest.testmod()

src/trees/traversals/traversals.py

@@ -1,131 +0,0 @@
-#!/usr/bin/python3
-# mari von steinkirch @2013
-# steinkirch at gmail
-
-from BST import BST
-
-
-from collections import deque
-class TranversalBST(object):
-    def __init__(self):
-        self.bst = BST(None)
-        self.nodes = []
-        
-    def insert(self, value):
-        if not self.bst.value:
-            self.bst.value = value
-        else:
-            self.bst.insert(value)
-
-    def contains(self, value):
-        return bool(self.bst.find(value))
-
-    def get(self, index):
-        for i, value in enumerate(self.inorder()):
-            if i == index:
-                return value
-
-    def inorder(self):
-        current = self.bst  
-        self.nodes = []
-        stack = []
-        while len(stack) > 0 or current is not None:
-            if current is not None:
-                stack.append(current)   
-                current = current.left
-            else:
-                current = stack.pop()
-                self.nodes.append(current.value)
-                current = current.right
-        return self.nodes
-
-
-    def preorder(self):
-        self.nodes = []
-        stack = [self.bst]  
-        while len(stack) > 0:
-            curr = stack.pop()
-            if curr is not None:
-                self.nodes.append(curr.value)
-                stack.append(curr.right)
-                stack.append(curr.left)
-        return self.nodes
-
-
-    def preorder2(self):
-        self.nodes = []
-        current = self.bst  
-        stack = []
-        while len(stack) > 0 or current is not None:
-            if current is not None:
-                self.nodes.append(current.value)
-                stack.append(current)   
-                current = current.left
-            else:
-                current = stack.pop()               
-                current = current.right            
-        return self.nodes
-
-
-
-    def preorder3(self):
-        self.nodes = []
-        node = self.bst
-        if not node: return None
-        stack = []  
-        stack.append(node)  
-        while stack:
-            node = stack.pop()
-            self.nodes.append(node.value)
-            if node.right: stack.append(node.right) # RIGHT FIRST!
-            if node.left: stack.append(node.left)
-        return self.nodes
-
-
-
-    
-    def BFT(self):
-        self.nodes = []
-        node = self.bst
-        if not node: return None
-        queue = deque() 
-        queue.append(node)  
-        while queue:
-            node = queue.popleft()
-            self.nodes.append(node.value)
-            if node.left: queue.append(node.left) # LEFT FIRST!
-            if node.right: queue.append(node.right)
-
-        return self.nodes
-
-
-
-
-def main():
-    """
-            10 
-       5       15
-    1   6     11    50
-    """     
-    t = TranversalBST()
-    t.insert(10)
-    t.insert(5)
-    t.insert(15)
-    t.insert(1)
-    t.insert(6)
-    t.insert(11)
-    t.insert(50)
-    print(t.preorder())
-    print(t.preorder2())
-    print(t.preorder3()) 
-    print(t.inorder())
-    print(t.BFT())
-    '''
-    [10, 5, 1, 6, 15, 11, 50]
-    [10, 5, 1, 6, 15, 11, 50]
-    [10, 5, 1, 6, 15, 11, 50]
-    [1, 5, 6, 10, 11, 15, 50]
-    [10, 5, 15, 1, 6, 11, 50]
-    '''
-if __name__ == '__main__':
-    main()