def make_example(): root = TreeNode(3) root.left = TreeNode(9) root.right = TreeNode(20) root.right.left = TreeNode(15) root.right.right = TreeNode(7) return root
def insertIntoMaxTree(self, root: TreeNode, val: int) -> TreeNode: if root is None or root is not None and root.val < val: node = TreeNode(val) node.left = root return node root.right = self.insertIntoMaxTree(root.right, val) return root
def make_example_2(): root = TreeNode(5) root.left = TreeNode(1) root.right = TreeNode(4) root.right.left = TreeNode(3) root.right.right = TreeNode(6) return root
def make_example_1(): root = TreeNode(1) root.left = TreeNode(2) root.right = TreeNode(2) root.left.left = TreeNode(3) root.left.right = TreeNode(4) root.right.left = TreeNode(4) root.right.right = TreeNode(3) return root
def sortedArrayToBST(self, nums: List[int]) -> TreeNode: if nums: nums_left, middle, nums_right = nums[:len(nums) // 2], nums[len(nums) // 2], nums[len(nums) // 2 + 1:] tree = TreeNode(middle) tree.left = self.sortedArrayToBST(nums_left) tree.right = self.sortedArrayToBST(nums_right) return tree
def sortedArrayToBST(self, nums: List[int]) -> TreeNode: length = len(nums) if length == 0: return None else: idx = length // 2 node = TreeNode(nums[idx]) node.left = self.sortedArrayToBST(nums[:idx]) node.right = self.sortedArrayToBST(nums[idx + 1:]) return node
def construct_tree(nums, left, right): if left >= right: return None max_i = left for index in range(left + 1, right): if nums[index] > nums[max_i]: max_i = index node = TreeNode(nums[max_i]) node.left = construct_tree(nums, left, max_i) node.right = construct_tree(nums, max_i + 1, right) return node
def sortedArrayToBST(self, nums): """ :type nums: List[int] :rtype: TreeNode """ if nums is None or len(nums) == 0: return None mid_index = len(nums) >> 1 node = TreeNode(nums[mid_index]) node.left = self.sortedArrayToBST(nums[:mid_index]) node.right = self.sortedArrayToBST(nums[mid_index + 1:]) return node
def sortedArrayToBST(self, num): if not num: return None if len(num) % 2 == 0: mid = len(num)/2 - 1 else: mid = (len(num)+1)/2 - 1 root = TreeNode(num[mid]) root.left = self.sortedArrayToBST(num[:mid]) root.right = self.sortedArrayToBST(num[mid+1:]) return root
def sortedListToBST(self, head: ListNode) -> TreeNode: if not head: return None elif not head.next: return TreeNode(head.val) else: slow = fast = head pre = None while fast and fast.next: pre = slow slow = slow.next fast = fast.next.next node = TreeNode(slow.val) pre.next = None node.left = self.sortedListToBST(head) node.right = self.sortedListToBST(slow.next) return node
def buildTree(self, inorder, postorder): """ :type inorder: List[int] :type postorder: List[int] :rtype: TreeNode """ def find(l, v): for index, ele in enumerate(l): if ele == v: return index return -1 if len(postorder) == 0 or len(inorder) == 0: return None node = TreeNode(postorder[-1]) index = find(inorder, postorder[-1]) node.left = self.buildTree(inorder[:index], postorder[:index]) node.right = self.buildTree(inorder[index + 1:], postorder[index:-1]) return node
sums.append(self.dfsSum(root.left, root.val)) if root.right != None: sums.append(self.dfsSum(root.right, root.val)) return sum(sums) def dfsSum(self, root, cursum): ret = [] cursum = cursum * 10 + root.val if not root.left and not root.right: return cursum if root.left != None and root.right != None: return self.dfsSum(root.left, cursum) + self.dfsSum(root.right, cursum) if root.left != None and not root.right: return self.dfsSum(root.left, cursum) if root.right != None and not root.left: return self.dfsSum(root.right, cursum) sol = Solution() t = TreeNode(8) t.left = TreeNode(3) t.right = TreeNode(5) t.left.right = TreeNode(9) t.left.right.left = TreeNode(9) t.left.right.right = TreeNode(5) print sol.sumNumbers(t)
# @param q, a tree node # @return a boolean def isSameTree(self, p, q): if not bool(p): if not bool(q): return True else: return False if not bool(q): if not bool(p): return True else: return False if p.val == q.val: return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right) else: return False sol = Solution() print sol.isSameTree({}, {0}) pTree = TreeNode(2) pTree.left = TreeNode(1) pTree.right = TreeNode(3) qTree = TreeNode(2) qTree.left = TreeNode(1) qTree.right = TreeNode(3) print sol.isSameTree(pTree, qTree)
# @param root, a tree node # @return an integer def maxDepth(self, root): if not bool(root): return 0 if root.left == None: if root.right == None: return 1 else: return 1 + self.maxDepth(root.right) elif root.right == None: if root.left == None: return 1 else: return 1 + self.maxDepth(root.left) else: return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right)) testRoot = TreeNode(5) testRoot.left = TreeNode(3) testRoot.right = TreeNode(8) testRoot.left.left = TreeNode(2) testRoot.left.right = TreeNode(4) testRoot.right.left = TreeNode(7) testRoot.right.left.left = TreeNode(6) sol = Solution() print sol.maxDepth(testRoot) print sol.maxDepth({})