LeetCode——4. 寻找两个正序数组的中位数（给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。）

示例 1：
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例2：
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2+ 3) / 2 = 2.5

示例 3：
输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000

示例 4：
输入：nums1 = [], nums2 = [1]
输出：1.00000

示例 5：
输入：nums1 = [2], nums2 = []
输出：2.00000

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

一、暴力解法(加到一个数组里，然后排序，然后根据奇偶算中位数)

class Solution {
    public  double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int a = nums1.length;
        int b = nums2.length;
        int[] num = new int[a+b];
        System.arraycopy(nums1,0,num,0,a);
        System.arraycopy(nums2,0,num,a,b);
        List<BigDecimal> list = new ArrayList();
        for (int i = 0; i < num.length; i++) {
            list.add(new BigDecimal(num[i]));
        }
        Collections.sort(list);
        //说明是双数的
        int m  = (list.size() / 2) - 1;
        if (list.size() % 2 == 0){
            return new Double((list.get(m).add(list.get(m+1)).divide(new BigDecimal(2))).toString());
        }else {
            return new Double(list.get(m + 1).toString());
        }
    }
}

二、归并法（需要学一下分治和归并排序）

2.1 归并排序 首先需要两个已经排序好的数组，然后创建一个两个数组长度之和的新数组，然后遍历，添加进去。如果是无序数组，那么先用分治的方法排序后再归并。

public class D_Solution {
    public static void main(String[] args) {
        int[] arr = {2,5,3,10,1,8,6,7};
        int L = 0;
        int R = arr.length - 1;
        int M = (L + R) / 2 + 1;
        mergeSort(arr,L,R);
        System.out.println(Arrays.toString(arr));
    }


    /**
     * 分治
     */
    public static void mergeSort(int[] arr,int L,int R){
        if (L == R){
            return;
        }else {
            int M = (L + R) / 2;
            mergeSort(arr,L,M);
            mergeSort(arr,M+1,R);
            merge(arr,L,M+1,R);
        }
    }

    /**
     * 归并
     */
    public static void merge(int[] arr,int L,int M,int R){
        int left_size = M - L;
        int right_size = R - M + 1;
        int[] leftArray = new int[left_size];
        int[] rightArray = new int[right_size];
        //把数组分成左边和右边两部分
        for (int l = L; l < M; l++) {
           leftArray[l - L] = arr[l];
        }
        for (int l = M; l <= R; l++) {
            rightArray[l - M] = arr[l];
        }
        //开始排序
        int i = 0,j = 0,k = L;
        while (i < left_size && j < right_size){
            if (leftArray[i] < rightArray[j]){
                arr[k++] = leftArray[i++];
            }
            else {
                arr[k++] = rightArray[j++];
            }
        }
        while (i < left_size){
            arr[k++] = leftArray[i++];
        }
        while (j < right_size){
            arr[k++] = rightArray[j++];
        }

    }
}