def convert(nums, j, k):
if j <= k:
mid = (j + k) // 2
node = TreeNode(nums[mid])
node.left = convert(nums, j, mid - 1)
node.right = convert(nums, mid + 1, k)
return node
def test_e1(self):
n1 = TreeNode(1)
n2 = TreeNode(2)
n2.left = n1
self.assertEqual(2, solution.lowestCommonAncestor(n2, n2, n1).val)
def deleteNode(self, root: TreeNode, key: int) -> TreeNode:
if root is None:
return None
if key < root.val:
root.left = self.deleteNode(root.left, key)
return root
elif key > root.val:
root.right = self.deleteNode(root.right, key)
return root
else:
if root.left is None and root.right is None:
return None
elif root.left is not None and root.right is None:
return root.left
elif root.left is None and root.right is not None:
return root.right
else:
node, parent = self._find_min_node_parent(root.right, None)
if parent:
parent.left = node.right
node.left = root.left
if root.right is not node:
node.right = root.right
return node
def bst(lo, hi):
if lo <= hi:
mid = (lo + hi) // 2
node = TreeNode(nums[mid])
node.left = bst(lo, mid - 1)
node.right = bst(mid + 1, hi)
return node
def build(inorder_start, inorder_end):
if inorder_start <= inorder_end:
cur_val = preorder[self.preorder_ix]
node = TreeNode(cur_val)
inorder_ix = inoder_ix_map[cur_val]
self.preorder_ix += 1
node.left = build(inorder_start, inorder_ix - 1)
node.right = build(inorder_ix + 1, inorder_end)
return node
def insert(root, x):
if not root:
return TreeNode(x)
if (x < root.val):
root.left = insert(root.left, x)
root.left_count += 1
else:
root.right = insert(root.right, x);
return root
def insertIntoBST(self, root: Optional[TreeNode],
val: int) -> Optional[TreeNode]:
if not root:
return TreeNode(val)
if val < root.val:
root.left = self.insertIntoBST(root.left, val)
else:
root.right = self.insertIntoBST(root.right, val)
return root
def test_solution(self):
n3 = TreeNode(3)
n9 = TreeNode(9)
n20 = TreeNode(20)
n15 = TreeNode(15)
n7 = TreeNode(7)
n20.left = n15
n20.right = n7
n3.left = n9
n3.right = n20
self.assertEqual([[3], [9, 20], [15, 7]], s.levelOrder(n3))
def test1(self):
for f in functions:
root = list_to_tree([6,2,8,0,4,7,9,None,None,3,5])
self.assertEqual(f(root, TreeNode(3), TreeNode(7)).val, 6, f.__name__)
def test_solution(self):
n3 = TreeNode(3)
n9 = TreeNode(9)
n20 = TreeNode(20)
n15 = TreeNode(15)
n7 = TreeNode(7)
n20.left = n15
n20.right = n7
n3.left = n9
n3.right = n20
self.assertEqual(3, s.maxDepth(n3))
def test_solution(self):
n0 = TreeNode(0)
n2 = TreeNode(2)
n3 = TreeNode(3)
n4 = TreeNode(4)
n5 = TreeNode(5)
n6 = TreeNode(6)
n7 = TreeNode(7)
n8 = TreeNode(8)
n9 = TreeNode(9)
n4.left = n3
n4.right = n5
n2.left = n0
n2.right = n4
n8.left = n7
n8.right = n9
n6.left = n2
n6.right = n8
self.assertEqual(6, solution.lowestCommonAncestor(n6, n2, n8).val)
self.assertEqual(2, solution.lowestCommonAncestor(n6, n2, n4).val)
def test_e1(self):
root = TreeNode(1)
root.left = TreeNode(1)
self.assertFalse(solution.isValidBST(root))