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)