leetcode刷题周记（二）

最新推荐文章于 2023-05-03 20:09:07 发布
最新推荐文章于 2023-05-03 20:09:07 发布
阅读量144 收藏
点赞数 1
分类专栏： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wszhou1997/article/details/102923276
版权

题目编号： 88、100、101、104、107、108、110、111、112
88. 合并两个有序数组
我的解法：
合并后排序

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None Do not return anything, modify nums1 in-place instead.
        """
        for i in range(m,m+n):
            nums1[i] = nums2[i-m]
     	nums1.sort()
        return nums1

题解思路：
双指针法：
1.从前往后：
将指针p1 置为 nums1的开头， p2为 nums2的开头，在每一步将最小值放入输出数组中。
由于 nums1 是用于输出的数组，需要将nums1中的前m个元素放在其他地方，也就需要 O(m) 的空间复杂度，时间复杂度为O(m+n)

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: void Do not return anything, modify nums1 in-place instead.
        """
        # Make a copy of nums1.
        nums1_copy = nums1[:m] 
        nums1[:] = []
        # Two get pointers for nums1_copy and nums2.
        p1 = 0 
        p2 = 0
        
        # Compare elements from nums1_copy and nums2
        # and add the smallest one into nums1.
        while p1 < m and p2 < n: 
            if nums1_copy[p1] < nums2[p2]: 
                nums1.append(nums1_copy[p1])
                p1 += 1
            else:
                nums1.append(nums2[p2])
                p2 += 1
        # if there are still elements to add
        if p1 < m: 
            nums1[p1 + p2:] = nums1_copy[p1:]
        if p2 < n:
            nums1[p1 + p2:] = nums2[p2:]

2.从后往前：
从前往后已经取得了最优的时间复杂度O(n+m)，但需要使用额外空间。这是由于在从头改变nums1的值时，需要把nums1中的元素存放在其他位置。
如果我们从结尾开始改写 nums1 的值又会如何呢？这里没有信息，因此不需要额外空间。
这里的指针 p 用于追踪添加元素的位置。

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: void Do not return anything, modify nums1 in-place instead.
        """
        # two get pointers for nums1 and nums2
        p1 = m - 1
        p2 = n - 1
        # set pointer for nums1
        p = m + n - 1
           # while there are still elements to compare
        while p1 >= 0 and p2 >= 0:
            if nums1[p1] < nums2[p2]:
                nums1[p] = nums2[p2]
                p2 -= 1
            else:
                nums1[p] =  nums1[p1]
                p1 -= 1
            p -= 1
        # add missing elements from nums2
        nums1[:p2 + 1] = nums2[:p2 + 1]

100. 相同的树
我的解法：
首先判断 p 和 q 是不是 None，然后判断它们的值是否相等。
若以上判断通过，则递归对子结点做同样操作。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution(object):
    def isSameTree(self, p, q):
        """
        :type p: TreeNode
        :type q: TreeNode
        :rtype: 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)

101. 对称二叉树
我的解法：
递归。
递归结束条件：
都为空指针则返回 true
只有一个为空则返回 false
递归过程：
判断两个指针当前节点值是否相等
判断 A 的右子树与 B 的左子树是否对称
判断 A 的左子树与 B 的右子树是否对称
短路：
在递归判断过程中存在短路现象，也就是做 与 操作时，如果前面的值返回 false 则后面的不再进行计算
时间复杂度：O(n)

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

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        def check(node1,node2):
            if not node1 and not node2:
                return True
            elif not node1 or not node2:
                return False
            
            if node1.val != node2.val:
                return False
            
            return check(node1.left,node2.right) and check(node1.right,node2.left)
        return check(root,root)

104. 二叉树的最大深度
我的解法：
递归
若当前结点为空，则返回0；若当前节点不为空，则返回左右子树的最大深度+1

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

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        
        return 1 + max(self.maxDepth(root.left),self.maxDepth(root.right))

107. 二叉树的层次遍历 II
解法思路：

class Solution:
    def levelOrderBottom(self, root):
        queue = []                                                  # 结果列表
        cur = [root]                                                # 接下来要循环的当前层节点，存的是节点
        while cur:                                                  # 当前层存在结点时
            cur_layer_val = []                                      # 初始化当前层结果列表为空，存的是val
            next_layer_node = []                                    # 初始化下一层结点列表为空
            for node in cur:                                        # 遍历当前层的每一个结点
                if node:                                            # 如果该结点不为空，则进行记录
                    cur_layer_val.append(node.val)                  # 将该结点的值加入当前层结果列表的末尾
                    next_layer_node.extend([node.left, node.right]) # 将该结点的左右孩子结点加入到下一层结点列表
            if cur_layer_val:                                       # 只要当前层结果列表不为空
                queue.insert(0, cur_layer_val)                      # 则把当前层结果列表插入到队列首端
            cur = next_layer_node                                   # 下一层的结点变成当前层，接着循环
        return queue                                                # 返回结果队列

python实现树的遍历操作

108. 将有序数组转换为二叉搜索树
我的解法：
递归+二分法
1.平衡二叉搜索树的特点是：每个节点的左右子树都高度差在1以内，每个节点左子树小于右子树。
2.根据平衡二叉搜索树的特点，可以联想到，每个节点当做根节点的时候，左子树形成的数组一定比它小，右子树形成的数组一定比他大。因此，符合有序数组任意子数组中点的性质。
3.结合树结构常用的递归思想，可以采用DFS，递归构建这颗树，为了实现每个节点都是平衡二叉搜索树，可以递归二分数组来分配资源，左面的构建左子树，右面的构建右子树，以此递归。

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

class Solution(object):
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        if nums is None:
            return
        start = 0
        end = len(nums) - 1
        if start > end:
            return
        mid = (start + end) >> 1
        print("mid:",mid)
        print("nums[mid]:",nums[mid])
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[start:mid])
        root.right = self.sortedArrayToBST(nums[mid+1:end+1])
        return root

110. 平衡二叉树
我的解法：
从底至顶（提前阻断法）
对二叉树做深度优先遍历DFS，递归过程中：
终止条件：当DFS越过叶子节点时，返回高度0；
返回值：
（1）从底至顶，返回以每个节点root为根节点的子树最大高度(左右子树中最大的高度值加1max(left,right) + 1)；
（2）当我们发现有一例 左/右子树高度差 ＞ 1 的情况时，代表此树不是平衡树，返回-1；
当发现不是平衡树时，后面的高度计算都没有意义了，因此一路返回-1，避免后续多余计算。
最差情况是对树做一遍完整DFS，时间复杂度为 O(N)。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution(object):
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        return self.depth(root) != -1
    
    def depth(self,root):
        if not root: return 0
        left = self.depth(root.left)
        if left == -1: return -1
        right = self.depth(root.right)
        if right == -1: return -1
        return max(left,right) + 1 if abs(left - right) < 2 else -1

111. 二叉树的最小深度
我的解法：
分治法：
判断左右两棵子树的最小深度，比较两个的最小值
注意：最小深度的定义是要到最近的叶子结点，所以如果一棵子树没有任何结点，那么最小值是另一棵子树的深度
故步骤：
1.日常判断当前结点是否为空，同时也是递归的终止条件
2.判断如果一棵子树没有任何结点，则最小值是另一棵子树的深度
3.若两棵子树都有结点，则最小值是两颗子树深度的最小值

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

class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        if not root.left or not root.right:
            return self.minDepth(root.left) + self.minDepth(root.right) + 1
        return min(self.minDepth(root.left),self.minDepth(root.right)) + 1

112. 路径总和
我的解法：
遍历整棵树：如果当前节点不是叶子，对它的所有孩子节点，递归调用 hasPathSum 函数，其中 sum 值减去当前节点的权值；如果当前节点是叶子，检查 sum 值是否为 0，也就是是否找到了给定的目标和。

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

class Solution(object):
    def hasPathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: bool
        """
        if not root:
            return False
        
        sum -= root.val
        
        if not root.left and not root.right:
            return (sum == 0)
        
        return self.hasPathSum(root.left,sum) or self.hasPathSum(root.right,sum)
wszhou1997
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题笔记.rar
07-05
在LeetCode中，常见的算法题型涉及排序（快速排序、归并排序、堆排序等）、搜索（二分查找、深度优先搜索、广度优先搜索等）、动态规划、贪心算法、回溯法、分治法等。动态规划通常用于解决最优化问题，如背包问题、...
LeetCode刷题模板.pdf
04-05
1.4. LeetCode中二分查找题目 29 2. 双指针 30 2.1. 快慢指针 31 2.1.1. 什么是快慢指针 31 2.1.2. 快慢指针模板 31 2.1.3. 快慢指针相关题目 32 2.1.3.1. LC-141:链表是否有环 32 2.1.3.2. LC-142:环形链表入口 34 ...
LeetCode打卡27——合并两个有序数组
qq_39894692的博客
09-12 134
给定两个有序整数数组nums1 和 nums2，将 nums2 合并到nums1中，使得num1 成为一个有序数组。 说明: 初始化nums1 和 nums2 的元素数量分别为m 和 n。 你可以假设nums1有足够的空间（空间大小大于或等于m + n）来保存 nums2 中的元素。 示例: 输入: nums1 = [1,2,3,0,0,0], m = 3 nums2 = ...
leetcode刷题周记-2021.11.14~2021.11.20
zombotany的博客
11-20 253
leetcode刷题周记-2021.11.14~2021.11.202021.11.14-键值映射题面文字分析代码2021.11.15-灯泡开关题面文字分析代码2021.11.16-完美矩形题面文字分析代码2021.11.17-最大单词长度乘积题面文字分析代码2021.11.18-二叉树的坡度题面文字分析代码2021.11.19-整数替换题面文字分析代码2021.11.20-最长和谐子序列题面文字分析代码自我总结 2021.11.14-键值映射 题面 实现一个 MapSum 类，支持两个方法，insert
leetcode刷题周记（四）
wszhou1997的博客
11-25 107
题目编号： 155、160、167、168、169、171、172 155. 最小栈 我的解法： 同步双栈法，data栈存储数据，helper栈存储最小值 初始化：将两个栈均初始为空 入栈：data栈先入栈，若helper栈为空或当前入栈元素值小于helper栈顶元素（即当前入栈元素为最小值），则元素入helper栈，否则helper当前栈顶元素再次入helper栈 出栈：若栈不空，则helper...
leetcode刷题周记（五）
wszhou1997的博客
12-09 125
11. 盛最多水的容器 我的解法： 这种方法背后的思路在于，两线段之间形成的区域总是会受到其中较短那条长度的限制。 此外，两线段距离越远，得到的面积就越大。 我们在由线段长度构成的数组中使用两个指针，一个放在开始，一个置于末尾。 此外，我们会使用变量 maxarea 来持续存储到目前为止所获得的最大面积。 在每一步中，我们会找出指针所指向的两条线段形成的区域，更新 maxarea，并将指向较短线段...
leetcode刷题周记（一）
wszhou1997的博客
11-05 153
题目编号： 26、27、28、35、38、53、58、66、67、69、70、83 26.删除排序数组中的重复项： 我的解法：设置一个偏移量变量Offset用来记录重复的元素个数，length记录不重复的元素。遍历一次数组，若当前元素与下一个元素相同，则偏移量Offset加一；若当前元素与下一个元素不同，则Offset不变，length加一；循环每执行一次当前元素向前移动Offset位，即可实现覆...
leetcode刷题周记（三）
wszhou1997的博客
11-18 149
题目编号： 118、119、121、122、125、136 118. 杨辉三角 我的解法： 两个数组，now用来记录当前行数据，pre用来记录上一行的数据 首先对每一行设为全1，根据杨辉三角的特点，从第三行起，第二个元素开始，到倒数第二个元素为止，当前元素i等于上一行的i-1号元素和i号元素的和 class Solution(object): def generate(self, numR...
leetcode刷题周记-2021.11.21-2021.11.28
zombotany的博客
11-28 315
11.21-559. N 叉树的最大深度 题面 给定一个 N 叉树，找到其最大深度。 最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。 N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/maximum-depth-of-n-ary-tree 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 思路 没什么好说的，dfs/bfs板子题。 要点 图论 dfs/
C++刷题周记（一）
funkoctopus的博客
04-23 188
把C++重拾起来系统刷题的第一周（4.16-4.23），也是同时为了复习数据结构与准备夏令营机试。计划着主要是结合Acwing算法基础课的章节进行，同时也会穿插二刷之前用Java刷过的力扣题。
C++刷题周记(二)——Trie树/KMP
funkoctopus的博客
05-03 144
五一前这一周在忙一些比赛的事情，刷题不多，且内容也还没有完成整理，先挖个坑。
（C++）LeetCode刷题题解答案
02-20
（C++）LeetCode刷题题解答案
leetcode刷题账号-LeetCode:LeetCode刷题记录(C#)
07-06
这个压缩包文件"LeetCode-master"很可能包含了某个用户在刷题过程中的代码记录或者解决方案。 在刷LeetCode的过程中，有几个关键知识点是值得深入探讨的： 1. **基础数据结构**：在LeetCode的题目中，常见数据结构...
LeetCode 刷题笔记 with Java.zip
11-23
第二部分的暗黑版《LeetCode 刷题笔记 with Java 1-50（暗黑版）.pdf》可能提供了更加深入或非主流的解法，鼓励读者从不同角度思考问题，挑战自己的思维极限。 接着是《LeetCode 刷题笔记 with Java 51-100.pdf》，...
pi_heif-0.17.0-cp310-cp310-manylinux_2_17_aarch64.whl
07-27
pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。
Numper基础（一）
07-27
Numper基础（一）
C语言写的潮流计算大作业代码.zip
最新发布
07-27
c写的潮流计算大作业代码.zipc写的潮流计算大作业代码.zipc写的潮流计算大作业代码.zip
关于大模型的教程、调用和使用技巧的资源，帮助更多人高效地认知和使用大模型.docx
07-27
大模型（Large Models），尤其是指预训练的大规模语言模型，在自然语言处理（NLP）、计算机视觉（CV）等领域取得了显著的进步。以下是一些关于大模型的教程、调用和使用技巧的资源，帮助更多人高效地认知和使用大模型： 1. 大模型教程资源 官方文档： 大多数大型模型都会在其官方网站或GitHub页面上发布详细的文档，包括模型介绍、安装指南、使用示例等。 例如，Hugging Face的Transformers库提供了丰富的文档和教程。 在线课程： Coursera、edX等在线教育平台上提供了关于大模型的课程。 例如，斯坦福大学的NLP课程通常会涵盖最新的大模型技术。 博客文章： Medium、Towards Data Science等平台上有很多关于大模型的文章，这些文章通常由专业人士撰写，包含实战经验和技巧。 视频教程： B站（bilibili.com）和YouTube上有很多关于大模型的教程视频，适合初学者入门。 2. 调用API和使用技巧 Hugging Face Transformers： 提供了多种预训练模型的加载和调用方式。 Hugging Face文档 是一个非常
LeetCode刷题攻略：二分法与双指针模板
"LeetCode刷题模板.pdf" 这篇文档主要涵盖了LeetCode刷题中常见的两种算法模板——二分法和双指针法，并提供了相应的代码模板、关键属性和具体题目的应用示例。以下是对这两种方法的详细解释： 1. 二分法 - 什么...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值