class Solution(object): def is_balanced(self, root: TreeNode): if not root: return True return self.traverse(root) != -1 def traverse(self, node): if not node: return 0 left = self.traverse(node.left) if left == -1: return -1 right = self.traverse(node.right) if right == -1: return -1 if abs(left - right) > 1: return -1 return max(left, right) + 1 if __name__ == "__main__": import sys sys.path.append("..") from playground.TreePlayground import BinaryTreeUtil root = BinaryTreeUtil.build_tree([1, 1, 1, 1, 1, None, 1]) BinaryTreeUtil.pretty_print_tree(root) soln = Solution() print(soln.is_balanced(root))
res.append(None) return res.append(node.val) self._encode(node.left, res) self._encode(node.right, res) def deserialize(self, data): if not data: return None self.i = 0 self.data = data return self._decode() def _decode(self): if self.data[self.i] is None: self.i += 1 return None root = TreeNode(self.data[self.i]) self.i += 1 root.left = self._decode() root.right = self._decode() return root if __name__ == "__main__": codec = Codec() root = BinaryTreeUtil.build_tree([1,2,3,4,5,6,7,8]) BinaryTreeUtil.pretty_print_tree(root) encode = codec.serialize(root) print(encode) root = codec.deserialize(encode) BinaryTreeUtil.pretty_print_tree(root)
class Solution(object): def vertical_sum(self, root): import collections self.leftmost = self.rightmost = 0 self.res_dict = collections.Counter() self.traverse(root, 0) res = [] for x in range(self.leftmost, self.rightmost + 1): res.append(self.res_dict[x]) print(res) def traverse(self, node, x): if not node: return self.res_dict[x] += node.val self.leftmost = min(self.leftmost, x) self.rightmost = max(self.rightmost, x) self.traverse(node.left, x - 1) self.traverse(node.right, x + 1) if __name__ == "__main__": import sys sys.path.append("../../") from playground.TreePlayground import BinaryTreeUtil root = BinaryTreeUtil.build_tree([3, 9, 8, 4, 0, 1, 7]) soln = Solution() soln.vertical_sum(root) BinaryTreeUtil.pretty_print_tree(root)
import sys sys.path.append("../../") from playground.TreePlayground import BinaryTreeUtil, TreeNode root = BinaryTreeUtil.build_tree([1, 2, 3]) BinaryTreeUtil.pretty_print_tree(root) print("=====") def double_tree(node: TreeNode): if not node: return left_child = node.left node.left = TreeNode(node.val) node.left.left = left_child double_tree(left_child) double_tree(node.right) double_tree(root) BinaryTreeUtil.pretty_print_tree(root)
elif node.left and node.right: predecessor = self.pick_predecessor(node) if node == parent.left: parent.left = predecessor else: parent.right = predecessor predecessor.right = node.right if predecessor == node.left: predecessor.left = node.left def pick_predecessor(self, node): parent = node node = node.left while node.right: parent = node node = node.right if node == parent.left: parent.left = None else: parent.right = None print(parent.val, node.val) return node def get_root(self): return self.root bst = BinarySearchTree([1, 2, 3, 4, 7, 6, 5, 9, 8]) BinaryTreeUtil.pretty_print_tree(bst.get_root()) bst.delete_node(7) BinaryTreeUtil.pretty_print_tree(bst.get_root())
def vertical_order_2(self, root: TreeNode): import collections if not root: return [] leftmost = rightmost = 0 res_dict = collections.defaultdict(list) dq = collections.deque([[0, root]]) while dq: x, node = dq.popleft() leftmost = min(leftmost, x) rightmost = max(rightmost, x) res_dict[x].append(node.val) if node.left: dq.append([x - 1, node.left]) if node.right: dq.append([x + 1, node.right]) res = [] for x in range(leftmost, rightmost + 1): res.append(res_dict[x]) print(res) if __name__ == "__main__": import sys sys.path.append("../") from playground.TreePlayground import BinaryTreeUtil root = BinaryTreeUtil.build_tree([3, 9, 8, 4, 0, 1, 7]) soln = Solution() soln.vertical_order_2(root)