【Leetcode】4. 寻找两个正序数组的中位数

Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.

The overall run time complexity should be O(log (m+n)).

Example 1:

Input: nums1 = [1,3], nums2 = [2]
Output: 2.00000
Explanation: merged array = [1,2,3] and median is 2.

Example 2:

Input: nums1 = [1,2], nums2 = [3,4]
Output: 2.50000
Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.

Constraints:

nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-106 <= nums1[i], nums2[i] <= 106

• hard 难度果然不一般！
• 大抵是懂了罢，就是不会 code。

---

AC：

/*
 * @lc app=leetcode.cn id=4 lang=cpp
 *
 * [4] 寻找两个正序数组的中位数
 */

// @lc code=start
class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        if(nums1.size() > nums2.size()) // 保证nums1是短的数组
        {
            return findMedianSortedArrays(nums2, nums1); // 交换nums1和nums2
        }

        int m = nums1.size(); // nums1的长度
        int n = nums2.size(); // nums2的长度

        int left = 0, right = m; // 初始化二分查找的左右边界
        int median1 = 0, median2 = 0; // 中位数

        while(left <= right) // 二分查找
        {
            int i = (left + right) / 2; // nums1的二分查找位置
            int j = (m + n + 1) / 2 - i; // nums2的二分查找位置

            int nums_im1 = (i == 0 ? INT_MIN : nums1[i - 1]); // nums1[i-1]
            int nums_i = (i == m ? INT_MAX : nums1[i]); // nums1[i]
            int nums_jm1 = (j == 0 ? INT_MIN : nums2[j - 1]); // nums2[j-1]
            int nums_j = (j == n ? INT_MAX : nums2[j]); // nums2[j]

            if(nums_im1 <= nums_j) // nums1[i-1] <= nums2[j]
            {
                median1 = max(nums_im1, nums_jm1); // 更新中位数1
                median2 = min(nums_i, nums_j); // 更新中位数2
                left = i + 1; // 向右移动左边界
            }
            else {
                right = i - 1; // 向左移动右边界
            }
        }

        return (m + n) % 2 == 0 ? (median1 + median2) / 2.0 : median1; // 返回中位数
    }
};
// @lc code=end

---

Supplement:
归并排序算法是一种排序算法，通过将两个已经排序的数组合并，将它们组成一个更大的已排序数组。归并排序采用分治策略：将数组分成两半，分别对每个子数组进行排序，然后将两个已排序的子数组合并为一个已排序的数组。

归并排序的基本思想是将待排序的序列分成若干个子序列，每个子序列都是有序的，然后再把有序子序列合并为整体有序序列。归并排序算法的核心是合并操作。具体步骤如下：

1. 将待排序数组分成两个子数组，直到子数组大小为1。

2. 对两个子数组进行合并排序（即将两个有序的子数组合并成一个有序的大数组）。

3. 重复步骤2，直到合并成一个有序的数组。

C++代码实现：

#include <iostream>
using namespace std;

// 合并两个有序数组
void merge(int arr[], int left, int mid, int right)
{
    int i, j, k;
    int n1 = mid - left + 1;
    int n2 = right - mid;

    // 创建左右两个数组
    int L[n1], R[n2];

    // 将数据复制到左右两个数组中
    for (i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];

    // 合并左右两个数组
    i = 0; // 左数组的初始索引
    j = 0; // 右数组的初始索引
    k = left; // 合并后数组的初始索引
    while (i < n1 && j < n2)
    {
        if (L[i] <= R[j])
        {
            arr[k] = L[i];
            i++;
        }
        else
        {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    // 处理剩余元素
    while (i < n1)
    {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2)
    {
        arr[k] = R[j];
        j++;
        k++;
    }
}

// 归并排序
void mergeSort(int arr[], int left, int right)
{
    if (left < right)
    {
        // 找出中间点
        int mid = left + (right - left) / 2;

        // 对左半部分进行递归排序
        mergeSort(arr, left, mid);

        // 对右半部分进行递归排序
        mergeSort(arr, mid + 1, right);

        // 合并有序子数组
        merge(arr, left, mid, right);
    }
}

int main()
{
    int arr[] = {12, 11, 13, 5, 6, 7};
    int n = sizeof(arr) / sizeof(arr[0]);

    cout << "原数组：";
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    cout << endl;

    mergeSort(arr, 0, n - 1);

    cout << "排序后的数组：";
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    cout << endl;

    return 0;
}

输出：

原数组：12 11 13 5 6 7 
排序后的数组：5 6 7 11 12 13