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 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 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 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 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 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(): 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 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 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 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 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 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 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
from BinaryTree import Node
def depthBinaryTree(root):
if root is None:
return 0
return max(depthBinaryTree(root.left), depthBinaryTree(root.right)) + 1
if __name__ == "__main__":
root = Node(27)
root.left = Node(14)
root.right = Node(35)
root.left.left = Node(10)
root.left.right = Node(19)
root.right.left = Node(31)
root.right.right = Node(42)
root.left.left.left = Node(45)
print("Inorder:")
print(*root.inorderTraversal(root))
print(f"Depth: {depthBinaryTree(root)}")
else:
return None
# O(n)
def isChildNode(node, n1):
if node == None:
return False
if node.obj is n1.obj:
return True
return isChildNode(node.left, n1) or isChildNode(node.right, n1)
tree = Node("0")
tree.left = Node("1")
tree.right = Node("2")
tree.left.left = Node("3")
tree.left.right = Node("4")
tree.right.left = Node("5")
tree.right.right = Node("6")
tree.right.right.left = Node("10")
tree.right.right.right = Node("7")
tree.right.right.right.right = Node("8")
BinaryTree.print(tree)
node = get_Smallest_Common_Ancestor(tree, tree.right,
tree.right.right.right.right)
print("Smalest common ancestor: {}".format(node.obj))
getListOfDepths(root.left, listOfHeads, depth + 1)
getListOfDepths(root.right, listOfHeads, depth + 1)
setLinkedList(root, listOfHeads, depth)
def printListOfLinkedLists(listOfLL):
returnStr = ""
for node in listOfLL:
while node != None:
returnStr += str(node.nodeData) + " "
node = node.nextNode
returnStr += '\n'
print(returnStr)
if __name__ == "__main__":
n0 = TreeNode(0)
n1 = TreeNode(1)
n2 = TreeNode(2)
n3 = TreeNode(3)
n4 = TreeNode(4)
n5 = TreeNode(5)
n6 = TreeNode(6)
n0.left = n1
n0.right = n2
n1.left = n3
n1.right = n4
n2.left = n5
n2.left = n6
depth = getDepth(n0)
listOfHeads = [None] * depth
getListOfDepths(n0, listOfHeads, 0)
printListOfLinkedLists(listOfHeads)
from BinaryTree import Node
def areMirrors(root1, root2):
if root1 is None and root2 is None:
return True
if root1 is None or root2 is None:
return False
return root1.data == root2.data and areMirrors(root1.left, root2.right) and areMirrors(root1.right, root2.left)
if __name__ == "__main__":
root1 = Node(1)
root2 = Node(1)
root1.left = Node(2)
root1.right = Node(3)
root1.left.left = Node(4)
root1.left.right = Node(5)
root2.left = Node(3)
root2.right = Node(2)
root2.right.left = Node(5)
root2.right.right = Node(4)
print("Inorder (Tree1):")
print(*root1.inorderTraversal(root1))
print("Inorder (Tree2):")
print(*root2.inorderTraversal(root2))
print(areMirrors(root1, root2))
def isBalancedInternal(root):
if root == None:
return -1
else:
leftTree = isBalancedInternal(root.left)
rightTree = isBalancedInternal(root.right)
difference = leftTree - rightTree
if abs(difference) > 1:
raise Exception("Binary Tree is not balanced")
else:
return max(isBalancedInternal(root.left),
isBalancedInternal(root.right)) + 1
if __name__ == "__main__":
n0 = TreeNode(0)
n1 = TreeNode(1)
n3 = TreeNode(3)
n0.left = n1
n0.right = n3
# Un-comment to get an unbalanced tree
# n4 = TreeNode(4)
# n5 = TreeNode(5)
# n3.right = n4
# n4.right = n5
print(isBalanced(n0))
from BinaryTree import Node
# Driver program to test the binary tree functions
# Let us create the following BST
# 8
# / \
# 3 10
# / \ / \
# 1 6 60 80
# / \ \
# 4 7 14
# /
# 13
bTree = Node(8)
bTree.left = Node(3)
bTree.right = Node(10)
bTree.left.left = Node(1)
bTree.left.right = Node(6)
bTree.left.right.left = Node(4)
bTree.left.right.right = Node(7)
bTree.right.right = Node(14)
bTree.right.right.left = Node(13)
def search(root, key, traverse=False):
if traverse:
print(root.val)
if root == None:
return root
if root.val == key:
return root
"""
Here is where we practice Binary Trees
"""
from BinaryTree import Node;
root = Node("root");
root.left = Node("left child");
root.right = Node("right child");
