数据结构与算法[LeetCode]—两个有序数组合并及找中点问题

题一：Merge Sorted Array

Given two sorted integer arrays A and B, merge B into A as one sorted array.

Note:

You may assume that A has enough space (size that is greater or equal to m + n) to hold additional elements from B. The number of elements initialized in A and B are m and n respectively.

分析：

两个有序数组合并是一个典型算法。

如果用B一直向A正向插入，会导致A每次都需要向后挪动的问题，效率很低。

换一个思路：

A和B 均从最后开始比较大小，计算好位置，从后面开始挪动，保证每次比较后，当前值一次挪动到位，不需要多次移动。

代码如下：

class Solution{
public:
void merge(int A[],int m,int B[],int n){
int last=m+n-1;
int duration=0;          //排好序的数目（倒着插入，离最末尾的距离）
while(n!=0){
if(m==0){          //A数组已经比较结束，将B剩余数组项全部插入
A[last-duration]=B[n-1];
n--;
duration++;
continue;
}
if(B[n-1]>=A[m-1]){     //数组B当前值大，向后插入
A[last-duration]=B[n-1];
n--;
duration++;       //离末尾index的距离
}
else{                 //数组A当前值大，向后移动
A[last-duration]=A[m-1];
m--;
duration++;
}
}

//n==0 说明B数组已经完全插入A结束

return;
}
};

题二：Median of Two Sorted Arrays

There are two sorted arrays A and B of size m and n respectively. Find the median of the two sorted arrays. The overall run time complexity
should be O(log (m+n)).

分析：该题是一个经典题型。更加通用的是找出合并后第K位数的大小。

复杂度为O（m+n），直接两个有序数组合并，然后找出第K位。

需要找出第K位，我们并非需要合并，极大浪费空间。可以直接用计数器K。用pa，pb记录两个数组的当前值，依次进行比较，计数即可。在第K次时就是要找到的数。但是当K->m或n时，复杂度->O(m+n)，并非最佳。

可以说前面每次排除的是1位，但是我们可以尝试每次排除第K位前一半值，不断递归缩减两个数组，直到终止条件。A，B有序。前K位是由A，B前K位中的一部分构成。那么比较A和B的第K/2位元素(A[k/2-1],B[k/2-1])，小的那一部分一定会在合并后的前K位。那么，就可以将这一部分数组项去掉（假设有i项），那么在剩下的数组中就可以找合并后的第K-i位。依次递归，临界退出条件如下：

如果A或B为空，返回B[K-1]或A[k-1]

如果K=1，返回 min（A[0],B[0]）

如果A[k/2-1

]==B[k/2-1]，返回A[k/2-1]或B[k/2-1]
（注意1：由于k的奇偶问题，k/2+k/2 不一定等于 k，所以临界3中返回的值不一定是所需要的第k位，很可能是第k-1位，需要特殊处理）
（注意2：在本题中k为中点k=(m+n+1)/2 ，但是k/2 很可能大于m或n，出现A[k/2-1]或B[k/2-1]数组越界，那么需要假设A或B总为项数多的一方）

代码如下：

class Solution{
public:
double findMedianSortedArrays(int A[],int m,int B[],int n){
if((m+n)%2==0){   //m+n 为偶数
return (find_kth(A,m,B,n,(m+n)/2)+find_kth(A,m,B,n,(m+n)/2+1))/2;  //若总数为偶数，返回中间两个数的均值
}else   //m+n 为奇数，返回中间数的值
return find_kth(A,m,B,n,(m+n+1)/2);
}
private:
double find_kth(int A[],int m,int B[],int n,int k){
if(m>n) return find_kth(B,n,A,m,k);  //考虑到可能m+n的一半大于m,n中的小者，假定B数组长

if(m==0)return B[k-1];
if(n==0)return A[k-1];
if(k==1)return A[0]<=B[0]?A[0]:B[0];

int pa=min(m,k/2),pb=k-pa;    //pa 和 pb 在有些时候不等，相差1。例如m=3,n=3,k=3。解决奇偶问题。

if(A[pa-1]==B[pb-1])return A[pa-1];
if(A[pa-1]>B[pb-1]){
return find_kth(A,m,B+pb,n-pb,k-pb);
}
if(A[pa-1]<B[pb-1]){
return find_kth(A+pa,m-pa,B,n,k-pa);
}

}
};

本文参考：
学习了戴方勤的 项目 https://gitcafe.com/soulmachine/LeetCode 书籍
向牛人致敬！