def buildTree(preorder, inorder):
if inorder:
ind = inorder.index(preorder.pop(0))
root = Node(inorder[ind])
root._left = buildTree(preorder, inorder[0:ind])
root._right = buildTree(preorder, inorder[ind + 1:])
return root
def build_tree_from_array(A, start, end):
if start > end:
return
mid = (start + end) / 2
root = Node(A[mid])
root.left = build_tree_from_array(A, start, mid - 1)
root.right = build_tree_from_array(A, mid + 1, end)
return root
def getCountNodesInLevel(node: Node, level):
if not Node:
return 0
if level == 0:
return 1
return getCountNodesInLevel(node.getLeftNode(),
level - 1) + getCountNodesInLevel(
node.getRightNode(), level - 1)
def merge_bst(bst1, bst2):
merge = []
s1 = bst1.inorder().copy()
s2 = bst2.inorder().copy()
while s1 and s2:
if s1[0] <= s2[0]:
merge.append(s1.pop(0))
else:
merge.append(s2.pop(0))
new_root = Node(merge.pop(0))
while merge:
new_root.insert(merge.pop(0))
return new_root
def remove(self, node: Node):
if not node.leftChild and not node.rightChild:
if node.isleftchild():
node.parent.leftChild = None
else:
node.parent.rightChild = None
self.rebalance(node.parent)
elif node.leftChild and not node.rightChild:
if node.parent is None:
node.leftChild.parent = None
self.root = node.leftChild
elif node.isleftchild():
node.leftChild.parent = node.parent
node.parent.leftChild = node.leftChild
else:
node.leftChild.parent = node.parent
node.parent.rightChild = node.leftChild
self.rebalance(node.parent)
elif node.rightChild and not node.leftChild:
if node.parent is None:
node.rightChild.parent = None
self.root = node.rightChild
elif node.isleftchild():
node.rightChild.parent = node.parent
node.parent.leftChild = node.rightChild
else:
node.rightChild.parent = node.parent
node.parent.rightChild = node.rightChild
self.rebalance(node.parent)
else:
successor = self.find_successor(node)
node.key = successor.key
node.payload = successor.payload
self.remove(successor)
def addIterative(self, value):
newNode = Node(value)
if (self._root is None):
self._root = newNode
return
current = self._root
parent = None
while True:
parent = current
if (value == current._item):
return
if (value < current._item):
current = current._left
if (current is None):
parent._left = newNode
return
else:
current = current._right
if (current is None):
parent._right = newNode
return
def insert(self, key):
'''
:param key:
insert node with value key at first available position in level order traversal
:return:None
'''
node = Node(key)
if self.root is None:
self.root = node
return
queue = [self.get_root()]
while queue:
this_node = queue.pop(0)
if this_node.left is not None:
queue.append(this_node.left)
else:
this_node.left = node
break
if this_node.right is not None:
queue.append(this_node.right)
else:
this_node.right = node
break
def pair_sum_in_array(array, x):
"""Check whether there is a pair of numbers in sorted array with sum = x."""
l = 0
r = len(array) - 1
while l < r:
if array[l] + array[r] == x:
return True
elif array[l] + array[r] < x:
l += 1
else:
r -= 1
return False
def sum_in_bst(tree, x):
"""Find whether there is a pair of numbers in Binary Search Tree with sum = x."""
return pair_sum_in_array(tree.inorder(), x)
if __name__ == "__main__":
root1 = Node(50)
root1.insert(30)
root1.insert(20)
root1.insert(40)
root1.insert(70)
root1.insert(60)
root1.insert(80)
print(sum_in_bst(root1, 50))
print(sum_in_bst(root1, 150))
print(sum_in_bst(root1, 250))
pass
find_in_range(range_begin, range_end, node.right)
# Main
if __name__ == "__main__":
tree = BinarySearchTree()
keys_in_range = []
# Insert some random-looking integers into the tree.
user_values = input('Enter values to be inserted separated by spaces: ')
print()
for value in user_values.split():
new_node = Node(value)
tree.insert(new_node)
# print('Initial tree:')
# print(tree)
# print()
# Read in range values and starting node's key
range_begin = input()
range_end = input()
s_node = input()
# Find starting node in tree
start_node = BinarySearchTree.search(tree, s_node)
# Find keys in range from starting node
merge = []
s1 = bst1.inorder().copy()
s2 = bst2.inorder().copy()
while s1 and s2:
if s1[0] <= s2[0]:
merge.append(s1.pop(0))
else:
merge.append(s2.pop(0))
new_root = Node(merge.pop(0))
while merge:
new_root.insert(merge.pop(0))
return new_root
if __name__ == "__main__":
root1 = Node(50)
root1.insert(30)
root1.insert(20)
root1.insert(40)
root1.insert(70)
root1.insert(60)
root1.insert(80)
root2 = Node(150)
root2.insert(130)
root2.insert(12)
root2.insert(30)
root2.insert(10)
root2.insert(10)
root2.insert(10)
print(merge_bst(root1, root2).inorder())
# coding=utf-8
"""Fix Binary Search Tree with two swapped nodes."""
from BinarySearchTree import Node
def fix_tree(tree):
traversal = tree.inorder_object_traversal()
vals = [x.key for x in traversal]
vals.sort()
for x in range(len(vals)):
traversal[x].key = vals[x]
if __name__ == "__main__":
root1 = Node(50)
root1.insert(30)
root1.insert(20)
root1.insert(40)
root1.insert(70)
root1.insert(60)
root1.insert(80)
tr = root1.inorder_object_traversal()
tr[2].key, tr[5].key = tr[5].key, tr[2].key
print(root1.inorder())
fix_tree(root1)
print(root1.inorder())