class Tree(object):
from binarytree import heap
root = heap()
print('Max-heap of any height : \n', root)
root2 = heap(height=2)
print('Max-heap of given height : \n', root2)
root3 = heap(height=2, is_max=False, is_perfect=True)
print('Perfect min-heap of given height : \n', root3)
def test_heap():
for invalid_height in ['foo', -1]:
with pytest.raises(ValueError) as err:
heap(height=invalid_height)
assert str(err.value) == 'Height must be a non-negative integer'
# Test heap generation with height of 0
for _ in range(repetitions):
root = heap(height=0)
assert attr(root, 'left') is None
assert attr(root, 'right') is None
assert isinstance(attr(root, 'value'), int)
assert inspect(root)['height'] == 0
assert inspect(root)['is_min_heap'] is True
assert inspect(root)['is_max_heap'] is True
for _ in range(repetitions):
height = randint(1, 10)
root = heap(height)
nodes_to_visit = [root]
while nodes_to_visit:
node = nodes_to_visit.pop()
assert isinstance(node, Node)
assert isinstance(attr(node, 'value'), int)
if attr(node, 'left') is not None:
nodes_to_visit.append(attr(node, 'left'))
if attr(node, 'right') is not None:
nodes_to_visit.append(attr(node, 'right'))
assert inspect(root)['height'] == height
assert inspect(root)['is_min_heap'] is True
for _ in range(repetitions):
height = randint(1, 10)
root = heap(height, max=True)
nodes_to_visit = [root]
while nodes_to_visit:
node = nodes_to_visit.pop()
assert isinstance(node, Node)
assert isinstance(attr(node, 'value'), int)
if attr(node, 'left') is not None:
nodes_to_visit.append(attr(node, 'left'))
if attr(node, 'right') is not None:
nodes_to_visit.append(attr(node, 'right'))
assert inspect(root)['height'] == height
assert inspect(root)['is_max_heap'] is True
def Test():
A = []
T = []
Cases = []
for i in range(1, 101):
root = heap(height=2)
A.append(root)
Cases.append(i)
for i in A:
start = time.time()
InOrderTraversal(i)
# PostOrderTraversal(i)
# PreOrderTraversal(i)
T.append(time.time() - start)
plt.plot(Cases, T, "-o")
plt.xlabel('List Cases')
plt.ylabel('List Time')
plt.title('BinaryTreeTraversals')
plt.show()
def test_heap_generation():
for invalid_height in ['foo', -1, None]:
with pytest.raises(InvalidTreeHeightError) as err:
heap(height=invalid_height)
assert str(err.value) == 'The height must be an integer between 0 - 9'
root = heap(height=0)
root.validate()
assert root.height == 0
assert root.left is None
assert root.right is None
assert isinstance(root.value, int)
for _ in range(REPETITIONS):
random_height = random.randint(1, 9)
root = heap(random_height, is_max=True)
root.validate()
assert root.is_max_heap is True
assert root.is_min_heap is False
assert root.height == random_height
for _ in range(REPETITIONS):
random_height = random.randint(1, 9)
root = heap(random_height, is_max=False)
root.validate()
assert root.is_max_heap is False
assert root.is_min_heap is True
assert root.height == random_height
for _ in range(REPETITIONS):
random_height = random.randint(1, 9)
root = heap(random_height, is_perfect=True)
root.validate()
assert root.is_max_heap is True
assert root.is_min_heap is False
assert root.is_perfect is True
assert root.is_balanced is True
assert root.is_strict is True
assert root.height == random_height
if depth < mindepth:
mindepth = depth
return mindepth
def minDepth(A):
q = deque()
q.append(A)
curr, nest, level = 1, 0, 1
while q:
item = q.popleft()
curr -= 1
if not item.right and not item.left:
return level
if item.right:
q.append(item.right)
nest += 1
if item.left:
q.append(item.left)
nest += 1
if curr == 0:
curr, nest = nest, curr
level += 1
a = bst()
print(a)
#a= {3, 1, -1, -1}
print(minDepth(a))
b = heap()
print(b)
from binarytree import Node, tree, bst, heap, pprint # Generate a random binary tree and return its root my_tree = tree(height=5, balanced=True) # Generate a random BST and return its root my_bst = bst(height=5) # Generate a random max heap and return its root my_heap = heap(height=3, max=True) # Pretty print the trees in stdout #pprint(my_tree) #pprint(my_bst) #pprint(my_heap) root = Node(1) root.left = Node(2) root.right = Node(3) root.left.left = Node(4) root.left.right = Node(5) pprint(root)
yield node.value
if node.left is not None:
queue.append(node.left)
if node.right is not None:
queue.append(node.right)
if __name__ == '__main__':
# Generate a random binary tree and return its root node.
my_tree = tree(height=3, is_perfect=False)
# Generate a random BST and return its root node.
my_bst = bst(height=3, is_perfect=True)
# Generate a random max heap and return its root node.
my_heap = heap(height=3, is_max=True, is_perfect=False)
# Pretty-print the trees in stdout.
#print(my_tree)
#print(my_bst)
print(my_bst[12].value, my_bst[9].value,
[my_bst[i].value for i in range(15)])
del my_bst[9]
#del my_bst[10]
del my_bst[12]
print(my_bst)
#my_bst.pprint(index=True)
print(my_bst.inorder)
#print(my_bst.preorder)
#print(my_bst.postorder)
#print(*[n.value for n in my_bst.levelorder])
from binarytree import tree, bst, heap, build
import networkx as nx
my_tree1 = tree(height=0)
my_tree1list = list(my_tree1)
print(my_tree1list)
print(my_tree1)
my_tree2 = tree(height=1, is_perfect=True)
print(my_tree2.value)
my_tree3 = tree(height=3, is_perfect=False)
my_heap = heap(height=3)
print(my_tree1)
print(my_tree2)
print(my_tree3)
print(my_heap)
root = None
print(root.inorder)
values = [
10, 12, 14, 24, 39, 50, 54, 62, 67, 92, 134, 153, 161, 162, 167, 171, 172,
173, 191, 193, 197, 205, 206, 208, 210, 211, 222, 239, 240, 246, 249, 253,
263, 270, 286, 299, 303, 305, 308, 316, 319, 325, 344, 349, 350, 353, 363,
365, 371, 395, 414, 437, 453, 459, 463, 489, 500, 503, 512, 514, 515, 516,
518, 530, 553, 558, 573, 574, 578, 586, 590, 602, 607, 618, 636, 638, 647,
676, 690, 691, 716, 761, 767, 798, 811, 815, 836, 843, 849, 867, 882, 903,
919, 921, 943, 948, 958, 959, 980, 997
]
root = build(values)
tNodes[index] = newtNode
if (index % 2):
parenttNode.left = newtNode
else:
parenttNode.right = newtNode
index += 1
return tRoot
class Solution(object):
def levelOrderBotttom(self, root):
queue = [(root, 0)]
result = []
while queue:
node, level = queue.pop()
if node:
if level >= len(result):
result.insert(0, [])
result[-(level + 1)].append(node.val)
queue.insert(0, (node.left, level + 1))
queue.insert(0, (node.right, level + 1))
return result
noderoot = heap(2)
print(noderoot)
tRoot = fromNodetoTreeNode(noderoot)
solver = Solution()
result = solver.levelOrderBotttom(tRoot)
print(result)
'''
IN MAX HEAP, THE PARENT NODE HAS THE HIGHEST VALUE AND
DECREASES AS YOU GO DOWN THE BINARY TREE
'''
from binarytree import heap
root = heap(height=3, is_max=True, is_perfect=False)
print('Max-heap of height 3', root)
root2 = heap(height=3, is_max=False, is_perfect=True)
print('Min-heap of height 3', root2)
root3 = heap()
