【LeetCode】Top100 经典必刷题 05【5/20】

已于 2024-07-24 13:18:36 修改
阅读量490 收藏 5
点赞数 20
文章标签： python 数据结构 leetcode
于 2024-07-24 11:11:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Young_Pro/article/details/140643942
版权
21. 合并 K 个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

 

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

 

提示：

  • k == lists.length
  • 0 <= k <= 10^4
  • 0 <= lists[i].length <= 500
  • -10^4 <= lists[i][j] <= 10^4
  • lists[i] 按 升序 排列
  • lists[i].length 的总和不超过 10^4

python 参考题解：

第 21 道题是 "Merge k Sorted Lists"，题目描述如下： 合并 k 个已排序的链表并返回一个新的已排序的链表。

示例 1:

输入:
[
  1->4->5,
  1->3->4,
  2->6
]
输出: 1->1->2->3->4->4->5->6

以下是用 Python 给出的题解：

# 定义链表节点
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
def mergeKLists(lists):
    # 创建一个空栈，用于存储链表的头节点
    stack = []
    
    # 遍历每个链表，将链表的头节点添加到栈中
    for head in lists:
        if head:
            stack.append(head)
    
    # 初始化结果链表的头节点
    dummy = ListNode(0)
    current = dummy
    
    # 遍历栈，合并链表
    while stack:
        # 取出栈顶的链表头节点
        min_head = stack.pop(0)
        # 将最小头节点连接到结果链表中
        current.next = min_head
        current = current.next
        # 如果最小头节点的下一个节点不为空，则将下一个节点添加到栈中
        if min_head.next:
            stack.append(min_head.next)
    
    # 返回结果链表的头节点
    return dummy.next
# 示例
lists = [
    ListNode(1, ListNode(4, ListNode(5))),
    ListNode(1, ListNode(3, ListNode(4))),
    ListNode(2, ListNode(6))
]
result = mergeKLists(lists)
while result:
    print(result.val, end=" -> ")
    result = result.next
# 输出: 1 -> 1 -> 2 -> 3 -> 4 -> 4 -> 5 -> 6

解题思路和步骤：

  1. 创建栈：首先，我们创建一个空栈 stack，用于存储链表的头节点。
  2. 遍历链表：使用一个循环遍历每个链表，将链表的头节点添加到栈中。
  3. 初始化结果链表：创建一个哑节点 dummy 作为结果链表的头节点，并初始化一个指针 current 指向哑节点。
  4. 遍历栈：使用一个循环遍历栈，合并链表。
  5. 取出最小头节点：在循环中，我们取出栈顶的链表头节点 min_head。
  6. 连接最小头节点：将最小头节点连接到结果链表中。
  7. 更新指针：每次连接完成后，我们将 current 指针向前移动到新连接的节点。
  8. 添加下一个节点：如果最小头节点的下一个节点不为空，则将下一个节点添加到栈中。
  9. 返回结果链表：最后，我们返回哑节点的下一个节点，即新链表的头节点。

这个算法的时间复杂度是 O(k * n)，其中 k 是链表的数量，n 是链表的平均长度。空间复杂度是 O(k)，因为我们使用了栈来存储链表的头节点。

22. 两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

 

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

 

提示：

  • 链表中节点的数目在范围 [0, 100] 内
  • 0 <= Node.val <= 100

python 参考题解：

第 22 道题是 "Swap Nodes in Pairs"，题目描述如下： 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

示例 1:

输入: 1->2->3->4
输出: 2->1->4->3

以下是用 Python 给出的题解：

# 定义链表节点
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
def swapPairs(head: ListNode) -> ListNode:
    # 创建一个哑节点作为新链表的头节点
    dummy = ListNode(0)
    dummy.next = head
    current = dummy
    
    # 遍历链表，交换相邻的节点
    while current.next and current.next.next:
        # 保存第一个节点的下一个节点
        next_node = current.next.next
        # 交换第一个节点和第二个节点
        current.next.next = current.next.next.next
        next_node.next = current.next
        current.next = next_node
        # 移动到下一个交换对
        current = current.next.next
        
    # 返回新链表的头节点
    return dummy.next
# 示例
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
head.next.next.next = ListNode(4)
result = swapPairs(head)
while result:
    print(result.val, end=" -> ")
    result = result.next
# 输出: 2 -> 1 -> 4 -> 3

解题思路和步骤：

  1. 创建哑节点：首先，我们创建一个哑节点 dummy 作为新链表的头节点，并初始化一个指针 current 指向哑节点。
  2. 遍历链表：使用一个循环遍历链表，交换相邻的节点。
  3. 保存下一个节点：在循环中，我们保存第一个节点的下一个节点 next_node。
  4. 交换节点：交换第一个节点和第二个节点。
  5. 更新指针：每次交换完成后，我们将 current 指针向前移动到新交换的节点。
  6. 返回结果链表：最后，我们返回哑节点的下一个节点，即新链表的头节点。

这个算法的时间复杂度是 O(n)，其中 n 是链表的长度，因为我们只需要遍历链表一次。空间复杂度是 O(1)，因为我们只使用了常数级别的额外空间。

23. K 个一组翻转链表

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

 

示例 1：

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

示例 2：

输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]

 

提示：
  • 链表中的节点数目为 n
  • 1 <= k <= n <= 5000
  • 0 <= Node.val <= 1000

 

进阶：你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？

    python 参考题解：

    第 23 道题是 "Reverse Nodes in k-Group"，题目描述如下： 给定一个链表和整数 k，请你对链表进行分块反转，其中每个块包含 k 个节点。

    示例 1:

    输入: 1->2->3->4->5, k = 2
输出: 2->1->4->3->5

    以下是用 Python 给出的题解：

    # 定义链表节点
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
def reverseKGroup(head: ListNode, k: int) -> ListNode:
    # 创建一个哑节点作为新链表的头节点
    dummy = ListNode(0)
    dummy.next = head
    current = dummy
    
    # 遍历链表，找到需要反转的节点
    while current.next:
        # 初始化前驱节点和当前节点
        prev = current
        curr = current.next
        
        # 遍历 k 个节点，找到需要反转的最后一个节点
        for _ in range(k):
            if not curr:
                # 如果 k 个节点不足以构成一个完整的块，返回
                return dummy.next
            curr = curr.next
        
        # 反转当前块
        for _ in range(k):
            next_node = curr.next
            curr.next = prev.next
            prev.next = curr
            curr = next_node
            
        # 更新当前节点
        current.next = prev.next
        
    # 返回新链表的头节点
    return dummy.next
# 示例
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
head.next.next.next = ListNode(4)
head.next.next.next.next = ListNode(5)
result = reverseKGroup(head, 2)
while result:
    print(result.val, end=" -> ")
    result = result.next
# 输出: 2 -> 1 -> 4 -> 3 -> 5

    解题思路和步骤：

    1. 创建哑节点：首先，我们创建一个哑节点 dummy 作为新链表的头节点，并初始化一个指针 current 指向哑节点。
    2. 遍历链表：使用一个循环遍历链表，找到需要反转的节点。
    3. 初始化前驱节点和当前节点：在循环中，我们初始化前驱节点 prev 和当前节点 curr。
    4. 遍历 k 个节点：使用一个循环遍历 k 个节点，找到需要反转的最后一个节点。
    5. 反转当前块：使用一个循环反转当前块。
    6. 更新当前节点：每次反转完成后，我们将 current 指针向前移动到新反转的块的最后一个节点。
    7. 返回结果链表：最后，我们返回哑节点的下一个节点，即新链表的头节点。
      这个算法的时间复杂度是 O(n)，其中 n 是链表的长度，因为我们只需要遍历链表一次。空间复杂度是 O(1)，因为我们只使用了常数级别的额外空间。

    24. 旋转图像

    给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

    你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。

     

    示例 1：

    输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[7,4,1],[8,5,2],[9,6,3]]

    示例 2：

    输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]

     

    提示：

    • n == matrix.length == matrix[i].length
    • 1 <= n <= 20
    • -1000 <= matrix[i][j] <= 1000

     

    python 参考题解：

    第 24 道题是 "Rotate Image"，题目描述如下： 给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。

    示例 1:

    Given input matrix = 
[
  [1,2,3],
  [4,5,6],
  [7,8,9]
],
Output:
[
  [7,4,1],
  [8,5,2],
  [9,6,3]
]

    以下是用 Python 给出的题解：

    def rotate(matrix):
    # 先转置矩阵
    matrix[:] = map(list, zip(*matrix))
    # 然后反转每一行
    for i in range(len(matrix)):
        matrix[i] = matrix[i][::-1]
# 示例
matrix = [
  [1,2,3],
  [4,5,6],
  [7,8,9]
]
rotate(matrix)
for row in matrix:
    print(row)
# 输出:
# [7,4,1]
# [8,5,2]
# [9,6,3]

    解题思路和步骤：

    1. 转置矩阵：首先，我们使用 Python 的内置函数 zip 和 list 来实现矩阵的转置。转置矩阵意味着将原始矩阵的行转换为列，列转换为行。
    2. 反转每一行：然后，我们使用 Python 的切片操作符 [::-1] 来反转每一行。这意味着从最后一个元素开始，到第一个元素结束，步长为 -1，即从右到左遍历每一行。
    3. 返回结果：转置和反转完成后，原始矩阵已经被旋转了 90 度，所以不需要返回任何值。

    这个算法的时间复杂度是 O(n^2)，其中 n 是矩阵的边长，因为我们需要遍历矩阵的每一行和每一列。空间复杂度是 O(1)，因为我们只使用了常数级别的额外空间。

    25. 反转链表
    给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

     

    示例 1：

    输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

    示例 2：

    输入：head = [1,2]
输出：[2,1]

    示例 3：

    输入：head = []
输出：[]

     

    提示：

    • 链表中节点的数目范围是 [0, 5000]
    • -5000 <= Node.val <= 5000

     

    进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

    python 参考题解：

    第 206 道题是 "Reverse Linked List"，题目描述如下： 反转一个单链表。

    示例 1:

    输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

    以下是用 Python 给出的题解：

    # 定义链表节点
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
def reverseList(head: ListNode) -> ListNode:
    # 初始化三个指针，pre指向None，cur指向head，nex指向cur的下一个节点
    pre, cur, nex = None, head, head
    
    # 遍历链表，进行反转
    while cur:
        nex = cur.next  # 保存cur的下一个节点
        cur.next = pre  # 将cur的next指针指向pre
        pre = cur       # 移动pre到cur的位置
        cur = nex       # 移动cur到nex的位置
        
    # 反转完成后，pre指向新的头节点
    return pre
# 示例
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
head.next.next.next = ListNode(4)
head.next.next.next.next = ListNode(5)
result = reverseList(head)
while result:
    print(result.val, end=" -> ")
    result = result.next
# 输出: 5 -> 4 -> 3 -> 2 -> 1 -> NULL

    解题思路和步骤：

    1. 初始化指针：首先，我们创建三个指针 pre、cur 和 nex。pre 初始化为 None，cur 初始化为链表的头节点 head，nex 初始化为 cur 的下一个节点。
    2. 遍历链表：使用一个循环遍历链表，进行反转操作。
    3. 保存下一个节点：在循环中，我们首先保存 cur 的下一个节点 nex。
    4. 反转当前节点：然后，我们将 cur 的 next 指针指向 pre，实现反转。
    5. 移动指针：接着，我们将 pre 移动到 cur 的位置，将 cur 移动到 nex 的位置。
    6. 返回新头节点：遍历完成后，pre 指向新的头节点，我们返回 pre。

    这个算法的时间复杂度是 O(n)，其中 n 是链表的长度，因为我们只需要遍历链表一次。空间复杂度是 O(1)，因为我们只使用了常数级别的额外空间。

    Ustinian_310
    关注
    • 20
      点赞
    • 踩
    • 5
      收藏
      觉得还不错? 一键收藏
    • 0
      评论
    Leetcode Top100题目和答案（Java完整版 面试必备）.zip
    06-03
    《LeetCode Top100题目和答案（Java完整版 面试必备）》这个压缩包文件是一个针对Java程序员的面试准备资源，包含了LeetCode上最受欢迎的前100道编程题目及其对应的Java解决方案。LeetCode是一个在线平台，提供了一...
    Leetcode Top100题目和答案(C#完整版 面试必备).pdf
    10-30
    力扣（LeetCode） 相比其他编程平台有着很多优势： **各大知名公司面试真题：**对于求职者在这上面训练更具有针对性，目前国内一些公司面试时直接从在这上面出题。 **大中小企业都在使用：**常常会直接或者间接...
    【LeetCode】Top100 经典必刷题 01【1/20】
    Young_Pro的博客
    07-19 1186
    LeetCode Top 100 经典题目是算法与编程领域内公认的一系列具有挑战性和代表性的问题
    【LeetCode】Top100 经典必刷题 02【2/20】
    Young_Pro的博客
    07-20 1085
    LeetCode Top 100 经典题目是算法与编程领域内公认的一系列具有挑战性和代表性的问题
    【LeetCode】Top100 经典必刷题 03【3/20】
    Young_Pro的博客
    07-22 809
    LeetCode Top 100 经典题目是算法与编程领域内公认的一系列具有挑战性和代表性的问题
    【LeetCode】Top100 经典必刷题 04【4/20】
    最新发布
    Young_Pro的博客
    07-23 487
    LeetCode Top 100 经典题目是算法与编程领域内公认的一系列具有挑战性和代表性的问题
    初学者专属题单（LeetCode必刷8道题）
    m0_64130230的博客
    04-11 1244
    力扣（LeetCode）新手专属题单，8到简单的必刷题，虽然简单，但是涉及到许多知识，非常适合刚开始刷题的小伙伴。这里我分享了自己的做法，不对的地方多多指正，希望你能有所收货🙈🙈🙈🙉🙉🙉
    Leetcode Top100题目和答案（Java完整版 面试必备）
    热门推荐
    lx_lollipop的博客
    03-26 8万+
    最近忙着准备春招，复习完这个又复习那个。不过还是忙里偷闲，把剑指Offer这66道题目重新刷了一遍，收获还是很大的，下面贴出答案，又不懂的可以给我留言，博主会及时解答。 我的github 准备把春招复习的知识都整理到github上，一边是自己做个总结，一边也能供大家参考 ——leetcode数据库 19道题 ——剑指Offer 66道题 以下摘自leetcode Top100精选题目 文章目录1....
    LeetCode 热题 HOT 100【题型归类汇总，助力刷题】
    梦~'
    03-18 3745
    LeetCode 热题 HOT 100🔥【题型归类汇总】，超详细，不断优化ing ...
    leetcode热题HOT-100道题
    NOTBADCODER的博客
    10-09 677
    leetcode刷题记录题目题目 题目 寻找重复的子树 序列化二叉树 只能前序或后续遍历 利用map记录每个根节点的序列化字串 若系列化字串数量大于2就是重复的子树 题目
    LeetCode算法题整理(200题左右)
    qq_38253797的博客
    10-18 1万+
    Leetcode
    leetcode经典题库及知识点总结
    06-25
    leetcode经典题库及知识点总结
    LeetCode刷题手册，刷算法题必备
    12-27
    LeetCode刷题手册，刷算法题必备
    leetcode卡-LeetCode:刷LeetCode前200道题
    07-06
    刷LeetCode前200道题 作战时间：2018-5-13 ~2018-6-13月中旬 第一轮刷题 共计刷题200道 要求 ~每天刷5道题！休息日10道！ ~每天打两次卡，开始刷题时间，截止刷题时间。 注意：刷题不是目的，目的是掌握解题思路； ...
    刷LeetCode刷LeetCode刷LeetCode刷LeetCode
    01-09
    《刷LeetCode刷LeetCode刷LeetCode刷LeetCode》这个标题和描述虽然重复，但很明显是在强调通过反复练习LeetCode来提升编程技能的重要性。LeetCode是一个在线平台，它提供了大量的编程题目，涵盖算法、数据结构等多种...
    LeetCode 用户最喜欢的100题 | 面试最容易被问到的题
    02-28
    "LeetCode Top 100 Liked Questions"是LeetCode用户最喜爱并且在面试中最常被问到的100个问题的集合。这些问题涵盖了多种编程语言，包括但不限于Java、Python、C++等，它们反映了实际工作中的常见问题和面试官对候选...
    leetcode:LeetCode Top 100 Liked Questions | Top Interview Questions | LeetCode 用户最喜欢的100题 | 面试最容易被问到的题
    05-10
    LeetCode 指南 语言: Java 说明： 每道题在代码头部都添加了我的解题思路和批注，Eg: /***** * 287. Find the Duplicate Number * 题意：n+1个数属于[1~n]，找出重复的那个数 * 难度：Medium * 分类：Array, ...
    Leetcode:leetcode-cn.com刷题源代码
    03-23
    Leetcode本项目使用的题库为 :star:主要使用Java书写算法，还有部分SQL语句练习，刚刚开始刷题，数量并不是很多 :grinning_face_with_sweat:我就不建翻译索引目录了，文件名都有，直接Ctrl + F搜索题号吧 :grinning_...
    leetcode数据结构必刷题
    04-03
    LeetCode是一个非常受欢迎的在线编程平台，提供了大量的算法和数据结构题目，对于提升编程能力和面试准备非常有帮助。以下是一些LeetCode上的数据结构必刷题目： 1. 数组： - 两数之和（Two Sum） - 盛最多水的容器（Container With Most Water） - 移动零（Move Zeroes） 2. 字符串： - 反转字符串（Reverse String） - 字符串中的第一个唯一字符（First Unique Character in a String） - 最长回文子串（Longest Palindromic Substring） 3. 链表： - 反转链表（Reverse Linked List） - 合并两个有序链表（Merge Two Sorted Lists） - 删除链表的倒数第N个节点（Remove Nth Node From End of List） 4. 树： - 二叉树的最大深度（Maximum Depth of Binary Tree） - 二叉树的层序遍历（Binary Tree Level Order Traversal） - 二叉树的最近公共祖先（Lowest Common Ancestor of a Binary Tree） 5. 栈和队列： - 有效的括号（Valid Parentheses） - 用队列实现栈（Implement Stack using Queues） - 用栈实现队列（Implement Queue using Stacks） 6. 动态规划： - 爬楼梯（Climbing Stairs） - 最大子序和（Maximum Subarray） - 打家劫舍（House Robber） 7. 排序和搜索： - 合并两个有序数组（Merge Sorted Array） - 搜索旋转排序数组（Search in Rotated Sorted Array） - 在排序数组中查找元素的第一个和最后一个位置（Find First and Last Position of Element in Sorted Array）
    评论
    添加红包

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

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

    抵扣说明：

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

    余额充值