def postorder_example_tree(): tree = BinaryTree() n1 = Node('I') n2 = Node('N') n3 = Node('S') n4 = Node('C') n5 = Node('R') n6 = Node('E') n7 = Node('V') n8 = Node('A') n9 = Node('5') n0 = Node('3') n0.left = n6 n0.right = n9 n6.left = n1 n6.right = n5 n5.left = n2 n5.right = n4 n4.right = n3 n9.left = n8 n8.right = n7 tree.root = n0 return tree
def createTree(): print("Method is {}".format(createTree.__name__)) root = Node(1) root.left = Node(2) root.right = Node(3) root.left.left = Node(4) root.left.right = Node(5) return root
def test_inorder_tree_walk_stack(): T = BinaryTree() T.TREE_INSERT(Node(5)) T.TREE_INSERT(Node(3)) T.TREE_INSERT(Node(2)) T.TREE_INSERT(Node(7)) T.TREE_INSERT(Node(6)) T.INORDER_TREE_WALK_WITH_STACK(T.root)
def test_max(): T = BinaryTree() T.TREE_INSERT(Node(5)) T.TREE_INSERT(Node(3)) T.TREE_INSERT(Node(2)) T.TREE_INSERT(Node(7)) T.TREE_INSERT(Node(6)) assert T.TREE_MAXIMUM(T.root).key == 7
def main(): root = Node(1) root.left = Node(2) root.right = Node(3) root.left.left = Node(4) root.left.right = Node(5) inOrder(root)
def main(): root = Node(1) root.left = Node(2) root.right = Node(3) root.left.left = Node(4) root.right.right = Node(5) result = diameter(root) print(result)
def gen_uniq_BST(i,j): if i > j: yield None elif i == j: yield Node(i) else: for root in range(i,j+1): node = Node(root) for left_node in gen_uniq_BST(i,root-1): for right_node in gen_uniq_BST(root+1,j): node.left = left_node node.right = right_node yield node
def test_insert2(): T = BinaryTree() T.TREE_INSERT(Node(5)) T.TREE_INSERT(Node(3)) T.TREE_INSERT(Node(2)) T.TREE_INSERT(Node(7)) T.TREE_INSERT(Node(6)) assert T.root.key == 5 assert T.root.p == None assert T.root.left.key == 3 assert T.root.left.left.key == 2 assert T.root.right.key == 7 assert T.root.right.left.key == 6 assert T.root.left == T.root.left.left.p assert T.root.right.left.p == T.root.right
def recursive(root, preorder, inorder, left_or_right): if preorder: sub_root = preorder[0] current_root = Node(sub_root) else: current_root = sub_root = None if left_or_right == 'left': root.left = current_root elif left_or_right == 'right': root.right = current_root else: btree.root = current_root if sub_root: root_index = inorder.index(sub_root) # split inorder inorder_left = inorder[:root_index] inorder_right = inorder[root_index + 1:] # split preorder preorder_left = preorder[1:1 + root_index] preorder_right = preorder[1 + root_index:] #recursion for left subtree #for left subtree recursive(current_root, preorder_left, inorder_left, 'left') # for rigth subtree recursive(current_root, preorder_right, inorder_right, 'right')
def test_inorder_tree_walk_with_stack2(capsys): T = BinaryTree() for key in random.sample(range(1000), 1000): T.TREE_INSERT(Node(key)) T.INORDER_TREE_WALK_WITH_STACK(T.root) captured = list(map(int, capsys.readouterr().out.strip().split("\n"))) assert captured == list(range(1000))
def test_insert(): T = BinaryTree() z = Node(5) T.TREE_INSERT(z) assert T.root.key == 5 assert T.root.p == None assert T.root.left == None assert T.root.right == None
def test_postorder_tree_walk_compare(capsys): T = BinaryTree() keylist = [2, 3, 1, 6, 5] # list(random.sample(range(10), 5)) for key in keylist: T.TREE_INSERT(Node(key)) T.POSTORDER_TREE_WALK(T.root) captured = list(map(int, capsys.readouterr().out.strip().split("\n"))) assert captured == [1, 5, 6, 3, 2]
def _insert(self,n,key): #없으면 노드만 넣어서 if n==None: return Node(key) elif n.get_key()>key: n.set_left(self._insert,key) else: n.set_right(self._insert,key)
def test_preorder_tree_walk2(capsys): T = BinaryTree() keys = [5, 3, 2, 7, 6] for key in keys: T.TREE_INSERT(Node(key)) T.PREORDER_TREE_WALK(T.root) captured = list(map(int, capsys.readouterr().out.strip().split("\n"))) assert captured == keys
def insertNode(self, node, newVal): if (node == None): return Node(newVal, None, None) if (node.val > newVal): node.left = self.insertNode(node.left, newVal) elif (node.val < newVal): node.right = self.insertNode(node.right, newVal) return node
def createMinTree(array): if len(array) > 1: midPt = len(array)//2 root = Node(array[midPt]) print(array, array[midPt], midPt, array[:midPt]) root.left = createMinTree(array[:midPt]) root.right = createMinTree(array[midPt:]) return root
def SubTreeSlove(nums, l, r): mid = (l + r + 1) // 2 # 取中间数的索引 print(mid) node = Node(nums[mid]) if mid > l: node.left = SubTreeSlove(nums, l, mid - 1) if mid < r: node.right = SubTreeSlove(nums, mid + 1, r) return node
def main(): print("Method is {}".format(main.__name__)) #root = createTree() #root = createTree2() root = Node(1) input_list = input("Enter the list of numbers whose node is to created : ") for val in input_list.split(): root.insert(root, val) printOrders(root)
def test_successor(): T = BinaryTree() T.TREE_INSERT(Node(5)) T.TREE_INSERT(Node(3)) T.TREE_INSERT(Node(2)) T.TREE_INSERT(Node(7)) T.TREE_INSERT(Node(6)) a = T.TREE_MINIMUM(T.root) assert a.key == 2 b = T.TREE_SUCCESSOR(a) c = T.TREE_SUCCESSOR(b) d = T.TREE_SUCCESSOR(c) e = T.TREE_SUCCESSOR(d) assert b.key == 3 assert c.key == 5 assert d.key == 6 assert e.key == 7 x = T.TREE_SUCCESSOR(e) assert x == None
def createBinaryTree(): root = Node(1) root.left = Node(2) root.right = Node(3) root.left.left = Node(4) root.left.right = Node(5) root.right.left = Node(6) root.right.right = Node(7) return root
def parse_exp(exp): parse_stack = [] for e in exp: if '[' in e: parse_stack.append(Node(e)) elif ']' in e: lc = parse_stack[-1] rc = Node(e) newNode = Node('') newNode.addLeft(lc) newNode.addRight(rc) del parse_stack[-1] if len(parse_stack) == 0: return newNode else: lc = parse_stack[-1] rc = newNode newNode = Node('') newNode.addLeft(lc) newNode.addRight(rc) parse_stack[-1] = newNode else: lc = parse_stack[-1] rc = Node(e) newNode = Node('') newNode.addLeft(lc) newNode.addRight(rc) parse_stack[-1] = newNode return -1
def createTree2(): print("Method is {}".format(createTree2.__name__)) root = Node(10) root.left = Node(11) root.right = Node(9) root.left.left = Node(7) root.right.left = Node(15) root.right.right = Node(8) return root
def buildTree(inOrder, preOrder, inStrt, inEnd): if (inStrt > inEnd): return None tNode = Node(preOrder[buildTree.preIndex]) buildTree.preIndex += 1 if inStrt == inEnd: return tNode inIndex = search(inOrder, inStrt, inEnd, tNode.data) tNode.left = buildTree(inOrder, preOrder, inStrt, inIndex - 1) tNode.right = buildTree(inOrder, preOrder, inIndex + 1, inEnd) return tNode
def buildUtil(In, post, inStrt, inEnd, pIndex): if inStrt > inEnd: return None node = Node(post[pIndex[0]]) pIndex[0] -= 1 if inStrt == inEnd: return node iIndex = search(In, inStrt, inEnd, node.data) node.right = buildUtil(In, post, iIndex + 1, inEnd, pIndex) node.left = buildUtil(In, post, inStrt, iIndex - 1, pIndex) return node
def inorder_traversal_example(): tree = BinaryTree() n1 = Node('a') n2 = Node('+') n3 = Node('*') n4 = Node('b') n5 = Node('-') n6 = Node('/') n7 = Node('c') n8 = Node('d') n9 = Node('e') n6.left = n7 n6.right = n8 n5.left = n6 n5.right = n9 n3.left = n4 n3.right = n5 n2.left = n1 n2.right = n3 tree.root = n2 return tree
def test_bst(self): # Test printing self.assertEqual( "11 (6 (4 (None, 5), 8 (None, 10)), 19 (17, 43 (31, 49)))", str(bst)) self.assertEqual("8 (None, 10)", str(bst.left.right)) # Test no input print test_bst = Node() self.assertEqual("0", str(test_bst)) # Test negative numbers test_bst = Node(3) test_bst.insert(-8) test_bst.insert(2) self.assertEqual("3 (-8 (None, 2), None)", str(test_bst)) # Test inserting test_bst = Node(12) self.assertEqual("12", str(test_bst)) # Adding a a few numbers bigger than the root test_bst.insert(13) test_bst.insert(16) test_bst.insert(29) self.assertEqual("12 (None, 13 (None, 16 (None, 29)))", str(test_bst)) # Test inserting existing node test_bst.insert(13) self.assertEqual("12 (None, 13 (None, 16 (None, 29)))", str(test_bst)) # Test inserting with same value as root test_bst = Node(65) test_bst.insert(65) self.assertEqual("65", str(test_bst)) # Test inserting when root is None test_bst = Node(None) test_bst.insert(5) self.assertEqual("5", str(test_bst)) # Test invalid inputs test_bst = Node("TEST") self.assertEqual(None, test_bst.value) test_bst = Node(14) test_bst.insert("TEST") self.assertEqual("14", str(test_bst)) test_bst.insert(23.6) self.assertEqual("14", str(test_bst)) # Test inserting 0 test_bst.insert(0) self.assertEqual("14 (0, None)", str(test_bst))
import random from BinaryTree import Node def sum_root_to_leaf(root, cur_path_num, sum): if not root.left and not root.right: cur_path_num = cur_path_num * 10 + root.value print '+', cur_path_num sum += cur_path_num return sum cur_path_num = cur_path_num * 10 + root.value if root.left: sum = sum_root_to_leaf(root.left, cur_path_num, sum) if root.right: sum = sum_root_to_leaf(root.right, cur_path_num, sum) return sum # Is it possible to do this iteratively? def sum_root_to_leaf_iter(): pass if __name__ == '__main__': root = Node(1, left=Node(2, left=Node(4), right=Node(1, right=Node(6))), right=Node(3, right=Node(5))) print sum_root_to_leaf(root, 0, 0)
if root.left.value <= root.value: left_valid = valid_BST(root.left) if root.right: print root.value, '<=', root.right.value if root.right.value >= root.value: right_valid = valid_BST(root.right) return left_valid and right_valid if __name__ == '__main__': BST2 = Node(value=5, left=Node(value=2, left=Node(value=1), right=Node(value=3) ), right=Node(value=9, left=Node(value=7), right=Node(value=16, right=Node(value=15) ) ) ) print valid_BST(BST) print valid_BST(BST2) print valid_BST(root)
from BinaryTree import BinaryTree, Node tree = BinaryTree() tree.createRootNode(2, None, None) tree.root.left = Node(7, None, None) tree.root.left.left = Node(2, None, None) tree.root.left.right = Node(6, None, None) tree.root.left.right.left = Node(5, None, None) tree.root.left.right.right = Node(11, None, None) tree.root.right = Node(5, None, None) tree.root.right.right = Node(9, None, None) tree.root.right.right.left = Node(4, None, None) # ************************************************************************************************************************ def postorder(node): if (node == None): return postorder(node.left) postorder(node.right) print(str(node.val)) # ************************************************************************************************************************ print("\n********** POST-ORDER-TRAVERSAL **********\n") postorder(tree.root) print("\n******************\n")
from BinaryTree import Node import numpy as np xs = [i for i in range(100)] root = Node() for x in xs: root.insert(x) root.PrintTree() if (root.DFS(5)): print("Found 5") if (root.recursive_search(5)): print("Found 5 (recursively)")