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 原地修改,不需要额外空间

相关推荐
小码农<^_^>6 分钟前
优选算法精品课--滑动窗口算法(一)
算法
羊小猪~~8 分钟前
神经网络基础--什么是正向传播??什么是方向传播??
人工智能·pytorch·python·深度学习·神经网络·算法·机器学习
软工菜鸡33 分钟前
预训练语言模型BERT——PaddleNLP中的预训练模型
大数据·人工智能·深度学习·算法·语言模型·自然语言处理·bert
南宫生36 分钟前
贪心算法习题其三【力扣】【算法学习day.20】
java·数据结构·学习·算法·leetcode·贪心算法
AI视觉网奇1 小时前
sklearn 安装使用笔记
人工智能·算法·sklearn
JingHongB1 小时前
代码随想录算法训练营Day55 | 图论理论基础、深度优先搜索理论基础、卡玛网 98.所有可达路径、797. 所有可能的路径、广度优先搜索理论基础
算法·深度优先·图论
weixin_432702261 小时前
代码随想录算法训练营第五十五天|图论理论基础
数据结构·python·算法·深度优先·图论
小冉在学习1 小时前
day52 图论章节刷题Part04(110.字符串接龙、105.有向图的完全可达性、106.岛屿的周长 )
算法·深度优先·图论
Repeat7151 小时前
图论基础--孤岛系列
算法·深度优先·广度优先·图论基础
小冉在学习1 小时前
day53 图论章节刷题Part05(并查集理论基础、寻找存在的路径)
java·算法·图论