python leetcode 101-110

# 101
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        def match(left , right):
            if not left and not right:
                return True
            if not left or not right:
                return False
            return left.val == right.val and match(left.left , right.right) and match(left.right , right.left)
        return match(root.left , root.right)

# 102
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root):
        if not root:
            return []
        res = []
        def helper(root , depth):
            if not root:
                return
            if depth == len(res):
                res.append([])
            res[depth].append(root.val)
            helper(root.left , depth + 1)
            helper(root.right , depth + 1)
        helper(root , 0)
        return res

# 103
class Solution:
    def zigzagLevelOrder(self, root):
        if not root:
            return []
        res = []
        def helper(root , depth):
            if not root:
                return
            if len(res) == depth:
                res.append([])
            if depth % 2 == 0:
                res[depth].append(root.val)
            else:
                res[depth].insert(0 , root.val)
            helper(root.left , depth + 1)
            helper(root.right , depth + 1)
        helper(root , 0)
        return res
            

# 104
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxDepth(self, root):
        if not root:
            return 0
        l , r = self.maxDepth(root.left) , self.maxDepth(root.right)
        return max(l , r) + 1

# 105
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def buildTree(self, preorder, inorder):
        if not inorder: return
        root = TreeNode(preorder.pop(0))
        i = inorder.index(root.val)
        root.left = self.buildTree(preorder, inorder[:i])
        root.right = self.buildTree(preorder, inorder[i+1:])
        return root

# 106
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def buildTree(self, inorder, postorder):
        if not inorder: return
        root = TreeNode(postorder.pop(-1))
        i = inorder.index(root.val)
        root.right = self.buildTree(inorder[i+1:],postorder)
        root.left = self.buildTree(inorder[:i],postorder)
        return root

# 107
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrderBottom(self, root):
        if not root:
            return []
        res = []
        def helper(root , depth):
            if not root: return
            if len(res) == depth:
                res.insert(0 , [])
            res[-depth - 1].append(root.val)
            helper(root.left , depth + 1)
            helper(root.right , depth + 1)
        helper(root , 0)
        return res

# 108
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def sortedArrayToBST(self, nums):
        if not nums: return
        mid = len(nums) // 2
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid+1:])
        return root

# 109
class Solution:
        def sortedListToBST(self, head: ListNode) -> TreeNode:
            nums=[]
            p=head
            while p:
                nums.append(p.val)
                p=p.next
            def sortedArrayToBST(nums):
                if not nums:
                    return 
                mid = len(nums)//2
                root=TreeNode(nums[mid])
                root.left=sortedArrayToBST(nums[:mid])
                root.right=sortedArrayToBST(nums[mid+1:])
                return root
            return sortedArrayToBST(nums)

# 110
class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        def height(root: TreeNode) -> int:
            if not root:
                return 0
            leftHeight = height(root.left)
            rightHeight = height(root.right)
            if leftHeight == -1 or rightHeight == -1 or abs(leftHeight - rightHeight) > 1:
                return -1
            else:
                return max(leftHeight, rightHeight) + 1

        return height(root) >= 0