swift算法：寻找两个有序数组中的中位数

描述：

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

num1 = [1,3]
num2 = [2]
中位数为：2.0

示例 2:

num1 = [1,2]
num2 = [3,4]
中位数是：（2+3）/2 = 2.5

什么是中位数？

答：中位数，又称中点数，中值。中位数是按顺序排列的一组数据中居于中间位置的数，即在这组数据中，有一半的数据比他大，有一半的数据比他小。

中位数的作用是什么？

答：将一个集合划分为两个长度相等的子集，其中一个子集中的元素总是大于另一个子集中的元素。

 

解法一：

思路：

1）将两个数组合并为一个数组，并排序

2）数组的最大下标除以2求余

    余数为0时，数组个数为奇数，中位数为最中间的数

    反之，数组个数为偶数，中位数为中间两位数之和的一半

时间复杂度 O(m+n)

具体实现：

func findMedianSortedArrays(_ nums1: [Int], _ nums2: [Int]) -> Double {
        //思路，将两个数组拷贝至同一个数组中，然后排序，找出中位数
        
        var allArr : NSMutableArray = NSMutableArray.init(array: nums1)
        allArr.addObjects(from: nums2)
         //排序
        allArr.sort { (obj1, obj2) -> ComparisonResult in
            let num1 : Int = obj1 as! Int
            let num2 : Int = obj2 as! Int
             if num1 > num2{
                 return ComparisonResult.orderedDescending
             }else{
                 return ComparisonResult.orderedAscending 
             }
          }
       
        //根据下标找出中位数
        if ((allArr.count-1)%2) == 0{
            return allArr[(allArr.count-1)/2] as! Double
        }else{
            let flag = (allArr.count-1)/2
            return Double((allArr[flag] as! Int)+(allArr[flag+1] as! Int))/2
        }
    }

 

解法二：递归法

思路：

将两个数组合并后的长度划分为两个等长长度，若是多了一位则多的一位位于右边，分别去查找到左右两边对应的k值。这两个k值之和的一半即为所求的中位数，这种查找方式归类于二分查找

m为第一个数组的长度，n为第二个数组的长度

1）当m和n均为偶数时

左边的k值 一般是数组的最后一个数

右边的k值，一般是数组的第一个数

中位数为 两个k值之和的一半

2）当m和n一个为偶数，一个为奇数时

m>n时，中位数为第一个数组的最后一个数

m<n时，中位数为第二个数组的第一个数

 

时间复杂度：O(log(m+n))

具体实现：

    func findMedianSortedArrays(_ nums1: [Int], _ nums2: [Int]) -> Double {
        //思路--递归法
        
        let m : Int = nums1.count
        let n : Int = nums2.count
        //用m+n+1 的原因是，当m+n为奇数，多出的一个位于左边
        var left : Int = (m+n+1)/2
        var right : Int = (m+n+2)/2
        return Double(findKth(nums1, 0, nums2, 0, left)+findKth(nums1, 0, nums2, 0, right))/2.0
    }
    //寻找第k个元素
    func findKth(_ nums1: [Int], _ i : Int, _ nums2: [Int], _ j : Int, _ k : Int)->Int{
        //递归终止条件
        if (i>=nums1.count) {
            return nums2[j+k-1]
        }
        if (j>=nums2.count){
            return nums1[i+k-1]
        }
        if k==1 {
            return min(nums1[i],nums2[j])
        }
        
            
         //判断以i为起始位置，第k/2个元素，是否在数组内
        let n = i+k/2-1
        var midVal1 : Int!
        if n<nums1.count {
            midVal1 = nums1[n]
        }
        else{
            midVal1 = nums1[nums1.count-1]
        }
        //判断以j为起始位置，第k/2个元素，是否在数组内
        let m = j+k/2-1
        var midVal2 : Int!
        if m<nums2.count {
            midVal2 = nums2[m]
        }
        else{
            midVal2 = nums2[nums2.count-1]
        }
        
        //比较得到的两个数
        if midVal1<midVal2{
            if n<nums1.count {
                //移除了最小的一半元素后，k减少k/2
                return findKth(nums1, i+k/2, nums2, j, k-k/2)
            }
            else{
                return nums2[k-nums1.count-i-1]
            }
        }else{
           if m<nums2.count {
                //移除了最小的一半元素后，k减少k/2
                return findKth(nums1, i, nums2, j+k/2, k-k/2)
            }
            else{
                return nums1[k-nums2.count-j-1]
            }
        }
    }
    
    func min(_ a : Int, _ b : Int)->Int{
        return a<b ? a : b
    }

 

注：若算法有错，请留言纠正，算法的语法均用的swift语言编写