88. 合并两个有序数组 (Swift版本)

题目

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

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

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

提示

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

解答

方法1: 合并后使用系统方法 sort() (最简单, 最直接)

Show Code
swift 复制代码
class Solution {
    func merge(_ nums1: inout [Int], _ m: Int, _ nums2: [Int], _ n: Int) {
    	// range operator (区间运算符/区间操作符)
        for idx in 0..<n {
            nums1[m + idx] = nums2[idx]
        }
        // 闭包表达式的简短方式
        nums1.sort(by: <)
    }
}
复杂度分析
  • 时间复杂度:O((m+n)log(m+n))

    排序序列长度为 m+n,套用 sort 方法的时间复杂度即可,平均情况为 O((m+n)log⁡(m+n))

  • 空间复杂度: O(m+n)

    排序序列长度为 m+n,套用sort 方法的空间复杂度即可,平均情况为 O(m+n)

Swift 的内置排序算法 sort()Swift5 之后采用了 TimSort,相较于之前的 Introsortstability, 什么是 stability?它是_一种排序后维持相等元素的原始顺序的能力_, 关于 Swift 中 sort() 的 stability, 可以参考 Is sort() stable in Swift 5?

TimSort 是一种混合算法 ,包含插入排序O(n^2)归并排序O(nlogn), 因为 插入 和 归并 都是 stability, 所以 TimSort 也是

TimSort 核心原理是 切割 + 合并, 具体实现可参考 TimSort

TimSort 的平均时间复杂度为O(nlogn) ,最好情况O(n) ,最差情况O(nlogn) 。 空间复杂度O(n) ,是一个稳定的排序算法。 自该算法被发明以来,已被Python、Java、Android 平台和GNU Octave 用作默认排序算法。

执行用时&内存消耗

方法2: 双指针

方法一没有利用数组 nums1 与 nums2 已经被排序的性质。为了利用这一性质,我们可以使用双指针方法。这一方法将两个数组看作队列,每次从两个数组头部取出比较小的数字放到结果中。

Show code
swift 复制代码
    func merge(_ nums1: inout [Int], _ m: Int, _ nums2: [Int], _ n: Int) {
        var p1 = 0, p2 = 0
        var sorted = [Int]()
        while p1 < m || p2 < n {
            if p1 == m {
                sorted.append(nums2[p2])
                p2 += 1
                // 很重要, 没有则会向下执行, 最终Crash -> Fatal error: Index out of range
                continue
            }
            if p2 == n {
                sorted.append(nums1[p1])
                p1 += 1
                // 很重要, 没有则会向下执行, 最终Crash -> Fatal error: Index out of range
                continue
            }
            if nums1[p1] < nums2[p2] {
                sorted.append(nums1[p1])
                p1 += 1
            } else {
                sorted.append(nums2[p2])
                p2 += 1
            }
        }
        for idx in 0..<(m+n) {
            nums1[idx] = sorted[idx]
        }
    }
复杂度分析
  • 时间复杂度: O(m + n)

    指针移动单调递增,最多移动 m+n 次,因此时间复杂度为 O(m+n)

  • 空间复杂度: O(m + n)

    需要建立长度为 m+n 的中间数组 sorted

方法3: 逆向双指针

方法二中,之所以要使用临时变量,是因为如果直接合并到数组 nums1 中,nums1 中的元素可能会在取出之前被覆盖。那么如何直接避免覆盖 nums1 中的元素呢?观察可知,nums1 的后半部分是空的,可以直接覆盖而不会影响结果。因此可以指针设置为从后向前遍历,每次取两者之中的较大者放进 nums1 的最后面。

严格来说,在此遍历过程中的任意一个时刻,nums1 数组中有 m−p1−1 个元素被放入 nums1 的后半部,nums2 数组中有 n−p2−1 个元素被放入 nums1 的后半部,而在指针 p1 的后面,nums1 数组有 m+n−p1−1 个位置。由于

m+n−p1−1≥m−p1−1+n−p2−1

等价于

p2≥−1

永远成立,因此 p1 后面的位置永远足够容纳被插入的元素,不会产生 p1 的元素被覆盖的情况。

Show code
swift 复制代码
    func merge(_ nums1: inout [Int], _ m: Int, _ nums2: [Int], _ n: Int) {
        var p1 = m - 1, p2 = n - 1
        var tail = m + n - 1
        while p1 > -1 || p2 > -1 {
            if p1 == -1 {
                nums1[tail] = nums2[p2]
                tail -= 1
                p2 -= 1
                continue
            }
            if p2 == -1 {
                nums1[tail] = nums1[p1]
                tail -= 1
                p1 -= 1
                continue
            }
            if nums1[p1] > nums2[p2] {
                nums1[tail] = nums1[p1]
                p1 -= 1
                tail -= 1
            } else {
                nums1[tail] = nums2[p2]
                p2 -= 1
                tail -= 1
            }
        }
    }
复杂度分析
  • 时间复杂度: O(m + n)

    指针移动单调递减,最多移动 m+n 次,因此时间复杂度为 O(m+n)

  • 空间复杂度: O(1)

    直接对数组 nums1 原地修改,不需要额外空间

相关推荐
先鱼鲨生12 分钟前
排序【数据结构】【算法】
数据结构·算法·排序算法
时光の尘42 分钟前
C语言菜鸟入门·关键字·void的用法
c语言·开发语言·c++·算法·c#·c·关键字
蚂蚁没问题s43 分钟前
图像处理 - 色彩空间转换
图像处理·人工智能·算法·机器学习·计算机视觉
戊子仲秋1 小时前
【LeetCode】每日一题 2024_11_21 矩阵中的蛇(模拟)
算法·leetcode·矩阵
HP-Patience1 小时前
【机器学习】- 模型复杂度vs模型误差
python·算法·机器学习
螺旋天光极锐斩空闪壹式!1 小时前
第十三课 二维数组(2)方向数组
开发语言·c++·算法
peter80151 小时前
算法项目推荐
算法
小小白白蛆1 小时前
剑指offer JZ51 数组中的逆序对
数据结构·算法·排序算法
十五年专注C++开发1 小时前
C++不完整类型(Incomplete Type)的检测与避免
开发语言·c++·算法·设计模式
eternal19951 小时前
优化算法|基于Deep-Q-Network(DQN)的邻域搜索算法求解分布式柔性作业车间调度问题
分布式·算法