🏣 Clean up for arxiv

book/ebook_src/trees/binary_search_tree.py

@@ -0,0 +1,120 @@
+#!/usr/bin/python
+
+__author__ = "bt3"
+
+
+class Node(object):
+
+    def __init__(self, item=None,):
+
+        self.item = item
+        self.left = None
+        self.right = None
+
+    def __repr__(self):
+        return '{}'.format(self.item)
+
+
+    def _add(self, value):
+        new_node = Node(value)
+
+        if not self.item:
+            self.item = new_node
+
+        else:
+            if value > self.item:
+                self.right = self.right and self.right._add(value) or new_node
+            elif value < self.item:
+                self.left = self.left and self.left._add(value) or new_node
+            else:
+                print("BSTs do not support repeated items.")
+
+        return self # this is necessary!!!
+
+
+    def _search(self, value):
+        if self.item == value:
+            return True # or self
+
+        elif self.left and value < self.item:
+                return self.left._search(value)
+
+        elif self.right and value > self.item:
+                return self.right._search(value)
+
+        else:
+            return False
+
+
+    def _isLeaf(self):
+        return not self.right and not self.left
+
+
+    def _printPreorder(self):
+        print self.item
+
+        if self.left:
+            self.left._printPreorder()
+
+        if self.right:
+            self.right._printPreorder()
+
+    # Another possibility: use an array (a little bit more expensive):
+    def _preorder_array(self):
+        nodes = []
+        if self.item:
+            nodes.append(self.item)
+        if self.left:
+            nodes.extend(self.left._preorder_array())
+        if self.right:
+            nodes.extend(self.right._preorder_array())
+        return nodes
+
+
+
+
+class BST(object):
+
+    def __init__(self):
+        self.root = None
+
+    def add(self, value):
+        if not self.root:
+            self.root = Node(value)
+        else:
+            self.root._add(value)
+
+    def printPreorder(self):
+        if self.root:
+            self.root._printPreorder()
+
+    def search(self, value):
+        if self.root:
+            return self.root._search(value)
+
+    def preorder_array(self):
+        if self.root:
+            return self.root._preorder_array()
+        else:
+            return 'Tree is empty.'
+
+
+if __name__ == '__main__':
+
+    bst = BST()
+    print "Adding nodes 1 to 10 in the tree..."
+    for i in range(1, 11):
+        bst.add(i)
+
+    print
+    print "Searching for nodes 16 and 6"
+    print bst.search(16)
+    print bst.search(6)
+
+    print
+    print "Printing preorder..."
+    bst.printPreorder()
+
+
+
+

book/ebook_src/trees/binary_tree.py

@@ -0,0 +1,96 @@
+#!/usr/bin/python
+
+__author__ = "bt3"
+
+
+class Node(object):
+
+    def __init__(self, item=None,):
+        self.item = item
+        self.left = None
+        self.right = None
+
+    def __repr__(self):
+        return '{}'.format(self.item)
+
+
+    def _add(self, value):
+        new_node = Node(value)
+
+        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._add(value)
+
+        return self
+
+
+    def _search(self, value):
+        if self.item == value:
+            return True # or self
+
+        found = False # or None, thats diff from BST
+        if self.left:
+            found = self.left._search(value)
+
+        if self.right:
+            found =  found or self.right._search(value)
+
+        return found
+
+
+    def _isLeaf(self):
+        return not self.right and not self.left
+
+
+    def _preorder(self):
+        print self.item
+        if self.left:
+            self.left._preorder()
+        if self.right:
+            self.right._preorder()
+
+
+
+class BT(object):
+
+    def __init__(self):
+        self.root = None
+
+
+    def add(self, value):
+        if not self.root:
+            self.root = Node(value)
+        else:
+            self.root._add(value)
+
+
+    def search(self, value):
+        if self.root:
+            return self.root._search(value)
+
+
+    def preorder(self):
+        if self.root:
+            return self.root._preorder()
+
+
+if __name__ == '__main__':
+
+    bt = BT()
+    print "Adding nodes 1 to 10 in the tree..."
+    for i in range(1, 11):
+        bt.add(i)
+
+    print
+    print "Searching for nodes 16 and 6"
+    print bt.search(16)
+    print bt.search(6)
+
+    print
+    print "Printing preorder..."
+    bt.preorder()

book/ebook_src/trees/binary_tree_generators.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+class Node(object):
+    def __init__(self, value):
+        self.value = value
+        self.right = None
+        self.left = None
+
+    def add(self, value):
+        new_node = Node(value)
+        if not self.value:
+            self.value = new_node
+        elif not self.left:
+            self.left = new_node
+        elif not self. right:
+            self.right = new_node
+        else:
+            self.left = self.left.add(value)
+        return self # without this, it doesn't add!
+
+    def search(self, item):
+        if self.value == item:
+            return True
+        found = False
+        if (self.left and self.left.search(item)) or \
+                (self.right and self.right.search(item)):
+            found = True
+        return found
+
+    def preorder(self):
+        yield self.value
+        if self.left:
+            for node in self.left.preorder():
+                yield node
+        if self.right:
+            for node in self.right.preorder():
+                yield node
+
+    def postorder(self):
+        yield self.value
+        if self.left:
+            for node in self.left.postorder():
+                yield node
+        if self.right:
+            for node in self.right.postorder():
+                yield node
+
+    def inorder(self):
+        yield self.value
+        if self.left:
+            for node in self.left.inorder():
+                yield node
+        if self.right:
+            for node in self.right.inorder():
+                yield node
+
+    # this is the most basic way to write this function
+    def preorder_simple(self):
+        print self.value
+        if self.left:
+            self.left.preorder_simple()
+        if self.right:
+            self.right.preorder_simple()
+
+
+    # Another possibility: use an array (a little bit more expensive):
+    def preorder_array(self):
+        nodes = []
+        if self.value:
+            nodes.append(self.value)
+        if self.left:
+            nodes.extend(self.left.preorder_array())
+        if self.right:
+            nodes.extend(self.right.preorder_array())
+        return nodes
+
+
+
+class BT(object):
+    def __init__(self):
+        self.root = None
+
+    def add(self, value):
+        if not self.root:
+            self.root = Node(value)
+        else:
+            self.root.add(value)
+
+    def search(self, item):
+        if self.root:
+            return self.root.search(item)
+        else:
+            return 'Tree is empty.'
+
+    def preorder(self):
+        if self.root:
+            return self.root.preorder()
+        else:
+            return 'Tree is empty.'
+
+    def inorder(self):
+        if self.root:
+            return self.root.inorder()
+        else:
+            return 'Tree is empty.'
+
+    def postorder(self):
+        if self.root:
+            return self.root.postorder()
+        else:
+            return 'Tree is empty.'
+
+    def preorder_array(self):
+        if self.root:
+            return self.root.preorder_array()
+        else:
+            return 'Tree is empty.'
+
+    def preorder_simple(self):
+        if self.root:
+            return self.root.preorder_simple()
+        else:
+            return 'Tree is empty.'
+
+
+if __name__ == '__main__':
+    tree = BT()
+
+    for i in range(1, 11):
+        tree.add(i)
+
+    print 'Searching for node 4'
+    print tree.search(4)
+
+    print 'Searching for node 1'
+    print tree.search(1)
+
+    print 'Searching for node 12'
+    print tree.search(12)
+
+    print 'Pre-order generator...'
+    getree = tree.preorder()
+    for i in range(10):
+        print next(getree)
+    print
+    print 'Pre-order array...'
+
+    print tree.preorder_array()
+
+    print
+    print 'Pre-order simple...'
+
+    tree.preorder_simple()
+
+    print
+    print 'Inorder...'
+
+    getree = tree.inorder()
+    for i in range(10):
+        print next(getree)
+
+    print
+    print 'Postorder...'
+
+    getree = tree.postorder()
+    for i in range(10):
+        print next(getree)

book/ebook_src/trees/bunchclass.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+class BunchClass(dict):
+    def __init__(self, *args, **kwds):
+        super(BunchClass, self).__init__(*args, **kwds)
+        self.__dict__ = self
+
+
+def main():
+    ''' {'right': {'right': 'Xander', 'left': 'Willow'}, 'left': {'right': 'Angel', 'left': 'Buffy'}}'''
+    bc = BunchClass     # notice the absence of ()
+    tree = bc(left = bc(left="Buffy", right="Angel"), right = bc(left="Willow", right="Xander"))
+    print(tree)
+
+if __name__ == '__main__':
+     main()
+
+
+
+

book/ebook_src/trees/check_ancestor.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+from binary_search_tree import BST, Node
+
+def find_ancestor(path, low_item, high_item):
+    while path:
+        current_item = path[0]
+
+        if current_item < low_item:
+            try:
+                path = path[2:]
+            except:
+                return current_item
+
+        elif current_item > high_item:
+            try:
+                path = path[1:]
+            except:
+                return current_item
+
+        elif low_item <= current_item <= high_item:
+            return current_item
+
+
+def find_ancestor2(tree, n1, n2):
+    if not tree:
+        return False
+
+    if n1 <= tree.item and n2 >= tree.item or (not tree.left and not tree.right) :
+        return tree.item
+
+    if tree.left and (n1 < tree.item and n2 < tree.item):
+        return find_ancestor(tree.left, n1, n2) or tree.item
+
+    if tree.right and (n1 > tree.item and n2 > tree.item):
+        return find_ancestor(tree.right, n1, n2) or tree.item
+
+
+
+if __name__ == '__main__':
+    bst = BST()
+    l = [10, 5, 6, 3, 8, 2, 1, 11, 9, 4]
+    for i in l:
+        bst.add(i)
+    nodes = bst.preorder_array()
+
+    print 'Original:    ', l
+    print 'Preorder:    ', nodes
+
+    print 'Method 1: '
+    print 'Ancestor for 3, 11:', find_ancestor(nodes, 3, 11)
+
+    print 'Method 2: '
+    print 'Ancestor for 3, 11: ', find_ancestor2(bst.root, 3, 11)

book/ebook_src/trees/check_if_balanced.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+from binary_search_tree import BST, Node
+from binary_tree import BT, Node
+
+
+
+def isBalanced(node, left=0, right=0):
+    if not node:
+        return (left - right) < 2
+
+    return isBalanced(node.left, left+1, right) and \
+        isBalanced(node.right, left, right+1)
+
+
+
+
+if __name__ == '__main__':
+    bt = BST()
+    for i in range(1, 10):
+        bt.add(i)
+
+    assert(isBalanced(bt.root) == True)
+
+    bt = BT()
+    for i in range(1, 10):
+        bt.add(i)
+
+    assert(isBalanced(bt.root) == False)

book/ebook_src/trees/check_if_bst.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+from binary_search_tree import BST, Node
+from binary_tree import BT, Node
+
+
+def isBST(node, min_node=float("-infinity"), maxVal=float("infinity")):
+    if not node:
+        return True
+
+    if not min_node <= node.item <= maxVal:
+        return False
+
+    return isBST(node.left, min_node, node.item) and \
+           isBST(node.right, node.item, maxVal)
+
+
+
+def isBST_other_method(node, max_node=None, min_node=None):
+
+    if not node:
+        return True
+
+    left, right =  True, True
+    min_node = min_node or float('inf')
+    max_node = max_node or -float('inf')
+
+    if node.left:
+        if node.left.item > node.item or node.left.item > max_node:
+            left = False
+        else:
+            max_node = node.item
+            left =  isBST(node.left, max_node, min_node)
+
+    if node.right:
+        if node.right.item < node.item or node.right.item < min_node:
+            rihjt =  False
+        else:
+            min_node = node.item
+            right =  isBST(node.right, max_node, min_node)
+
+    return left and right
+
+
+
+
+
+if __name__ == '__main__':
+    bt = BST()
+    for i in range(1, 10):
+        bt.add(i)
+
+    assert(isBST(bt.root) == True)
+
+    bt = BT()
+    for i in range(1, 10):
+        bt.add(i)
+
+    assert(isBST(bt.root) == False)
+
+

book/ebook_src/trees/check_largest_item.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+from binary_search_tree import BST, Node
+
+def largest(node):
+
+    if node.right:
+        return largest(node.right)
+    return node.item
+
+
+if __name__ == '__main__':
+
+
+    bst = BST()
+    l = [10, 5, 6, 3, 8, 2, 1, 11, 9, 4]
+    for i in l:
+        bst.add(i)
+
+    print(largest(bst.root))

book/ebook_src/trees/simple_tree.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+""" A class for a simple tree """
+
+class SimpleTree(object):
+
+    def __init__(self, value=None, children = None):
+        self.value = value
+        self.children = children
+        if self.children == None:
+            self.children = []
+
+    def __repr__(self, level=0):
+        ret = "\t"*level+repr(self.value)+"\n"
+        for child in self.children:
+            ret += child.__repr__(level+1)
+        return ret
+
+
+
+def main():
+    """
+    'a'
+	    'b'
+		    'd'
+		    'e'
+	    'c'
+		    'h'
+		    'g'
+    """
+    st = SimpleTree('a', [SimpleTree('b', [SimpleTree('d'), SimpleTree('e')] ), SimpleTree('c', [SimpleTree('h'), SimpleTree('g')]) ])
+    print(st)
+
+
+if __name__ == '__main__':
+    main()
+
+

book/ebook_src/trees/transversal.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+from collections import deque
+from binary_search_tree import BST, Node
+from binary_tree import BT, Node
+
+
+def BFT(tree):
+    current = tree.root
+    nodes = []
+    queue = deque()
+    queue.append(current)
+
+    while queue:
+        current = queue.popleft()
+        nodes.append(current.item)
+        if current.left:
+            queue.append(current.left)
+        if current.right:
+            queue.append(current.right)
+
+    return nodes
+
+
+def preorder(tree, nodes=None):
+    nodes = nodes or []
+    if tree:
+        nodes.append(tree.item)
+        if tree.left:
+            preorder(tree.left, nodes)
+        if tree.right:
+            preorder(tree.right, nodes)
+    return nodes
+
+
+def postorder(tree, nodes=None):
+    nodes = nodes or []
+    if tree:
+        if tree.left:
+            nodes = postorder(tree.left, nodes)
+        if tree.right:
+            nodes = postorder(tree.right, nodes)
+        nodes.append(tree.item)
+
+    return nodes
+
+
+def inorder(tree, nodes=None):
+    nodes = nodes or []
+    if tree:
+        if tree.left:
+            nodes = inorder(tree.left, nodes)
+        nodes.append(tree.item)
+        if tree.right:
+            nodes = inorder(tree.right, nodes)
+    return nodes
+
+
+if __name__ == '__main__':
+
+
+    # bt
+    bt = BT()
+    l = [10, 5, 6, 3, 8, 2, 1, 11, 9, 4]
+    for i in l:
+        bt.add(i)
+    print 'BT...'
+    print 'Original:    ', l
+    print 'Preorder:    ', preorder(bt.root)
+    print 'Postorder:   ', postorder(bt.root)
+    print 'Inorder:     ', inorder(bt.root)
+    print 'Breath:      ', BFT(bt)
+
+    # bst
+    bst = BST()
+    l = [10, 5, 6, 3, 8, 2, 1, 11, 9, 4]
+    for i in l:
+        bst.add(i)
+
+    print
+    print 'BST ...'
+    print 'Original:    ', l
+    print 'Preorder:    ', preorder(bst.root)
+    print 'Postorder:   ', postorder(bst.root)
+    print 'Inorder:     ', inorder(bst.root)
+    print 'Breath:      ', BFT(bst)

book/ebook_src/trees/trie.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+
+__author__ = "bt3"
+
+
+'''
+Implement a trie. (Write the API and code for inserting into a trie).
+'''
+
+def make_trie(*args):
+    trie = {}
+
+    for word in args:
+        temp_trie = trie
+        for letter in word:
+            temp_trie = temp_trie.setdefault(letter, {})
+        temp_trie = temp_trie.setdefault('_end_', '_end_')
+
+    return trie
+
+
+def in_trie(trie, word):
+    temp_trie = trie
+    for letter in word:
+        if letter not in temp_trie:
+            return False
+        temp_trie = temp_trie[letter]
+    return True
+
+
+def remove_from_trie(trie, word, depth):
+    if word and word[depth] not in trie:
+        return False
+
+    if len(word) == depth + 1:
+        del trie[word[depth]]
+        if not trie:
+           return True
+        return False
+    else:
+        temp_trie = trie
+
+        if remove_from_trie(temp_trie[word[depth]], word, depth + 1):
+            if temp_trie:
+                del temp_trie[word[depth]]
+            return not temp_trie
+    return False
+
+
+if __name__ == '__main__':
+    trie = make_trie('hello', 'abc', 'baz', 'bar', 'barz')
+    print 'This is the trie:'
+    print trie
+
+    assert(in_trie(trie, 'hello') == True)
+    assert(in_trie(trie, 'bar') == True)
+    assert(in_trie(trie, 'bab') == False)
+    assert(in_trie(trie, 'zzz') == False)
+
+    remove_from_trie(trie, 'abc', 0)
+    assert(in_trie(trie, 'abc') == False)
+
+
+
+