Median of Two Sorted Arrays

Author: evagle

.gitignore

@@ -12,3 +12,7 @@
 *.la
 *.a
 *.out
+
+.c9revisions/
+.settings
+.idea/

analysis/median-of-two-sorted-arrays.md

@@ -0,0 +1,47 @@
+@file two-sum.md  
+@author  Brian  
+@version 1.0  
+@date 2014-09-11  
+
+
+##Median of Two Sorted Arrays [ [sourcecode](../src/MedianofTwoSortedArrays.cpp) | [problem](https://oj.leetcode.com/problems/median-of-two-sorted-arrays/) ]
+
+##分析
+题意很简单：给定两个已排序的数组，求两个数组合并之后的数组的中位数。如果是总个数是奇数个，那就是最中间的那个，如果是偶数个，那就求最中间的两个的平均值。 要求在O(lg(m+n))时间内求出。
+
+#### 方法1：排序
+如果不考虑时间空间限制，可以采用排序方法，将两个数组合并，然后排序，然后直接O(1)时间获得结果。
+排序方法的选择。如果选择快速排序，复杂度是nlogn。但最优的是选择归并排序，此处只须用到归并排序的合并步骤。边合并边计数，到 m+n/2 就答案。时间复杂度O(m+n),空间复杂度O(1).
+
+#### 方法2：找第K大数法
+找中位数可以泛华为找第K大数，中位数就是第(m+n)/2+1大得数（奇数个数的情况）。下面讨论如何找第K大数。
+核心思路是竟可能快的把第K+1以后的数全部排除，剩下K个数，那两个数组中最大的就是结果。如何排除呢？
+
+1. 将数目较少的数组记为A数组  
+2. 取A中得前p个数，B中前q个数，使得p+q=k+1. 其中，p=min(k/2+1,len(A)), q = k+1-p。这样的做法的好处是，尽量使得p和q相近。
+3. 如果A[p-1] < B[q-1],说明B[q-1]肯定比第K大数大，因为A[0..p-1]和B[0..q-2]都小于B[q-1]，总共p+q-1=k个。
+4. 将B[q-1...n]都去除，再从第一步1开始递归。
+5. 反之，如果A[p-1] > B[q-1]，将A[p-1...m]都去除，从第一步1开始递归。
+6. 如果相等，说明第K大和第K+1大的数相等，A[p-1] ，B[q-1]其中一个第K大，另一个第K+1大。直接返回A[p-1]或者B[q-1]。
+
+现在考虑停止条件:
+
+1. 当出现A[p-1] = B[q-1]时，直接返回结果。
+2. 如果A数组（较短的数组）已经为空，那么返回B[k]
+3. 如果m+n=k,m为A的长度，n为B的长度；说明所有的大于第k大数的都被剔除了，剩下前k大得数，返回最大值max(A[m-1],B[n-1])。
+   
+
+##坑：
+注意p的取值，p取值时需要考虑不能使得q大于B数组的长度。p如果取min(k/2,m)的时候，就会出现死循环。例子是A={1,2,2}, B={1,2,3}. 
+	
+	1. 第一次k=3， p=1，q=3，把B的最后一个数移除
+	2. 第二次递归：A={1,2}, B={1,2,2}；k=3， p=1，q=3；将最后的B最后的2移除了。
+	3. 然后再次递归：A=B={1，2}；k=3， p=1，q=3；结果B现在只有两个数，出错了。因为p取值的时候会有判断p=min(k/2,m),使得p不会超过m，但是q没有限制，所以需要让p=min(k/2+1,m),这样q无论如何都不会出现大于n的情况。
+	
+		证明如下:
+		先考虑m<=k/2+1的情况，那p=m, m+n>=k+1(如果m+n==k满足终止条件就结束了) -> p+n>=k+1 -> k+1-q+n>=k+1 -> q<=n，符合条件。
+		然后考虑m>k/2+1的情况，p = k/2+1,如果k为奇数，q=k/2, 因为程序始终保证A是较少的数组，所以n>=m>k/2+1>k/2=q；如果k是偶数，q = k/2-1 < k/2+1<m<=n。所以无论如何q<n.
+		综上，若p=min(k/2+1, m) ,则满足q<n.
+		
+
+

src/MedianofTwoSortedArrays.cpp

@@ -0,0 +1,71 @@
+#include <iostream>
+
+using namespace std;
+class Solution {
+public:
+    // 核心思想是去掉A，B中比Kth大得所有数
+    double findMedianSortedArrays(int A[], int m, int B[], int n) {
+        // 如果m+n是奇数，找最中间的数
+		if ((m + n) & 0x1) {
+            return findKth(A, m, B, n, (m + n) / 2 + 1);
+        } else { // 如果m+n是偶数，找最中间的两个取平均值
+            return (findKth(A, m, B, n, (m + n) / 2) + 
+                    findKth(A, m, B, n, (m + n) / 2 + 1)) / 2;
+        }
+    }
+    double findKth(int A[], int m, int B[], int n, int k)
+    {
+		//cout<<m<<", "<<n<<endl;
+        // 保证A数组是更短的一个
+        if (m > n) 
+            return findKth(B, n, A, m, k);
+        // m = 0,说明A数组空了，那么就从B中找第K大的
+        if (m == 0)
+            return B[k-1];
+	 
+        // 如果已经排除掉m+n-k+1个元素，现在只剩下K个，那两个数组中最大数中更大得
+        if (m + n <= k) {
+            return std::max(A[m-1], B[n-1]);
+        }
+        /** 
+		* p取其中k/2+1和m中的小值, 
+		* 注意需要取k/2+1，因为q的取值没有限制，需要保证q满足q<m
+		* 如果p取k/2,当k为奇数时，q就可能会小于m，
+		* 例子:A={1,2,2}, B={1,2,3}, p,q会一直是1，3，出现死循环  
+		*/
+        int p = std::min(k/2+1, m);
+        int q = k - p + 1;
+		/**
+		* 如果A[p-1] < B[q-1],
+		* A[0..p-1]和B[0..q-2]都小于B[q-1]
+		* 总共p+q-1=k个，所以有k个数小于B[q-1]，所以B[q-1]不可能是第K大
+		* 将B[q-1..m]删除, 递归查找A[0..m]~B[0..q-1]
+		*
+		* A[p-1] < B[q-1]类似
+		*
+		* 如果相等，说明第K大和第K+1大的数相等，A[p-1] ，B[q-1]其中一个第K大，另一个第K+1大.
+		* 直接返回A[p-1]
+		*/
+        if (A[p-1] < B[q-1]) 
+            return findKth(A, m, B, q-1, k);
+        else if (A[p-1] > B[q-1]) 
+            return findKth(A, p-1, B, n, k);
+        else 
+            return A[p-1];
+    }
+	void p(int a[], int n)
+	{
+		for (int i = 0; i < n; i++) {
+			cout<<a[i]<<"  ";
+		}	 
+		cout<<endl;
+	}
+};
+
+
+int main(int argc, char *argv[]) {
+	int A[] = {1,2,2};
+	int B[] = {1,2,3};
+	Solution s;
+	cout<<s.findMedianSortedArrays(A,3,B,3);
+}