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 __init__(id=0,
left=None,
right=None,
value=None,
parent=None,
next=None):
TreeNode.__init__(self, id, left, right, value, parent)
self.next = next # next right child on the same level
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 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 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 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 convert2BST_link(node, start, end):
if start > end or node is None:
return None, node
mid = (start + end) // 2
left_tree, node = convert2BST_link(node, start, mid - 1)
root = TreeNode(value=node.value)
node = node.next
right_tree, node = convert2BST_link(node, mid + 1, end)
root.left = left_tree
root.right = right_tree
return root, node
def convert2BST_link(node, start, end):
if start > end or node is None:
return None, node
mid = (start+end)//2
left_tree, node = convert2BST_link(node, start, mid-1)
root = TreeNode(value = node.value)
node = node.next
right_tree, node = convert2BST_link(node, mid+1, end)
root.left = left_tree
root.right = right_tree
return root, node
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 build_print_tree(self, node):
if node.leaf is not True:
root = BNode('x' + str(node.x))
if node.rchild is not None:
root.right = self.build_print_tree(node.rchild)
if node.lchild is not None:
root.left = self.build_print_tree(node.lchild)
return root
else:
root = BNode('+' if node.boolean_value == 1 else '-')
return root
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 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 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 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 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 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 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 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 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 _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_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 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 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
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")
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
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)")
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)
def __init__(id=0,
left=None, right=None,
value=None, parent=None,
next=None):
TreeNode.__init__(self, id, left, right, value, parent)
self.next = next # next right child on the same level
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)
def main():
file = open(sys.argv[1], "rb")
byte_dict = {}
total = 0
#Count frequencies
try:
byte = file.read(1)
while byte != "":
total += 1
if byte_dict.get(byte) is None:
byte_dict[byte] = 1
else:
byte_dict[byte] += 1;
byte = file.read(1)
finally:
file.close()
byte_list = sorted(byte_dict.items(), key=lambda x: x[1])
trees = []
for char, count in byte_list:
node = Node((char, count))
trees.append(node)
#perform Huffman code algorithm by joining Binary Trees together
while(len(trees) > 1):
start_len = len(trees) - 2
first = trees[0]
second = trees[1]
count = second.val[1] + first.val[1]
val = ("None", count)
node = Node(val)
if second.val[1] > first.val[1]:
node = node.set_left(first)
node = node.set_right(second)
else:
node = node.set_left(second)
node = node.set_right(first)
trees = trees[2:]
for tree in trees:
if (tree.val[1] > count):
ind = trees.index(tree)
trees.insert(ind, node)
break
if (len(trees) == start_len):
trees.append(node)
print len(trees)
trees[0].to_string()
codes = recursive_dfs(trees[0], "")
with open('code.txt', 'wb') as outfile:
json.dump(codes, outfile)
