LeetCode 每周算法 3（矩阵、链表）

最新推荐文章于 2024-11-09 20:38:27 发布
最新推荐文章于 2024-11-09 20:38:27 发布
阅读量240 收藏
点赞数 3
文章标签： 算法 leetcode 矩阵
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45801780/article/details/141467109
版权

LeetCode 每周算法 3（矩阵、链表）

矩阵算法：

在这里插入图片描述

class Solution(object):
    def setZeroes(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: None Do not return anything, modify matrix in-place instead.
        """
        # 如果矩阵为空或没有列，则直接返回  
        if not matrix or not matrix[0]:  
            return  
        
        # 获取矩阵的行数和列数  
        rows, cols = len(matrix), len(matrix[0])  
        
        # 初始化两个标志变量，用于记录第一行和第一列是否需要设置为0  
        firstRowZero = False   
        firstColZero = False  
        
        # 遍历第一行，检查是否有0  
        for j in range(cols):  
            if matrix[0][j] == 0:  
                firstRowZero = True  
                break  
        
        # 遍历第一列，检查是否有0  
        for i in range(rows):  
            if matrix[i][0] == 0:  
                firstColZero = True  
                break  
                
        # 遍历矩阵（除了第一行和第一列），标记0所在的行和列  
        for i in range(1, rows):  
            for j in range(1, cols):  
                if matrix[i][j] == 0:  
                    matrix[i][0] = 0  # 在第一列标记行  
                    matrix[0][j] = 0  # 在第一行标记列  
                    
        # 根据第一行和第一列的标记，设置对应的行和列为0  
        for i in range(1, rows):  
            for j in range(1, cols):  
                if matrix[i][0] == 0 or matrix[0][j] == 0:  
                    matrix[i][j] = 0  
        
        # 如果第一行有0，则将第一行所有元素设置为0  
        if firstRowZero:  
            for j in range(cols):  
                matrix[0][j] = 0  
                
        # 如果第一列有0，则将第一列所有元素设置为0  
        if firstColZero:  
            for i in range(rows):  
                matrix[i][0] = 0

在这里插入图片描述

class Solution(object):
    def spiralOrder(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: List[int]
        """
        if not matrix or not matrix[0]:  
            # 如果矩阵为空或没有列，则直接返回空列表  
            return []  
        
        rows, cols = len(matrix), len(matrix[0])  
        # 初始化矩阵的边界  
        top, bottom = 0, rows - 1  
        left, right = 0, cols - 1  
        result = []  
        
        while top <= bottom and left <= right:  
            # 从左到右遍历上边界  
            for i in range(left, right + 1):  
                result.append(matrix[top][i])  
            top += 1  # 上边界下移  
            
            # 从上到下遍历右边界  
            for i in range(top, bottom + 1):  
                result.append(matrix[i][right])  
            right -= 1  # 右边界左移  
            
            # 如果已经遍历完整个矩阵，则跳出循环  
            if top > bottom or left > right:  
                break  
            
            # 从右到左遍历下边界  
            for i in range(right, left - 1, -1):  
                result.append(matrix[bottom][i])  
            bottom -= 1  # 下边界上移  
            
            # 从下到上遍历左边界  
            for i in range(bottom, top - 1, -1):  
                result.append(matrix[i][left])  
            left += 1  # 左边界右移  
        
        return result

在这里插入图片描述

class Solution(object):
    def rotate(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: None Do not return anything, modify matrix in-place instead.
        """
        n = len(matrix)  
      
        # 第一步：沿主对角线镜像对称  
        for i in range(n):  
            for j in range(i, n):  # 注意 j 从 i 开始，避免重复交换  
                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]  
        
        # 第二步：反转每一行  
        for i in range(n):  
            matrix[i] = matrix[i][::-1]

在这里插入图片描述

class Solution(object):
    def searchMatrix(self, matrix, target):
        """
        :type matrix: List[List[int]]
        :type target: int
        :rtype: bool
        """
        # 如果矩阵为空或者矩阵的第一行为空，则直接返回False，表示找不到目标值。  
        if not matrix or not matrix[0]:    
            return False    
        
        # 获取矩阵的行数和列数。  
        m, n = len(matrix), len(matrix[0])    
        # 初始化搜索的起始位置为矩阵的右上角。  
        row, col = 0, n - 1    
        
        # 当行索引小于行数且列索引大于等于0时，继续搜索。  
        while row < m and col >= 0:    
            # 如果当前位置的值等于目标值，返回True，表示找到了目标值。  
            if matrix[row][col] == target:    
                return True    
            # 如果当前位置的值小于目标值，说明目标值在当前位置的下方，因此行索引下移。  
            elif matrix[row][col] < target:    
                row += 1    
            # 如果当前位置的值大于目标值，说明目标值在当前位置的左侧，因此列索引左移。  
            else:    
                col -= 1   
        
        # 如果循环结束还没有找到目标值，则返回False。  
        return False

链表算法：

在这里插入图片描述

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        # 如果任一链表为空，则它们不可能相交，直接返回 None  
        if not headA or not headB:  
            return None  
        
        pA = headA  # 初始化指针 pA 指向链表 A 的头节点  
        pB = headB  # 初始化指针 pB 指向链表 B 的头节点  
        
        # 当 pA 和 pB 不相等时，继续循环  
        while pA != pB:  
            # 如果 pA 到达链表 A 的末尾（即 pA 为 None），则将 pA 指向链表 B 的头节点  
            pA = pA.next if pA else headB  
            # 如果 pB 到达链表 B 的末尾（即 pB 为 None），则将 pB 指向链表 A 的头节点  
            pB = pB.next if pB else headA  
        
        # 当循环结束时，pA 和 pB 一定相等，它们要么都指向相交节点，要么都指向 None（如果不相交）  
        return pA

在这里插入图片描述

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        # 初始化前一个节点为None  
        prev = None  
        # 初始化当前节点为头节点  
        current = head  
        # 遍历链表  
        while current:  
            # 保存当前节点的下一个节点  
            next_temp = current.next  
            # 将当前节点指向前一个节点，实现反转  
            current.next = prev  
            # 将前一个节点移动到当前节点  
            prev = current  
            # 将当前节点移动到下一个节点  
            current = next_temp  
        # 返回反转后的头节点，即最后一个处理的节点  
        return prev

在这里插入图片描述

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def isPalindrome(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        # 边界条件：如果链表为空或只有一个节点，则一定是回文链表  
        if not head or not head.next:  
            return True  
    
        # 使用快慢指针找到链表的中点  
        slow, fast = head, head  
        while fast and fast.next:  
            slow = slow.next  
            fast = fast.next.next  
    
        # 反转链表的后半部分  
        prev, current = None, slow  
        while current:  
            next_temp = current.next  
            current.next = prev  
            prev = current  
            current = next_temp  
    
        # 比较链表的前半部分和反转后的后半部分是否相等  
        left, right = head, prev  
        while right:  
            if left.val != right.val:  
                return False  
            left = left.next  
            right = right.next  
    
        # 如果全部节点都比较完毕且相等，则返回True  
        return True

在这里插入图片描述

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        # 初始化快慢指针，都指向头节点  
        slow = head  
        fast = head  
    
        # 当快指针和快指针的下一个节点都不为空时，循环继续  
        while fast and fast.next:  
            # 慢指针每次移动一步  
            slow = slow.next  
            # 快指针每次移动两步  
            fast = fast.next.next  
    
            # 如果快慢指针相遇，说明链表中有环  
            if slow == fast:  
                return True  
    
        # 如果循环结束，说明快指针已经到达链表尾部，链表中无环  
        return False

在这里插入图片描述

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        # 如果链表为空或只有一个节点，则肯定没有环  
        if not head or not head.next:  
            return None  
        
        # 初始化快慢指针，都指向头节点  
        slow = head  
        fast = head  
        
        # 查找快慢指针相遇的点  
        while fast and fast.next:  
            slow = slow.next           # 慢指针每次移动一步  
            fast = fast.next.next      # 快指针每次移动两步  
            
            # 如果快慢指针相遇，则存在环  
            if slow == fast:  
                break  
        
        # 如果快指针已经到达链表末尾（fast 或 fast.next 为空），则不存在环  
        if not fast or not fast.next:  
            return None  
        
        # 将慢指针重新放回头节点，快指针保持在相遇点  
        slow = head  
        
        # 移动快慢指针，每次一步，直到它们再次相遇  
        while slow != fast:  
            slow = slow.next  
            fast = fast.next  
        
        # 返回环的起始节点  
        return slow
S01d13r
关注
【Leetcode】86. 分隔链表
锥栗的博客
11-17 622
题目描述 给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你应当 保留 两个分区中每个节点的初始相对位置。 题解 非常简单粗暴又有效，让small用于链接小结点，large用于链接大结点，最后两个结点链接起来。 执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户 内存消耗：37.6 MB, 在所有 Java 提交中击败了86.29%的用户 通过测试用例：168 / 168 import java
【Leetcode之数组和矩阵】
Liususiu的秃头日记
12-12 249
Leetcode之数组和矩阵part
Java 中 LeetCode 热门算法精讲
Miss_SunHengYang的博客
07-18 901
动态规划是解决优化问题的重要方法，适用于问题具有重叠子问题和最优子结构特点的情况，通过递推的方式逐步构建最优解。快速排序是一种高效的排序算法，通过分治法的策略，将一个大问题分解为小问题来解决，从而达到整体上的高效排序。动态规划解决股票买卖问题时，关键在于状态的定义和转移，以及对初始状态的处理，从而得到最终的最大利润。计算表达式的值是编程中的常见需求，需要注意运算符优先级和括号的处理，栈是实现这一功能的理想数据结构。寻找数组交集是常见的算法问题，通过集合的方式可以有效地解决，同时考虑算法的时间和空间复杂度。
leetcode螺旋矩阵总结
weixin_42208579的博客
01-04 686
leetcode螺旋矩阵总结
常见算法总结【leetcode】
xiaod12138的博客
09-11 2181
【注意：列出来的题目大部分是简单题；列出来的题目其最优解法不一定是本文中所说的算法，列举只是为了辅助更好的理解算法；
LeetCode 算法学习记录 链表 142. 环形链表 II
reresrse的博客
03-01 209
public class Linked_List_Cycle_II { //142. 环形链表 II //给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 //如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行
LeetCode 算法学习记录 链表面试题 02.07. 链表相交
reresrse的博客
03-01 263
public class Intersection_of_Two_Linked_Lists_LCCI { //面试题 02.07. 链表相交 //给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。 //图示两个链表在节点 c1 开始相交： //版本一 双指针,\ //如果俩个链表相交的话,那么俩个链表必定从摸一个位置开始往后一模一样, //那么就出现俩个思路,一个是从后往前遍
leetcode算法总结（方法论篇）
kwsunnh的博客
10-09 612
堆，又称优先级队列，在逻辑上可以视为一棵完全二叉树，且满足每个节点的值小于等于（小根堆）其左右孩子节点的值。结合二维数组使用，常用图、或者多个条件的状态。备注：子序列是非连续的，子串是连续的。是否相遇（快指针两步，慢指针一步）
Leetcode习题螺旋矩阵，旋转链表
liuxingxing_sun的博客
01-18 154
螺旋矩阵 class Solution: def spiralOrder(self, matrix: List[List[int]]) -> List[int]: if not matrix: return [] m=len(matrix) #行 n=len(matrix[0]) #列 layer_num=(min(m,n)+1)//2 #有多少层 res_list=[] #保持结果 for l
leetcode中文版-LeetCode:算法练习：LeetCode问题、LeetCode每周竞赛等
06-29
BFS：矩阵、单词变换 排列、组合、分割、子集：四大类问题，常用回溯、DFS解决 图的搜索：DFS、BFS、并查集、Flood 并查集（TODO） 二分查找： g 函数，利用边界 K th 问题 旋转数组 双指针： 左右指针：数组（或...
leetcode:leetcode小算法
04-01
《LeetCode：Python小算法详解》 LeetCode是一个广受欢迎的在线编程挑战平台，它包含了大量算法题目，旨在提升程序员的编程技能和解决问题的能力。在这个专题中，我们将重点关注使用Python语言解决LeetCode中的小...
青蛙过河leetcode-LeetCode:python3实现经典算法题
07-06
python3实现经典算法题 记录一些之前在leetcode上刷的题以及别的地方看到的有趣的东西，把还能看懂的上传一下，尽量标注题号 1、KMP算法---字符串匹配 利用字符串最长相同前缀后缀减少没必要的比较从而加快匹配 2、...
leetcode数组下标大于间距-leetcode:leetcode问题算法
06-30
合并两个有序链表 68.66% - 26 删除排序数组中的重复项 97.95% - 27 移除元素 92.86% - 28 实现 strStr() 91.12% - 31 下一个排列 48.69% 8.77% 34 在排序数组中查找元素的第一个和最后一个位置 93.39% 37.16% 35 ...
STL set
最新发布
hls0611的博客
11-09 202
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
100种算法【Python版】第51篇——希尔排序
AnFany
11-06 283
100种算法【Python版】第51篇——希尔排序
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 357
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 2057
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
洛谷 P2239 [NOIP2014 普及组] 螺旋矩阵
jzwalliser的博客
11-09 785
本文由Jzwalliser原创，发布在CSDN平台上，遵循CC 4.0 BY-SA协议。因此，若需转载/引用本文，请注明作者并附原文链接，且禁止删除/修改本段文字。
二叉树(一)
m0_74340589的博客
11-05 463
/ 写递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。// 再说说归并排序的逻辑，若要对nums[lo…// 再看看回溯算法，前文回溯算法详解干脆直接说了，回溯算法就是个 N 叉树的前后序遍历问题，没有例外。// 其实很多动态规划问题就是在遍历一棵树，你如果对树的遍历操作烂熟于心，起码知道怎么把思路转化成代。//快速排序的逻辑是，若要对nums[lo….所有回溯、动归、分治算法，其实都是树的问题，而树的问题就永远逃不开树的递归遍历。
掌握LeetCode编程题：矩阵生成与算法优化
资源摘要信息:"Leetcode生成斜矩阵是一个关于如何使用Leetcode平台记录刷题过程中的编程练习和解决方案的文档。文中详细介绍了几种常见的算法问题以及解决这些问题的思路和代码实现。这些问题包括数组中两数之和、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值