def test_solution(self):
for nums, p, q, answer in self.test_case:
root = TreeNode.create(nums)
p = TreeNode(p)
q = TreeNode(q)
ans = self.s.lowestCommonAncestor(root, p, q)
self.assertEqual(answer, ans.val)
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.increasingBST(root)
# self.assertEqual(answer,ans )
while ans is not None:
print(ans.val)
print(ans.left)
ans = ans.right
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.connect(root)
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.convertBST(root)
self.assertEqual(TreeNode.literal(ans), answer)
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.findBottomLeftValue(root)
self.assertEqual(answer, ans)
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.deepestLeavesSum(root)
self.assertEqual(answer,ans , (nums, answer))
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.zigzagLevelOrder(root)
print(ans)
self.assertEqual(answer, ans)
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
answer = TreeNode.create(answer)
ans = self.s.invertTree(root)
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.largestValues(root)
self.assertEqual(answer, ans)
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.rightSideView(root)
self.assertEqual(answer, ans)
def test_solution(self):
for nums, val, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.insertIntoBST(root, val)
self.assertEqual(answer, TreeNode.literal(ans))
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.preorderTraversal(root)
self.assertEqual(answer, ans)
def test_solution(self):
for pp, qq, answer in self.test_case:
p = TreeNode.create(pp)
q = TreeNode.create(qq)
ans = self.s.isSameTree(p, q)
self.assertEqual(answer, ans)
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.getMinimumDifference(root)
self.assertEqual(answer, ans)
def test_solution(self):
for nums, target, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.delNodes(root, target) # TODO
def test_solution(self):
for nums, low, high, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.rangeSumBST(root, low, high)
self.assertEqual(answer, ans)
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.widthOfBinaryTree(root)
self.assertEqual(answer, ans)
def test_solution(self):
for nums, target, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.hasPathSum(root, target)
self.assertEqual(answer, ans)
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.isSymmetric(root)
self.assertEqual(answer, ans)
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.maxAncestorDiff(root)
self.assertEqual(answer, ans, (nums, answer))
def test_solution(self):
for nums1, nums2, answer in self.test_case:
root1 = TreeNode.create(nums1)
root2 = TreeNode.create(nums2)
ans = self.s.flipEquiv(root1, root2)
self.assertEqual(answer, ans)
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.minDiffInBST(root)
self.assertEqual(answer, ans)
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.pruneTree(root)
self.assertEqual(answer, TreeNode.literal(ans))
def test_solution(self):
for nums, answer in self.test_case:
root = TreeNode.create(nums)
ans = self.s.levelOrder(root)
