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)")
