【1】Leetcode简单题合集 python

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: Optional[TreeNode]) -> int:
        if root==None:
            return 0
        else:
            return max(self.maxDepth(root.left), self.maxDepth(root.right))+1

100. 相同的树

# 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 isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
        # 以相同的方式同时遍历两棵二叉树
        # 返回false：遇到有值的节点时，如果值不相等 / 或者其中一个为空另一个不为空 

        # 先审视一下根节点
        if p==None and q==None: #同时为空是可以的
            return True
        if p==None or q==None: #一个为空，另一个不空，这不行
            return False
        if p.val!=q.val: #如果上边两种情况都没有返回，那俩都不为空，此时如果值不相等，这不行
            return False
        
        #根节点暂且满足条件（都不为空且值相等），接下来检查一下左右子树的返回情况
        left = self.isSameTree(p.left, q.left)
        right = self.isSameTree(p.right, q.right)
        # 左右必须完全一样才能返回True
        if left and right:
            return True
        else:
            return False

101. 对称二叉树

• 上一个题是两棵树，每个树上配备一个遍历指针
• 两个指针始终往同方向走，一旦不一样了就返回false
• 对比一下这个题，只给了一颗树，我们可以想象拷贝出来一个完全一样的树
• 也是用两个指针分别遍历树，只不过两个指针是往反方向走
• 两个指针是同步进行的，所以一定是同时出现在函数中被使用（原则）

# 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 copyTrees(self, p, q): 
        # p指向左子树的根节点，q指向右子树的根节点
        # 刚开始root节点p、q指向相同，相当于左右重合，此时也是满足对称的
        if p==None and q==None:
            return True
        if p==None or q==None:
            return False
        if p.val!=q.val:
            return False
        
        # 根节点暂时满足条件（都不为空且值相等），接下来检查左右子树的返回情况
        p_left = self.copyTrees(p.left, q.right) # 以p的左为基准，和q的右对比
        p_right = self.copyTrees(p.right, q.left) # 以p的右为基准，和q的左对比
        if p_left and p_right:
            return True
        else:
            return False

    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        res = self.copyTrees(root, root)  # 在这个函数里实现和上题类似的过程
        return res

226. 翻转二叉树

# 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 invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if root==None:
            return None
        # 其他只要是非空的节点，我们就等着返回交换后的左右子树
        left = self.invertTree(root.right)
        right = self.invertTree(root.left)
        root.left = left
        root.right = right
        return root

509. 斐波那契数

# 动态规划
class Solution:
    def fib(self, n: int) -> int:
        dp = [0] * (n+5) 
        dp[0],dp[1] = 0,1
        for i in range(2,n+1):
            dp[i] = dp[i-1]+dp[i-2]
        return dp[n]
# 递归
class Solution:
    def fib(self, n: int) -> int:
        if n==0 or n==1:
            return n
        else: 
            return self.fib(n-1)+self.fib(n-2)

118. 杨辉三角

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        dp = []
        dp.append([1])

        if numRows==1:    
            return dp

        for i in range(1, numRows): #从第二行开始
            pre = dp[i-1]
            cur = []
            cur.append(pre[0])
            for j in range(0, len(pre)-1):
                cur.append(pre[j]+pre[j+1])
            cur.append(pre[-1])
            dp.append(cur)

        return dp

674. 最长连续递增序列

• 动态规划，dp[i] 表示以 i 结尾的当前最长递增序列长度
  

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        dp = [1] * len(nums) 
        maxLen = 1

        for i in range(1, len(nums)):
            if nums[i]>nums[i-1]:
                dp[i] = dp[i-1]+1
            maxLen = max(maxLen, dp[i])
        
        return maxLen

【本题进阶的类似题目可以看中等题合集中的53和300这两个题】

---

持续更新中……