力扣刷题笔记

力扣206 反转链表

题目描述: 给你单链表的头节点head ，请你反转链表，并返回反转后的链表。 

示例 1：

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

示例 2：

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

示例 3：

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

方法一: 迭代

思路: 遍历链表，在遍历链表的过程中，不断地修改当前节点的指针，使其指向前一个节点，从而实现链表的反转。在修改指针之前，需要提前保存下一个节点的引用，以防止丢失节点。通过遍历完成后，原链表的头节点变成了反转后链表的尾节点，需要返回新的头节点的引用。

python实现代码:

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
        # 初始化当前节点为头节点
        curr = head
        # 遍历链表，直到当前节点为空
        while curr:
            # 存储下一个节点的引用
            next_node = curr.next
            # 将当前节点的指针指向前一个节点，实现反转
            curr.next = prev
            # 更新前一个节点为当前节点
            prev = curr
            # 更新当前节点为下一个节点
            curr = next_node
        # 返回反转后的头节点引用
        return prev

# 主函数用于测试
if __name__ == "__main__":
    # 创建一个链表：1 -> 2 -> 3 -> None
    node3 = ListNode(3)
    node2 = ListNode(2, node3)
    node1 = ListNode(1, node2)

    # 创建 Solution 类的实例
    solution = Solution()
    # 调用 reverseList 方法反转链表
    new_head = solution.reverseList(node1)

    # 打印反转后的链表
    while new_head:
        print(new_head.val, end=" -> ")
        new_head = new_head.next

复杂度分析:

时间复杂度：O(n)，其中 nnn 是链表的长度。需要遍历链表一次。

空间复杂度：O(1)。

方法二: 递归

思路：利用递归实现链表的反转。在递归过程中，我们假设递归函数能够正确地反转从当前节点的下一个节点开始的链表部分，然后我们将当前节点的下一个节点指向当前节点，从而完成链表的反转操作。

python实现代码：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        # 如果链表为空或者只有一个节点，则直接返回头节点
        if not head or not head.next:
            return head
        
        # 递归调用，反转以当前节点的下一个节点为头节点的子链表
        new_head = self.reverseList(head.next)
        
        # 将当前节点的下一个节点的下一个节点指向当前节点，完成反转操作
        head.next.next = head
        
        # 将当前节点的下一个节点设为 None，防止产生环
        head.next = None
        
        # 返回反转后的头节点
        return new_head

# 主函数用于测试
if __name__ == "__main__":
    # 创建一个链表：1 -> 2 -> 3 -> None
    node3 = ListNode(3)
    node2 = ListNode(2, node3)
    node1 = ListNode(1, node2)

    # 创建 Solution 类的实例
    solution = Solution()
    # 调用 reverseList 方法反转链表
    new_head = solution.reverseList(node1)

    # 打印反转后的链表
    while new_head:
        print(new_head.val, end=" -> ")
        new_head = new_head.next

复杂度分析:

时间复杂度：O(n)，其中 n 是链表的长度。需要对链表的每个节点进行反转操作。

空间复杂度：O(n)，其中 n 是链表的长度。空间复杂度主要取决于递归调用的栈空间，最多为 n 层。

力扣204 计数质数

题目描述：给定整数 n ，返回 所有小于非负整数 n 的质数的数量 。

示例 1：

输入：n = 10

输出：4

解释：小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。

示例 2：

输入：n = 0

输出：0

示例 3：

输入：n = 1

输出：0

方法一：埃氏筛

思路：利用布尔数组标记质数，从 2 开始遍历至 n 的平方根，将每个质数的倍数标记为非质数，最后统计布尔数组中值为 True 的数量即为小于 n 的质数的数量。

python实现代码：

class Solution:
    def countPrimes(self, n: int) -> int:
        if n <= 2:
            return 0
        
        # 初始化布尔数组，全部标记为 True，表示所有数都是质数
        primes = [True] * n
        # 0 和 1 不是质数，将其标记为 False
        primes[0], primes[1] = False, False
        
        # 从 2 开始遍历到 n 的平方根
        for i in range(2, int(n ** 0.5) + 1):
            if primes[i]:
                # 将 i 的所有倍数标记为非质数
                primes[i*i:n:i] = [False] * len(primes[i*i:n:i])
        
        # 统计布尔数组中值为 True 的数量，即为小于 n 的质数的数量
        return sum(primes)

# 测试代码
if __name__ == "__main__":
    solution = Solution()
    n = 10
    print(solution.countPrimes(n))  # 输出结果应为 4，因为小于 10 的质数有 2、3、5、7

复杂度分析：

时间复杂度：O(n * log(log(n)))。算法中最主要的部分是埃拉托斯特尼筛法的实现，其中有一个嵌套循环，外部循环从 2 到 n 的平方根，内部循环从当前质数的平方开始，直到 n，所以时间复杂度为 O(n * log(log(n)))。

空间复杂度：O(n)。需要使用一个大小为 n 的布尔数组 primes 来标记质数，因此空间复杂度为 O(n)。

力扣238 除自身以外数组的乘积

题目描述：给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。题目数据保证数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。请不要使用除法，且在 O(n) 时间复杂度内完成此题。

示例 1:

输入: nums = [1,2,3,4]

输出: [24,12,8,6]

示例 2:

输入: nums = [-1,1,0,-3,3]

输出: [0,0,9,0,0]

方法一：左右乘积列表

思路：使用两个数组来保存每个元素左侧和右侧的乘积。具体思路如下：

1. 初始化两个数组 left_products 和 right_products，分别用于保存每个元素左侧和右侧的乘积。
2. 遍历原始数组 nums，计算每个元素左侧所有元素的乘积，并存储在 left_products 中。
3. 遍历原始数组 nums（从右向左遍历），计算每个元素右侧所有元素的乘积，并存储在 right_products 中。
4. 对于结果数组 answer，每个元素的值等于对应位置的左侧乘积和右侧乘积的乘积。
5. 返回结果数组 answer。

python实现代码：

class Solution(object):
    def productExceptSelf(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        lens = len(nums)
        answer = [1] * lens
        
        # 计算每个元素左侧所有元素的乘积
        left_product = 1
        for i in range(lens):
            answer[i] *= left_product
            left_product *= nums[i]
        
        # 计算每个元素右侧所有元素的乘积，并与左侧乘积相乘得到最终结果
        right_product = 1
        for i in range(lens - 1, -1, -1):
            answer[i] *= right_product
            right_product *= nums[i]
        
        return answer

复杂度分析：

时间复杂度：O(n)，其中 n 是输入数组 nums 的长度。在算法中，我们只需要遍历 nums 数组两次，一次从左到右，一次从右到左，每次遍历都需要 O(n) 的时间。因此，总的时间复杂度是 O(n)。

空间复杂度：O(1)，除了返回的答案之外，我们只使用了常数额外的空间来存储一些变量，例如左侧乘积和右侧乘积。因此，空间复杂度是 O(1)。

持续更新中.............