LeetCode题集三（Python实现）

最新推荐文章于 2024-08-05 15:41:47 发布
最新推荐文章于 2024-08-05 15:41:47 发布
阅读量260 收藏 1
点赞数 1
分类专栏： LeetCode 文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bansme/article/details/108539838
版权

LeetCode题集三

简单题

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: TreeNode, q: TreeNode) -> bool:
        # 当同一个位置都为空的时候，返回True
        if not p and not q:
            return True

        # 深度优先
        if p and q and p.val==q.val:
            l = self.isSameTree(p.left, q.left)
            r = self.isSameTree(p.right, q.right)
            return l and r
        
        # 剩余的情况均为False
        return False

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

        return self.cmp_node(root.left, root.right)

    def cmp_node(self, node_1, node_2):
        if not node_1 and not node_2:
            return True
        elif not node_1 or not node_2:
            return False
        elif node_1.val != node_2.val:
            return False
        return self.cmp_node(node_1.left, node_2.right) and self.cmp_node(node_1.right, node_2.left)
  • 迭代
class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:

        if not root:
            return True

        # 使用队列
        queue = collections.deque()
        queue.append((root.left,root.right))

        while queue:
            left, right = queue.popleft()
            if not left and not right:
                continue
            if not left or not right:
                return False
            if left.val != right.val:
                return False
            queue.append((left.left, right.right))
            queue.append((left.right, right.left))
            
        return True

104. 二叉树的最大深度

题目：
在这里插入图片描述

思路：

递归：深度优先，如果不为空的话，深度至少是1，递归查找左右子结点可以得到答案；
迭代：广度优先，将一排结点加入到队列中然后查找他们是否存在直接点来进行计算。

解法：

  • 递归（DFS）
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def maxDepth(self, root: TreeNode) -> int:

        if not root:
            return 0

        left = 1 + self.maxDepth(root.left)
        right = 1 + self.maxDepth(root.right)

        return max(left, right)
  • 迭代（BFS）
    # BFS
    def maxDepth(self, root):

        if not root:
            return 0

        res = 0
        queue = [root]

        while queue:

            for _ in range(len(queue)):
                node = queue.pop(0)
                if node.left:
                    queue.append((node.left))
                if node.right:
                    queue.append((node.right))

            res += 1

        return res

107. 二叉树的层次遍历 II

题目：
在这里插入图片描述

思路：

递归：参考了别人的实现，主要还是深度优先实现。
迭代：与球二叉树的最大深度类似，不过最后需要的是结点的值，而不是整个结点。

解法：

  • 递归
# 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: TreeNode) -> List[List[int]]:
        res = []
        
        def dfs(root, depth):
            if not root:
                return []
            if len(res) < depth+1:
                res.append([])
            res[depth].append(root.val)
            dfs(root.left, depth+1)
            dfs(root.right, depth+1)
            
        dfs(root, 0)

        return res[::-1]
  • 迭代
class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []

        queue = [root]
        res = []

        while queue:

            node_values = []

            for _ in range(len(queue)):

                node = queue.pop(0)
                if node.left:
                    queue.append((node.left))
                if node.right:
                    queue.append((node.right))

                node_values.append(node.val)

            # 插在前面一层的前面
            res.insert(0, node_values)

        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: List[int]) -> TreeNode:

        if not nums:
            return None

        mid = len(nums) // 2

        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid+1:])

        return root

110. 平衡二叉树

题目：
在这里插入图片描述

思路：

递归：计算左右子树，如果左右子树是平衡二叉树的话，再看他们的左右子树

解法：

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

class Solution:
       
    # 计算二叉树深度
    def cal_height(self, root):  
        if not root:
            return 0
        return max(self.cal_height(root.left), self.cal_height(root.right)) + 1

    def isBalanced(self, root):

        if not root:
            return True

        if abs(self.cal_height(root.left) - self.cal_height(root.right)) <= 1:
            # 判断两个子树是否都是平衡二叉树
            return self.isBalanced(root.left) and self.isBalanced(root.right)  
        else:
            return False

111. 二叉树的最小深度

题目：
在这里插入图片描述

思路：

递归：子结点为空的时候为0，子结点非空的时候为1，其他情况递归。
迭代：和层次遍历类似，一层层向下遍历，当某个结点左右子结点都为空的时候，可以跳出循环返还这个深度了。

解法：

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

# 递归
class Solution:
    def minDepth(self, root: TreeNode) -> int:

        if not root:
            return 0
        if not root.left and not root.right:
            return 1            
        res = inf
        if root.left:
            res = min(res, self.minDepth(root.left))
        if root.right:
            res = min(res, self.minDepth(root.right))
            
        return res+1
  • 迭代：
class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0

        res = 1
        queue = [root]

        while queue:

            for i in range(len(queue)):
                node = queue.pop(0)

                if node.left:
                    queue.append(node.left)

                if node.right:
                    queue.append(node.right)

                if not node.left and not node.right:
                    return res
            
            res += 1

        return res

112. 路径总和

题目：
在这里插入图片描述

思路：

递归遍历，通过逐渐减少sum值去比较。
迭代也是一样的思路，不过得使用一个栈。

解法：

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

class Solution:
    def hasPathSum(self, root: TreeNode, sum: int) -> bool:

        if not root:
            return 0

        if not root.left and not root.right:
            return root.val == sum    
        
        return self.hasPathSum(root.left, sum - root.val) or self.hasPathSum(root.right, sum - root.val)
  • 迭代
class Solution:
    def hasPathSum(self,root,sum):
        if not root:
            return False
        stack = [(root,sum)]
        while stack:
            node, val = stack.pop()
            if not node.left and not node.right and node.val == val:
                return True
            if node.right:
                stack.append((node.right,val-node.val))
            if node.left:
                stack.append((node.left,val-node.val))
        return False

119. 杨辉三角 II

题目：
在这里插入图片描述
在这里插入图片描述

思路：

暴力破解：按照给的规律直接暴力求解
巧妙求解：参考了别人的答案，可以错位相加求解

解法：

  • 暴力求解
class Solution:
    def generate(self, numRows: int) -> List[List[int]]:

        if not numRows:
            return []

        res = [[1]]

        for i in range(1, numRows):
            tmp = [1, 1]

            for j in range(1, i):
                num = res[i - 1][j - 1] + res[i - 1][j]
                tmp.insert(j, num)

            res.append(tmp)

        return res
  • 巧妙求解
    在这里插入图片描述
class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        if numRows == 0: 
        	return []
        res = [[1]]
        while len(res) < numRows:
            newRow = [a+b for a, b in zip([0]+res[-1], res[-1]+[0])]
            res.append(newRow)      
        return res

119. 杨辉三角 II

题目：
在这里插入图片描述
思路：

在上那个一题的基础上修改实现。

解法：

class Solution:
    def getRow(self, rowIndex: int) -> List[int]:

        res = [[1]]

        while len(res) <= rowIndex:
            newRow = [a + b for a, b in zip([0]+res[-1], res[-1]+[0])]
            res.append(newRow)      
        return res[rowIndex]
bansme
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
LeetCode 题集：字典树
星海浮生
11-10 5098
LeetCode 208. Implement Trie (Prefix Tree)（实现 Trie (前缀树)） 211. Design Add and Search Words Data Structure（添加与搜索单词 - 数据结构设计） 212. Word Search II（单词搜索 II）
leetcode题库-LeetCode_Python:LeetCode算法题Python实现
06-29
而 `LeetCode_Python` 则是这个庞大题库的一个Python实现版本，为Python爱好者提供了一个学习和实践算法的好机会。 Python，作为一种简洁易读、功能强大的编程语言，被广泛应用于各种领域，包括数据分析、Web开发、...
LeetCode题集四（Python实现）
bansme的博客
09-16 282
LeetCode题集四简单题121. 买卖股票的最佳时机 简单题 121. 买卖股票的最佳时机 题目： 思路： 先将第一个值默认是最小的价钱，之后依次查找后面的价格，进行对比获取最小价格和最大收益。 解法： class Solution: def maxProfit(self, prices: List[int]) -> int: if len(prices) < 2: return 0 res = 0
LeetCode题集五（Python实现）
bansme的博客
09-17 303
LeetCode题集四简单题171. Excel表列序号 简单题 171. Excel表列序号 题目： 思路： 26进制转10进制。 解法： class Solution: def titleToNumber(self, s: str) -> int: if not s: return 0 n = len(s) res = 0 for i in range(n):
LeetCode题集二（Python实现）
bansme的博客
09-11 222
LeetCode题集二简单题35. 搜索插入位置38. 外观数列 简单题 35. 搜索插入位置 题目： 思路： 主要有两个思路： 将目标数直接插入，然后使用sort()方法排序后，再用index()查找目标数的位置； 直接遍历数组，查找相应位置。 解法： 插入后查找位置 class Solution: def searchInsert(self, nums: List[int], target: int) -> int: if not nums:
LeetCode题集一（Python实现）
bansme的博客
09-08 338
LeetCode题集简单1. 两数之和7. 整数反转 简单 1. 两数之和 给定一个整数数组nums和一个目标值target请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] 解法： 原本想用列表来实现的，不过比较消耗时间，参考了大神们的答案，发
LeetCode 题集：栈和队列
星海浮生
11-08 244
LeetCode 232. Implement Queue using Stacks（用栈实现队列） 225. Implement Stack using Queues（用队列实现栈） 150. Evaluate Reverse Polish Notation（逆波兰表达式求值） 71. Simplify Path（简化路径） 155. Min Stack（最小栈） 20. Valid Parentheses（有效的括号）
LeetCode 题集：哈希表
星海浮生
10-22 205
LeetCode 1. Two Sum（两数之和） 290. Word Pattern（单词规律） 49. Group Anagrams（字母异位词分组） 205. Isomorphic Strings（同构字符串） 166. Fraction to Recurring Decimal（分数到小数）
LeetCode 题集：深度优先搜索（DFS）、广度优先搜索（BFS）
星海浮生
11-03 360
LeetCode 110. Balanced Binary Tree（平衡二叉树） 111. Minimum Depth of Binary Tree（二叉树的最小深度） 112. Path Sum（路径总和） 113. Path Sum II（路径总和 II） 102. Binary Tree Level Order Traversal（二叉树的层序遍历）
解leetcode题集....持续更新中
qq_33535433的博客
03-10 422
1.给定一个数组nums，写一个函数将数组中的所有0挪到数组末尾而且维持其他所有非零元素相对位置不变 举例:nums[3,7,0,6,0,3,2] 函数运行后结果为nums=[3,7,6,3,2,0,0] public class Solution { public static void swap(int[] nums,int a,int b){ int t...
leetcode全套解答python版本
03-29
《LeetCode 全套解答 Python 版本》 在编程领域，LeetCode 是一个非常知名的在线平台，它提供了丰富的算法题目，旨在帮助开发者提升编程技能、理解和掌握数据结构与算法。Python，作为一门广泛使用的编程语言，因其...
leetcode:leetcode 题集
05-11
引言 欢迎大家 fork and star 时间线 2019-06-01 至 2019-08-17 leetcode 300题, 主要集中树, 回溯, 数组, 字符串, 贪心, 动态规划几个专题。...leetcode 600题, 主要是leetcode 周赛和虚拟竞赛, 周赛(2-3)/4, 虚
135. 分发糖果【 力扣(LeetCode) 】
yyh520025的博客
08-04 807
n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目。
(leetcode学习)50. Pow(x, n)
最新发布
m0_54888411的博客
08-05 231
快速幂，第一次写的时候用 n%2==1，这样不能处理负数的问题。
5力扣：最长回文子串
m0_75015083的博客
08-02 258
从后到前遍历是为了让每一次遍历时所需用到的子串提前被计算过。
LeetCode 572.另一棵树的子树 C写法
m0_63816268的博客
08-02 231
可以用上的方法，，如果有一轮比较成功就表示root包含subroot。
leetcode数论(​3044. 出现频率最高的质数)-质数判断
磐门的博客
08-04 684
经过前期的基础训练以及部分实战练习，粗略掌握了各种题型的解题思路。现阶段开始专项练习。
Leetcode 第 135 场双周赛题解
ProgramNovice的博客
08-03 875
Leetcode 第 135 场双周赛题解
苏大Python复试上机：LeetCode高频题集——英语字母顺序挑战
在苏州大学的Python复试上机环节，学生可能会被要求解决一系列来自LeetCode的编程问题，以检验他们的编程能力和对Python的理解。这些题目涵盖了多个主题，包括但不限于字符串处理、数组操作、哈希表应用、数学算法、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值