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");