数组

LeetCode中的数组题目是非常常见的题型之一，考察的是对数组的基本操作和一些高级算法的运用。数组是一种线性数据结构，它可以存储同一类型的元素，这些元素可以通过索引来访问。数组的操作包括：插入、删除、查找、遍历等。以下是一些常见的LeetCode数组题目类型：

1. 数组排序

   这类题目主要考察排序算法的实现和优化。常见的排序算法有冒泡排序、插入排序、选择排序、归并排序、快速排序等。LeetCode中的数组排序题目包括：

   • 88.合并两个有序数组
   • 215.数组中的第K个最大元素
   • 287.寻找重复数
   • 75.颜色分类

2. 数组查找

   这类题目主要考察查找算法的实现和优化。常见的查找算法有线性查找、二分查找、哈希查找等。LeetCode中的数组查找题目包括：

   • 33.搜索旋转排序数组
   • 153.寻找旋转排序数组中的最小值
   • 240.搜索二维矩阵 II
   • 4.寻找两个正序数组的中位数

3. 数组操作

   这类题目主要考察对数组的一些基本操作的实现和优化。包括去重、最大子序列和、最长上升子序列、数组旋转等。LeetCode中的数组操作题目包括：

   • 26.删除有序数组中的重复项
   • 53.最大子序和
   • 300.最长上升子序列
   • 189.旋转数组

4. 数组变换

   这类题目主要考察对数组变换的实现和优化。包括对称变换、交换变换、数值变换等。LeetCode中的数组变换题目包括：

   • 31.下一个排列
   • 48.旋转图像
   • 56.合并区间
   • 289.生命游戏

总的来说，LeetCode中的数组题目难度从简单到困难不一，需要具备扎实的数组操作和算法基础知识，同时也需要具备灵活的思维和创新能力，能够根据问题特点灵活选择算法和数据结构。

---

88. 合并两个有序数组 - 力扣（Leetcode）

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意： 最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

 

示例 1：

输入： nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出： [1,2,2,3,5,6]
解释： 需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

示例 2：

输入： nums1 = [1], m = 1, nums2 = [], n = 0
输出： [1]
解释： 需要合并 [1] 和 [] 。
合并结果是 [1] 。

示例 3：

输入： nums1 = [0], m = 0, nums2 = [1], n = 1
输出： [1]
解释： 需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

 

提示：

• nums1.length == m + n
• nums2.length == n
• 0 <= m, n <= 200
• 1 <= m + n <= 200
• -109 <= nums1[i], nums2[j] <= 109

 

进阶： 你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗？

class Solution:
    def merge(self, nums1, m, nums2, n) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        tail = m + n - 1
        m -= 1
        n -= 1
        while m >= 0 or n >= 0:
            if m == -1:
                nums1[tail] = nums2[n]
                n -= 1
            elif n == -1:
                nums1[tail] = nums1[m]
                m -= 1
            elif nums1[m] > nums2[n]:
                nums1[tail] = nums1[m]
                m -= 1
            else:
                nums1[tail] = nums2[n]
                n -= 1
            tail -= 1

这是一个归并排序的合并操作。给定两个有序数组 nums1 和 nums2，将 nums2 合并到 nums1 中，并且保证合并后的 nums1 也是有序的。

具体实现是用 tail 记录 nums1 和 nums2 合并后的末尾位置。然后将 m 和 n 分别记录 nums1 和 nums2 的末尾位置。从后向前依次比较 nums1 和 nums2 的元素，将较大的元素放入 nums1 的末尾。当其中一个数组的元素全部被处理完之后，直接将另一个数组中的元素填充到 nums1 的前面即可。

该题的时间复杂度为 $O(m+n)$，其中 $m$ 为 nums1 数组的长度，$n$ 为 nums2 数组的长度。因为算法需要遍历 nums1 和 nums2 数组中的所有元素一次，所以时间复杂度为 $O(m+n)$。

空间复杂度为 $O(1)$，因为算法只需要额外使用常数个变量来存储一些指针和临时变量，空间复杂度为常数级别。

27. 移除元素 - 力扣（Leetcode）

给你一个数组 nums 和一个值 val，你需要 原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1：

输入： nums = [3,2,2,3], val = 3
输出： 2, nums = [2,2]
解释： 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例 2：

输入： nums = [0,1,2,2,3,0,4,2], val = 2
输出： 5, nums = [0,1,4,0,3]
解释： 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

 

提示：

• 0 <= nums.length <= 100
• 0 <= nums[i] <= 50
• 0 <= val <= 100

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        slow,fast = 0,0
        while fast < len(nums):
            if nums[fast] != val:
                nums[slow] = nums[fast]
                slow+=1
            fast += 1
        return slow

具体解释如下：

1. 首先定义两个指针，一个是slow指针，一个是fast指针，表示慢指针和快指针。

2. 用快指针来遍历数组中的元素，如果当前元素不等于指定值val，则将当前元素赋值给慢指针指向的位置，然后slow指针加1。

3. 不论是否赋值，都要将快指针加1。

4. 最后返回slow指针，即为处理后的数组长度。

这个算法的时间复杂度是O(n)，其中n是数组的长度。因为需要遍历整个数组一次，将不等于指定值的元素移到前面。空间复杂度是O(1)，因为只需要额外的常数级别的空间来存储两个指针。

26. 删除有序数组中的重复项 - 力扣（Leetcode）

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

• 更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
• 返回 k 。  

示例 1：

输入： nums = [1,1,2]
输出： 2, nums = [1,2,_]
解释： 函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2：

输入： nums = [0,0,1,1,1,2,2,3,3,4]
输出： 5, nums = [0,1,2,3,4]
解释： 函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

 

提示：

• 1 <= nums.length <= 3 * 104
• -104 <= nums[i] <= 104
• nums 已按 升序 排列

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        slow = fast = 0

        while fast<len(nums):
            if nums[slow] != nums[fast]:
                slow += 1
                nums[slow] = nums[fast]
            fast += 1

        return slow + 1

和上一个题目类似，都是采用快慢指针的方法来实现。慢指针 slow 指向数组中当前不重复元素的最后一个位置，快指针 fast 遍历整个数组。当快指针指向的元素不等于慢指针指向的元素时，将慢指针右移一位，并将快指针指向的元素赋值给慢指针指向的位置。

时间复杂度为 $O(n)$，其中 $n$ 为数组的长度。因为算法需要遍历整个数组一次，所以时间复杂度为线性。

空间复杂度为 $O(1)$，因为算法只需要使用常数个额外的变量来存储指针和临时变量，空间复杂度为常数级别。

80. 删除有序数组中的重复项 II - 力扣（Leetcode）

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

 

说明：

为什么返回数值是整数，但输出的答案是数组呢？

请注意，输入数组是以 「引用」 方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

示例 1：

输入： nums = [1,1,1,2,2,3]
输出： 5, nums = [1,1,2,2,3]
解释： 函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。 不需要考虑数组中超出新长度后面的元素。

示例 2：

输入： nums = [0,0,1,1,1,1,2,3,3]
输出： 7, nums = [0,0,1,1,2,3,3]
解释： 函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。 不需要考虑数组中超出新长度后面的元素。

 

提示：

• 1 <= nums.length <= 3 * 104
• -104 <= nums[i] <= 104
• nums 已按升序排列

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        slow,fast = 0,0
        while fast<len(nums):
            if slow<2 or nums[fast] != nums[slow-2]:
                nums[slow] = nums[fast]
                slow += 1
            fast += 1
        return slow

上一道题和这一道题，这两段代码实现的是相同的功能，都是去除重复的元素，使每个元素最多出现2次。不同之处在于第一段代码的判断条件是 nums[slow-2] != nums[fast]，而第二段代码的判断条件是 nums[slow] != nums[fast]。

第一段代码中的判断条件是使用了 slow-2 来判断，这是因为在这个题目中，要求每个元素最多出现两次，所以 slow-2 指向的是前面第二个数，如果这个数与当前 fast 指向的数不相等，那么就说明当前 fast 指向的数可以放在 slow 指向的位置，即可满足每个元素最多出现两次的要求。而第二段代码中的判断条件则是比较直观，只需要判断当前 fast 指向的数是否与 slow 指向的数相等即可。

两段代码在实现上略有不同，但时间复杂度和空间复杂度都是一样的，都是 O(n) 的时间复杂度和 O(1) 的空间复杂度。