Leetcode刷题Day2

Leetcode刷题Day2
16.爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

• 示例：输入：n = 2 输出：2 解释：有两种方法可以爬到楼顶。
  1. 1 阶 + 1 阶
  2. 2 阶

class Solution:
    def climbStairs(self, n: int) -> int:
        if n== 0 or n == 1:return 1
        else:return self.climbStairs(n-1) + self.climbStairs(n-2)

以上超出时间限制，f(n)只与f(n-1)和f(n-2)项有关，改为下面：

class Solution:
    def climbStairs(self, n: int) -> int:
        a,b = 0, 1
        for _ in range(n):
            a, b = b, a+b
        return b

17.合并两个有序数组
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

• 示例：输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
  输出：[1,2,2,3,5,6] 解释：需要合并 [1,2,3] 和 [2,5,6] 。 合并结果是 [1,2,2,3,5,6]

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        nums1[m:] = nums2
        nums1.sort()
        return nums1

18.二叉树的中序遍历
给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

• 示例：输入：root = [1,null,2,3] 输出：[1,3,2]

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root is None:
            return []
        result = []
        result += self.inorderTraversal(root.left)
        result.append(root.val)
        result += self.inorderTraversal(root.right)
        return result

扩展：

1. 二叉树的先序遍历

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root is None:
            return []
        result = []
        result.append(root.val)
        result += self.inorderTraversal(root.left)
        result += self.inorderTraversal(root.right)
        return result

2. 二叉树的后序遍历

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root is None:
            return []
        result = []
        result += self.inorderTraversal(root.left)
        result += self.inorderTraversal(root.right)
        result.append(root.val)
        return result

19.相同的树
给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

• 示例：输入：p = [1,2,3], q = [1,2,3] 输出：true

class Solution:
    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
        if not p and not q: return True
        if not p or not q: return False
        if p.val != q.val: return False
        return self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)

20.对称二叉树
给你一个二叉树的根节点 root ， 检查它是否轴对称。

• 示例：输入：root = [1,2,2,3,4,4,3] 输出：true

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

21.二叉树的最大深度
给定一个二叉树 root ，返回其最大深度。
二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

• 示例：输入：root = [3,9,20,null,null,15,7] 输出：3

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root: return 0
        left_depth = self.maxDepth(root.left)
        right_depth = self.maxDepth(root.right)
        return max(left_depth, right_depth) + 1 

22.将有序数组转换为二叉搜索树
给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵平衡二叉搜索树。

• 示例：输入：nums = [-10,-3,0,5,9] 输出：[0,-3,9,-10,null,5]
  解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案。

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
        return self.arrayToTree(nums, 0, len(nums))

    def arrayToTree(self, nums, start, end):
        if start >= end: return None
        mid = (start + end) // 2
        node = TreeNode(nums[mid])
        node.left = self.arrayToTree(nums, start, mid)
        node.right = self.arrayToTree(nums, mid+1, end)
        return node

23.平衡二叉树
给定一个二叉树，判断它是否是平衡二叉树。

• 示例：输入：root = [3,9,20,null,null,15,7] 输出：true

class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        if not root: return True
        left_height = self.height_tree(root.left)
        right_tree = self.height_tree(root.right)
        return abs(left_height - right_tree) <= 1 and self.isBalanced(root.left) and self.isBalanced(root.right)
        

    def height_tree(self, root):
        if not root: return 0
        left_depth = self.height_tree(root.left)
        right_depth = self.height_tree(root.right)
        return max(left_depth, right_depth) + 1

24.二叉树最小深度
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。

• 示例：输入：root = [3,9,20,null,null,15,7] 输出：2

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if not root: return 0
        if not root.left and not root.right: return 1
        if not root.left: return self.minDepth(root.right) + 1
        if not root.right: return self.minDepth(root.left) + 1
        return min(self.minDepth(root.left), self.minDepth(root.right)) + 1