Leetcode Median of Two Sorted Arrays

这是一道比较难的题目，因为正常考虑的话，想在面试中解出这道题，你必须知道在两个有序数组中找第K大数的程序，然后利用那程序来解出这道题，详细如下：

class Solution {
private:
    int findKth(int A[], int m, int B[], int n, int k){
        int i = static_cast<int>(static_cast<double>(m)/(m + n) * k),
            j = k - i,
            Ai_1 = i == 0 ? INT_MIN : A[i-1],
            Ai = i == m ? INT_MAX : A[i],
            Bj_1 = j == 0 ? INT_MIN : B[j-1],
            Bj = j == n ? INT_MAX : B[j];
        if(Ai_1 <= Bj && Bj <= Ai){
            return Bj;
        }
        if(Bj_1 <= Ai && Ai <= Bj){
            return Ai;
        }   
        if(Ai < Bj){
            return findKth(A + i + 1, m - i - 1, B, n, k - 1 - i);
        }else{
            return findKth(A, m, B + j + 1, n - j - 1, k - 1 - j);
        }
    }
public:
    double findMedianSortedArrays(int A[], int m, int B[], int n) {
        if((m + n) & 1){
            return findKth(A,m,B,n,(n+m)/2);    
        }else{
            return (findKth(A,m,B,n,(n+m)/2-1) + findKth(A,m,B,n,(n+m)/2)) / 2.0;    
        }
    }
};

上述缺点是要对偶数情形要进行二次计算，如果只想进行一次计算，程序如下，但面试时候肯定写不出

class Solution {
public:
    double findMedianBaseCase(int med, int C[], int n) {
  if (n == 1)
    return (med+C[0])/2.0;
 
  if (n % 2 == 0) {
    int a = C[n/2 - 1], b = C[n/2];
    if (med <= a)
      return a;
    else if (med <= b)
      return med;
    else /* med > b */
      return b;
  } else {
    int a = C[n/2 - 1], b = C[n/2], c = C[n/2 + 1];
    if (med <= a)
      return (a+b) / 2.0;
    else if (med <= c)
      return (med+b) / 2.0;
    else /* med > c */
      return (b+c) / 2.0;
  }
}
 
double findMedianBaseCase2(int med1, int med2, int C[], int n) {
  if (n % 2 == 0) {
    int a = (((n/2-2) >= 0) ? C[n/2 - 2] : INT_MIN);
    int b = C[n/2 - 1], c = C[n/2];
    int d = (((n/2 + 1) <= n-1) ? C[n/2 + 1] : INT_MAX);
    if (med2 <= b)
      return (b+max(med2,a)) / 2.0;
    else if (med1 <= b)
      return (b+min(med2,c)) / 2.0;
    else if (med1 >= c)
      return (c+min(med1,d)) / 2.0;
    else if (med2 >= c)
      return (c+max(med1,b)) / 2.0;
    else  /* a < med1 <= med2 < b */
      return (med1+med2) / 2.0;
  } else {
    int a = C[n/2 - 1], b = C[n/2], c = C[n/2 + 1];
    if (med1 >= b)
      return min(med1, c);
    else if (med2 <= b)
      return max(med2, a);
    else  /* med1 < b < med2 */
      return b;
  }
}
 
double findMedianSingleArray(int A[], int n) {
  assert(n > 0);
  return ((n%2 == 1) ? A[n/2] : (A[n/2-1]+A[n/2])/2.0);
}
 
double findMedianSortedArrays(int A[], int m, int B[], int n) {
  assert(m+n >= 1);
  if (m == 0)
    return findMedianSingleArray(B, n);
  else if (n == 0)
    return findMedianSingleArray(A, m);
  else if (m == 1)
    return findMedianBaseCase(A[0], B, n);
  else if (n == 1)
    return findMedianBaseCase(B[0], A, m);
  else if (m == 2)
    return findMedianBaseCase2(A[0], A[1], B, n);
  else if (n == 2)
    return findMedianBaseCase2(B[0], B[1], A, m);
 
  int i = m/2, j = n/2, k;
  if (A[i] <= B[j]) {
    k = ((m%2 == 0) ? min(i-1, n-j-1) : min(i, n-j-1));
    assert(k > 0);
    return findMedianSortedArrays(A+k, m-k, B, n-k);
  } else {
    k = ((n%2 == 0) ? min(m-i-1, j-1) : min(m-i-1, j));
    assert(k > 0);
    return findMedianSortedArrays(A, m-k, B+k, n-k);
  }
 }
};