def recursiveInsert(self, data, node):
"""
uses recursion to find the appropriate node at which a data value should be added.
:param data: desired data value to be added to the tree. (int)
:param node: root node under which to add data value. (BinaryTreeNode)
:return: None
"""
if data < node.data: # if insert data is less than current node data:
if node.left is None: # add the insert as the left child if it doesn't exist
node.left = BinaryTreeNode(data)
else: # OR move to the left child and check again
self.recursiveInsert(data, node.left)
elif data >= node.data: # if insert data is greater/equal to current node data:
if node.right is None: # add the insert as the right child if it doesn't exist
node.right = BinaryTreeNode(data)
else: # OR move to the right child and check again
self.recursiveInsert(data, node.right)
def main():
root = BinaryTreeNode(10)
root.setLeft(5)
root.setRight(6)
root.left.setLeft(1)
root.left.setRight(2)
root.right.setLeft(3)
root.right.setRight(4)
root.left.right.setLeft(7)
# test case 1: node 7 and 6 --> Common ancestor: 10
# test case 2: node 2 and 5 --> Common ancestor: 5
# test case 3: node 6 and a node not in the tree --> Common ancestor: None
tests = [(root.left.right.left, root.right), (root.left.right, root.left), (root.right, BinaryTreeNode(9))]
methods = [commonAncestor_1, commonAncestor_2]
for test in tests:
for method in methods:
if method == commonAncestor_1:
ancestor = method(test[0], test[1])
else:
ancestor = method(root, test[0], test[1])
print ancestor.value if ancestor is not None else None
def deSerialize(astr):
if len(astr)==0:
return None
alist = astr.split(',', 1)
num = alist[0]
astr = str(alist[-1])
root = None
if num != '#':
root = BinaryTreeNode.BinaryTreeNode(num)
root.left,astr = deSerialize(astr)
root.right,astr = deSerialize(astr)
return root,astr
def insert(self, data):
"""
inserts a data value into the binary tree at an appropriate location.
:param data: desired data value to be added to the tree. (int)
:return: None
"""
if self.root is None: # if there is no root, set the data point as the new root
self.root = BinaryTreeNode(data)
else:
self.recursiveInsert(data,
self.root) # recursive function to insert
self.count += 1 # after adding, add one to node count
def Test1():
pNode10 = BinaryTreeNode.BinaryTreeNode(10)
pNode6 = BinaryTreeNode.BinaryTreeNode(6)
pNode14 = BinaryTreeNode.BinaryTreeNode(14)
pNode4 = BinaryTreeNode.BinaryTreeNode(4)
pNode8 = BinaryTreeNode.BinaryTreeNode(8)
pNode12 = BinaryTreeNode.BinaryTreeNode(12)
pNode16 = BinaryTreeNode.BinaryTreeNode(16)
pNode10.connectTreeNodes(pNode10, pNode6, pNode14)
pNode6.connectTreeNodes(pNode6, pNode4, pNode8)
pNode14.connectTreeNodes(pNode14, pNode12, pNode16)
Test("test1", pNode10)
def main():
givenSum = 7
root = BinaryTreeNode(1)
root.setLeft(2)
root.setRight(3)
root.left.setLeft(4)
root.left.setRight(5)
root.right.setLeft(3)
root.right.setRight(4)
root.left.right.setLeft(7)
findSum(root, givenSum)
def binary_tree_from_preorder_inorder_helper(preorder_start, preorder_end,
inorder_start, inorder_end):
if preorder_end <= preorder_start or inorder_end <= inorder_start:
return None
root_inorder_idx = node_to_inorder_idx[preorder[preorder_start]]
left_subtree_size = root_inorder_idx - inorder_start
return BinaryTreeNode(
preorder[preorder_start],
# Recursively builds the left subtree.
binary_tree_from_preorder_inorder_helper(
preorder_start + 1, preorder_start + 1 + left_subtree_size,
inorder_start, root_inorder_idx),
# Recursively builds the right subtree.
binary_tree_from_preorder_inorder_helper(
preorder_start + 1 + left_subtree_size, preorder_end,
root_inorder_idx + 1, inorder_end))
def Test1():
pNode10 = BinaryTreeNode.BinaryTreeNode(10)
pNode6 = BinaryTreeNode.BinaryTreeNode(6)
pNode14 = BinaryTreeNode.BinaryTreeNode(14)
pNode4 = BinaryTreeNode.BinaryTreeNode(4)
pNode8 = BinaryTreeNode.BinaryTreeNode(8)
pNode12 = BinaryTreeNode.BinaryTreeNode(12)
pNode16 = BinaryTreeNode.BinaryTreeNode(16)
pNode10.connectTreeNodes(pNode10, pNode6, pNode14)
pNode6.connectTreeNodes(pNode6, pNode4, pNode8)
pNode14.connectTreeNodes(pNode14, pNode12, pNode16)
pNode10.printTree(pNode10)
print("The nodes from top to bottom, from left to right are: \n")
printTreeFromTop2(pNode10)
def Test():
pNode8 = BinaryTreeNode.BinaryTreeNode(8);
pNode6 = BinaryTreeNode.BinaryTreeNode(6);
pNode10 = BinaryTreeNode.BinaryTreeNode(10);
pNode5 = BinaryTreeNode.BinaryTreeNode(5);
pNode7 = BinaryTreeNode.BinaryTreeNode(7);
pNode9 = BinaryTreeNode.BinaryTreeNode(9);
pNode11 = BinaryTreeNode.BinaryTreeNode(11);
pNode8.connectTreeNodes(pNode8, pNode6, pNode10);
pNode6.connectTreeNodes(pNode6, pNode5, pNode7);
pNode10.connectTreeNodes(pNode10, pNode9, pNode11);
astr = serialize(pNode8)
print(astr)
root,astr = deSerialize(astr)
root.printTree(root)
def main():
root = BinaryTreeNode(10)
root.setLeft(5)
root.setRight(6)
root.left.setLeft(1)
root.left.setRight(2)
root.right.setLeft(3)
root.right.setRight(4)
root.left.right.setLeft(7)
# test case 1: node 7 and 6 --> Common ancestor: 10
# test case 2: node 2 and 5 --> Common ancestor: 5
# test case 3: node 6 and a node not in the tree --> Common ancestor: None
tests = [(root.left.right.left, root.right), (root.left.right, root.left),
(root.right, BinaryTreeNode(9))]
methods = [commonAncestor_1, commonAncestor_2]
for test in tests:
for method in methods:
if method == commonAncestor_1:
ancestor = method(test[0], test[1])
else:
ancestor = method(root, test[0], test[1])
print ancestor.value if ancestor is not None else None
def newNode(self, data):
return btn.BinaryTreeNode(data)
