题目不难，关键是边界条件要想清楚。先写一个时间复杂度为O(K) 的解法。

#include

using namespace std;

//a[] increase

//b[] decrease

//use ret_value to return the result

//function ret reprsent the error if not 0

int find_k(int a[], int b[], int m, int n, int k, int& ret_value) {

if(k<=0 || m<0 || n<0 || k>(m+n)) {

return -1;

}

int i = 0, x = m-1, y = 0;

while (i=0 && y<=n-1) {

if (a[x] > b[y]) {

ret_value = a[x];

i++;

x--;

} else if (a[x]

ret_value = b[y];

i++;

y++;

} else { //equal

ret_value = a[x];

i+=2;

x--;

y++;

}

}

cout <

<

<

<

i = k-i;

if (i > 0) {

if (x<0) {

ret_value = a[y+i-1];

} else if (y > n-1) {

ret_value = a[x-i+1];

}

}

return 0;

}

int main () {

int a[] = {1,2,3};

int b[] = {6,5,3};

int k=0;

cout <

cin >> k;

int value = -1;

find_k(a,b,3,3,k,value);

cout <

return 0;

}

再附上一个时间复杂服为O(log n)的算法实现，

算法思想是：

每次从两个数组里数 k/2 个数，比较其大小，较大的那个数所在的数组里这 k/2 个数， 肯定在前k大个数里面；

这样就排除了k/2个数，然后再在剩下的数里面找第k/2大的数，循环到找到最后一个数为止。

为了简化一下，假设两个数组都为降序。

注意程序的31~34行，如果不判断相等，当最后还剩一个数的时候，第20行mid_b = pb + kb -1;mid_b 会被赋值为一个错误的位置，导致程序陷入死循环//both a[] b[] decrease

int find_k_both_increase_O_log_k(int a[], int b[], int m, int n, int k, int& ret_value) {

if(k<=0 || m<0 || n<0 || k>(m+n)) {

return -1;

}

int ka = 0;

int kb = 0;

int pa = 0;

int pb = 0;

int mid_a = 0;

int mid_b = 0;

int i = k;

while (i>0 && pa

ka = i/2;

kb = i-ka;

mid_a = pa + ka -1;

mid_b = pb + kb -1;

if (mid_a

if (a[mid_a] > b[mid_b]) {

ret_value = a[mid_a];

pa = mid_a + 1;

i = i - ka;

} else if (a[mid_a]

ret_value = b[mid_b];

pb = mid_b + 1;

i = i - kb;

} else { //equal

ret_value = a[mid_a];

return 0;

}

}

cout <

<

<

cout <

}

if (i > 0) {

if (pa > m-1) {

ret_value = a[pb-1+i];

} else if (pb > n-1) {

ret_value = a[pa-1+i];

}

}

return 0;

}

在leetcode上碰到该题的改进版本，被标识为hard，看起来简单的题目，其实不简单。

附上题目和代码如下：

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大个数，和我上面一个稍微有点不同，写起来很多边界条件，回头多看几遍。int find(int A[], int m, int B[], int n, int k) {

if (m==0) {

return B[k-1];

}

if (n==0) {

return A[k-1];

}

int pa=0, pb=0;

int sa=0, sb=0;

int ka=0, kb=0;

while (k>1 && sa

ka = k/2;

kb = k-ka;

pa = sa + ka -1;

pb = sb + kb -1;

if (pa >= m) {

pa = m-1;

ka = m-sa;

kb = k-ka;

pb = sb + kb -1;

} else if (pb >= n) {

pb = n-1;

kb = n-sb;

ka = k - kb;

pa = sa + ka -1;

}

if (A[pa] > B[pb]) {

k = ka;

sb = pb+1;

} else if (A[pa]

k = kb;

sa = pa+1;

} else { //A[pa] == B[pb]

return A[pa];

}

}

if (sa>=m) {

return B[sb+k-1];

} else if (sb >= n) {

return A[sa+k-1];

}

if (k == 1) {

return A[sa]

}

}

class Solution {

public:

double findMedianSortedArrays(int A[], int m, int B[], int n) {

int k=(m+n+1)/2;

if ((m+n)&1) {

return find(A, m, B, n, k);

} else {

return (double)(find(A, m, B, n, k) + find(A, m, B, n, k+1))/2;

}

}

};