double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
int n = nums1.size() + nums2.size();
if (n == 0) return 0;
if (n % 2)
return findMedianSortedArrays(nums1.begin(), nums1.size(), nums2.begin(), nums2.size(), n / 2 + 1);
else
return (findMedianSortedArrays(nums1.begin(), nums1.size(), nums2.begin(), nums2.size(), n / 2) + findMedianSortedArrays(nums1.begin(), nums1.size(), nums2.begin(), nums2.size(), n / 2 + 1)) / 2.0;
}
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
int total = nums1.size() + nums2.size();
if (total % 2) {
return findMedianSortedArrays(nums1, nums2, nums1.size(), nums2.size(), (total + 1) / 2);
} else {
return (findMedianSortedArrays(nums1, nums2, nums1.size(), nums2.size(), total / 2 + 1) +
findMedianSortedArrays(nums1, nums2, nums1.size(), nums2.size(), total / 2)) / 2;
}
}
double findMedianSortedArrays(Iter iter1, int n1, Iter iter2, int n2, int k) {
if (n1 > n2)
return findMedianSortedArrays(iter2, n2, iter1, n1, k);
if (n1 == 0) return *(iter2 + k - 1);
if (k == 1) return min(*iter1, *iter2);
int m1 = min(n1, k / 2), m2 = k - m1;
if (*(iter1 + m1 - 1) < *(iter2 + m2 - 1))
return findMedianSortedArrays(iter1 + m1, n1 - m1, iter2, n2, k - m1);
else
return findMedianSortedArrays(iter1, n1, iter2 + m2, n2 - m2, k - m2);
}
int main(int argc, char const *argv[]) {
int nums1[] = {1, 3};
int nums2[] = {2};
double median1 = findMedianSortedArrays(nums1, 2, nums2, 1);
printf("%lf\n", median1);
assert(median1 == 2.0);
int nums3[] = {1, 2};
int nums4[] = {3, 4};
double median2 = findMedianSortedArrays(nums3, 2, nums4, 2);
printf("%lf\n", median2);
assert(median2 == 2.5);
return 0;
}
double findMedianSortedArrays(vector<int> nums1, vector<int> nums2, int m, int n, int k) {
if (m > n) return findMedianSortedArrays(nums2, nums1, nums2.size(), nums1.size(), k);
if (m == 0) return nums2[k-1];
if (k == 1) return min(nums1[0], nums2[0]);
int p1 = min((int)nums1.size(), k/2);
int p2 = k - p1;
if (nums1[p1 - 1] < nums2[p2 - 1]) {
return findMedianSortedArrays(vector<int>(nums1.begin() + p1, nums1.end()), nums2, m - p1, n, k - p1);
} else if (nums1[p1 - 1] > nums2[p2 - 1]) {
return findMedianSortedArrays(nums1, vector<int>(nums2.begin() + p2, nums2.end()), m, n - p2, k - p2);
} else {
return nums1[p1-1];
}
}
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
int n = nums1.size(), m = nums2.size();
if(n > m) {
return findMedianSortedArrays(nums2, nums1);
}
int left = 0, right = n;
while(left <= right){
int i = (left + right)>>1;
int j = (n + m + 1)/2 - i;
int l1 = i > 0 ? nums1[i - 1] : INT_MIN;
int r1 = i < n ? nums1[i] : INT_MAX;
int l2 = j > 0 ? nums2[j - 1] : INT_MIN;
int r2 = j < m ? nums2[j] : INT_MAX;
if(l1 > r2) {
right = i - 1;
} else if(r1 < l2) {
left = i + 1;
} else {
return (n + m)%2 == 0 ? (double)(max(l1, l2) + min(r1, r2))/2.0 : max(l1, l2);
}
}
return 0;
}
int main() {
// Use a merge style algorithm by walking through two pointers from
// beginning to end of each vector in sorted order and stopping once
// half of the total size has been traversed
for (int totalSize = 1; totalSize < 100; ++totalSize) {
std::vector<int> v;
for (int i = 0; i < totalSize; ++i) {
v.push_back(rand() % 100);
}
std::sort(v.begin(), v.end());
double trueMedian = middleOf(v);
std::vector<int> v1, v2;
for (auto x : v) {
if (rand() % 2) {
v1.push_back(x);
} else {
v2.push_back(x);
}
}
std::sort(v1.begin(), v1.end());
std::sort(v2.begin(), v2.end());
assert(findMedianSortedArrays(v1, v2) == trueMedian);
}
return 0;
}
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
int m = nums1.size(), n = nums2.size();
if(m > n)
return findMedianSortedArrays(nums2, nums1);
int i, j, low = 0, high = m, mid1, mid2, a, b;
while(low <= high) {
i = low + (high - low) / 2;
j= (m + n + 1) / 2 - i;
if(j > 0 && i < m && nums2[j - 1] > nums1[i])
low = i + 1;
else if(i > 0 && j < n && nums1[i - 1] > nums2[j])
high = i - 1;
else
break;
}
a = i == 0 ? INT_MIN : nums1[i - 1];
b = j == 0 ? INT_MIN : nums2[j - 1];
mid1 = max(a, b);
if((m + n) & 1)
return mid1;
a = i == m ? INT_MAX : nums1[i];
b = j == n ? INT_MAX : nums2[j];
mid2 = min(a, b);
return (mid1 + mid2) / 2.0;
}
int main() {
srand(time(NULL));
int n = 0, m = 4;
int a[n], b[m];
genArray(a, n);
genArray(b, m);
sort(a, a+n);
sort(b, b+m);
printArray(a, n);
printArray(b, m);
int c[n+m];
int p = 0, p1 = 0, p2 = 0;
while(p1 < n || p2 < m){
if(p1 >= n || (p2 < m && b[p2] < a[p1]))
c[p++] = b[p2++];
else
c[p++] = a[p1++];
}
printArray(c, n+m);
// cout<<c[n]<<endl;
cout<<findMedianSortedArrays(a, n, b, m)<<endl;
return 0;
}
//O(log (min(m,n)))
//http://blog.csdn.net/u010738052/article/details/50450153
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
int m = nums1.size(), n = nums2.size();
if (m > n) return findMedianSortedArrays(nums2, nums1);
int imin = 0, imax = m;
int i = 0, num1, num2;
while (imin <= imax)
{
int i = (imin + imax) / 2;
int j =((m + n + 1) >> 1) - i;
if (j > 0 && i < m && nums2[j - 1] > nums1[i])
imin = i + 1;
else if (i > 0 && j < n && nums1[i - 1] > nums2[j])
imax = i - 1;
else {
if (i == 0)
num1 = nums2[j - 1];
else if (j == 0)
num1 = nums1[i - 1];
else num1 = max(nums1[i - 1], nums2[j - 1]);
if ((m + n) % 2 == 1)
return num1;
if (i == m)
num2 = nums2[j];
else if (j == n)
num2 = nums1[i];
else
num2 = min(nums1[i], nums2[j]);
return (num1 + num2) / 2.0;
}
}
}
double findMedianSortedArrays(int A[], int m, int B[], int n) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if(m==0&&n!=0)
return mid(B, n);
if(n==0&&m!=0)
return mid(A, m);
if(m==1&&n==1)
return ((double)A[0] + (double)B[0])/2;
int midA = mid(A, m);
int midB = mid(B, n);
int* bigger;
int* smaller;
int big, small;
if(midA>midB)
{
bigger = A;
big = m;
smaller = B;
small = n;
}
else
{
bigger = B;
big = n;
smaller = A;
small = m;
}
int bigarr[1000], smallarr[1000];
cutleft(bigger, big, bigarr);
cutright(smaller, small, smallarr);
return findMedianSortedArrays(bigarr, big/2, smallarr, small/2); //DON'T MISS THE RETURN
}
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
if(nums1.empty() && nums2.empty())
return 0;
if(nums1.size() > nums2.size())
return findMedianSortedArrays(nums2, nums1);
int midIdx = (nums1.size() + nums2.size()) / 2;
}
int main(void)
{
int array1[] = {1, 2, 3, 7, 9, 10};
int array2[] = {4, 5, 6, 8};
double result;
int i;
result = findMedianSortedArrays(array1, ARRAY_SIZE(array1), array2, ARRAY_SIZE(array2));
for(i = 0; i < ARRAY_SIZE(array1); i++)
{
printf("%d ", array1[i]);
}
printf("\n");
for(i = 0; i < ARRAY_SIZE(array2); i++)
{
printf("%d ", array2[i]);
}
printf("\n");
printf("result = %f\n", result);
return 0;
}
void run4() {
int nums1Size = arc4random()%20;
int nums2Size = arc4random()%20;
int * nums1 = sortedArray(nums1Size);
int * nums2 = sortedArray(nums2Size);
double result = findMedianSortedArrays(nums1, nums1Size, nums2, nums2Size);
printf("median_of_two_sorted_arrays_test %lf", result);
}
double findMedianSortedArrays(int A[], int m, int B[], int n) {
if(m<=0) return mid(B,n);
if(n<=0) return mid(A,m);
if(m>n) return findMedianSortedArrays(B,n,A,m);
if(m==1)
{
return mid2(A[0],B,n);
}
if(A[0]<=B[0] && A[m-1]>=B[n-1])
return findMedianSortedArrays(&A[1],m-2,B,n);
else if (B[0]<=A[0] && B[n-1]>=A[m-1])
return findMedianSortedArrays(A,m, &B[1],n-2);
double aMid = mid(A,m);
double bMid = mid(B,n);
if(aMid==bMid)
return aMid;
else if(aMid<bMid)
{
if((m&1)==0 && m!=2)
return findMedianSortedArrays(&A[m/2-1],m-(m/2-1), B, n-(m/2-1));
else
return findMedianSortedArrays(&A[m/2],m-m/2, B, n-m/2);
}
else
{
if(m!=2)
return findMedianSortedArrays(A,m/2+1, &B[m-(m/2+1)] ,n-(m-(m/2+1)));
else
return findMedianSortedArrays(A,1, &B[1] ,n-1);
}
}
int main(int argc, char* argv)
{
int nums1[] = {1, 2};
int nums2[] = {3, 4};
int* res = findMedianSortedArrays(nums1, 2, nums1, 2);
printf("%d %d\n", res);
return 0;
}
void MedianOfTwoSortedArrays::TestClass()
{
int Array1[1]={};
int Array2[2]={2,3};
vector<int> nums1(Array1,Array1);
vector<int> nums2(Array2,Array2+2);
double res=findMedianSortedArrays(nums1,nums2);
cout<<"median="<<res<<endl;
}
int main(int argc, char **argv)
{
int arr1[] = {1, 3, 4, 5, 6, 7, 8},
arr2[] = {2, 3, 4, 5, 7};
double res;
res = findMedianSortedArrays(arr1, 7, arr2, 5);
printf("%f\n", res);
return 0;
}
int main(int argc, char *argv[])
{
int n1[] = {};
int n2[] = {1};
printf("%.2f\n", findMedianSortedArrays(n1, sizeof(n1) / 4, n2, sizeof(n2) / 4));
int n3[] = {};
int n4[] = {2, 3};
printf("%.2f\n", findMedianSortedArrays(n3, sizeof(n3) / 4, n4, sizeof(n4) / 4));
int n7[] = {1};
int n8[] = {1};
printf("%.2f\n", findMedianSortedArrays(n7, sizeof(n7) / 4, n8, sizeof(n8) / 4));
int n5[] = {1, 2};
int n6[] = {1, 2};
printf("%.2f\n", findMedianSortedArrays(n5, sizeof(n5) / 4, n6, sizeof(n6) / 4));
}
int main(int argc, char **argv)
{
int nums1[] = {1,2,3,4,5,6,7,8,9,10};
int nums2[] = {2,4,6,8,10};
double median = findMedianSortedArrays(nums1, 10, nums2, 5);
printf("%lf\n", median);
return 0;
}
double findMedianSortedArrays(int A[], int m, int B[], int n) {
if (m>n){
return findMedianSortedArrays(B, n, A, m);
}
if (m < 2){
if (m == 0) return (B[(n-1)/2] + B[n/2])/2.0;
if (m == 1){
if (n & 1){
if (n == 1){
return (A[0] + B[0]) / 2.0;
}
int x = B[n/2-1], y = B[n/2+1], z = B[n/2];
if (A[0] < x) return (x + z)/2.0;
if (A[0] < y) return (A[0] + z)/2.0;
return (z + y)/2.0;
}else{
int x = B[(n-1)/2], y = B[n/2];
if (A[0] < x) return x;
if (A[0] > y) return y;
return A[0];
}
}
}
int xa = 0, ya = 0, xb = 0, yb = 0;
if(A[(m-1)/2] < B[(n-1)/2]){
xa = m/2;
}else{
xb = n/2;
}
if (A[m/2] > B[n/2]){
ya = m/2;
}else{
yb = n/2;
}
if (xa != ya){
xa = min(xa, yb);
xb = min(xb, ya);
ya = min(ya, xb);
yb = min(yb, xa);
}
return findMedianSortedArrays(A+xa,m-xa-ya, B+xb, n-xb-yb);
}
/*int min(int a,int b)
{
return (a<b?a:b);
}
int max(int a,int b)
{
return (a>=b?a:b);
}*/
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2)
{
if (nums1.size()>nums2.size())
{
return findMedianSortedArrays(nums2, nums1);
}
int imin,imax,i,j,m,n,mid;
m=nums1.size();
n=nums2.size();
imin=0;
imax=m;
mid=(m+n)/2;
while(imin<=imax)
{
i=(imin+imax)/2;
j=mid-i;
if(j>0&&i<m&&nums2[j-1]>nums1[i])
{
imin=i+1;
}
else if (i>0&&j<n&&nums1[i-1]>nums2[j])
{
imax=i-1;
}
else
{
int min_of_right,max_of_left;
/*
if (i == 0) max_of_left = nums2[j-1];
else if (j == 0) max_of_left = nums1[i - 1];
else max_of_left = max(nums1[i-1],nums2[j-1]);
if ((m+n)%2==1) return max_of_left;
if (i==m) min_of_right=nums2[j];
else if(j==n) min_of_right=nums1[i];
else min_of_right=min(nums1[i],nums2[j]);
*/
if (i==m) min_of_right=nums2[j];
else if(j==n) min_of_right=nums1[i];
else min_of_right=min(nums1[i],nums2[j]);
if ((m+n)%2==1) return min_of_right;
if (i == 0) max_of_left = nums2[j-1];
else if (j == 0) max_of_left = nums1[i - 1];
else max_of_left = max(nums1[i-1],nums2[j-1]);
return (max_of_left + min_of_right) / 2.0;
}
}
}
int main()
{
int a[]={1,3,5};
int b[]={2,4,6};
int aLen=sizeof(a)/sizeof(a[0]);
int bLen=sizeof(b)/sizeof(b[0]);
printf("aLen:%d,bLen:%d\n",aLen,bLen);
printf("result of medium %lf\n",findMedianSortedArrays(a,aLen,b,bLen));
return 0;
}
int main( int argc, char *argv[] ) {
int size1, size2, *arr1, *arr2;
fscanf( stdin, "%d", &size1 );
arr1 = (int *)malloc( sizeof( int ) * size1 );
for ( int i=0; i<size1; i++ ) fscanf( stdin, "%d", &arr1[i] );
fscanf( stdin, "%d", &size2 );
arr2 = (int *)malloc( sizeof( int ) * size2 );
for ( int i=0; i<size2; i++ ) fscanf( stdin, "%d", &arr2[i] );
double answer = findMedianSortedArrays( arr1, size1, arr2, size2 );
fprintf( stderr ,"%lf\n", answer );
return 0;
}
int main()
{
double i;
int a[2]={1,1};
int b[1]={3};
i = findMedianSortedArrays(a,2,b,1);
printf("median = %f\n",i);
return 0;
}
int main(){
int nums1[] = {0,4,4,5};
int nums2[] = {1,4,5,6,8,9};
size_t m = sizeof(nums1)/sizeof(int);
size_t n = sizeof(nums2)/sizeof(int);
double res = findMedianSortedArrays(nums1, m, nums2, n);
printf("Result is = %f\n", res);
return 0;
}
int main()
{
int A[10], B[10];
double res;
for(int i=0; i<10; i++)
{
A[i] = i+1;
B[i] = i;
}
res = findMedianSortedArrays(A, 10, B, 0);
printf("res = %f\n", res);
return 0;
}
void Main()
{
print(findMedianSortedArrays(createVector({ 1, 2 }), createVector({ 1, 2, 3 })));
print(findMedianSortedArrays(createVector({ 1, 2, 3 }), createVector({ 4, 5, 6 })));
print(findMedianSortedArrays(createVector({ 2 }), vector<int>()));
print(findMedianSortedArrays(createVector({ 1, 1 }), createVector({ 1, 2 })));
print(findMedianSortedArrays(createVector({ 1, 2 }), createVector({ 1, 2 })));
print(findMedianSortedArrays(createVector({ 1, 1 }),createVector({ 1, 1 })));
print(findMedianSortedArrays(vector<int>(), createVector({ 2, 3 })));
}
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
int N1 = nums1.size();
int N2 = nums2.size();
if (N1 < N2) return findMedianSortedArrays(nums2, nums1); // Make sure A2 is the shorter one.
if (N2 == 0) return ((double)nums1[(N1-1)/2] + (double)nums1[N1/2])/2; // If A2 is empty
int lo = 0, hi = N2 * 2;
while (lo <= hi) {
int mid2 = (lo + hi) / 2; // Try Cut 2
int mid1 = N1 + N2 - mid2; // Calculate Cut 1 accordingly
double L1 = (mid1 == 0) ? INT_MIN : nums1[(mid1-1)/2]; // Get L1, R1, L2, R2 respectively
double L2 = (mid2 == 0) ? INT_MIN : nums2[(mid2-1)/2];
double R1 = (mid1 == N1 * 2) ? INT_MAX : nums1[(mid1)/2];
double R2 = (mid2 == N2 * 2) ? INT_MAX : nums2[(mid2)/2];
if (L1 > R2) lo = mid2 + 1; // A1's lower half is too big; need to move C1 left (C2 right)
else if (L2 > R1) hi = mid2 - 1; // A2's lower half too big; need to move C2 left.
else return (max(L1,L2) + min(R1, R2)) / 2; // Otherwise, that's the right cut.
}
return -1;
}
int main()
{
int r1[] = {1};
int r2[] = {2};
int n1 = sizeof(r1)/sizeof(r1[0]);
int n2 = sizeof(r2)/sizeof(r2[0]);
printf("Median is 1.5 = %f\n", findMedianSortedArrays(r1, n1, r2, n2));
int ar1[] = {1, 12, 15, 26, 38};
int ar2[] = {2, 13, 17, 30, 45, 50};
n1 = sizeof(ar1)/sizeof(ar1[0]);
n2 = sizeof(ar2)/sizeof(ar2[0]);
printf("Median is 17 = %f\n", findMedianSortedArrays(ar1, n1, ar2, n2));
int ar11[] = {1, 12, 15, 26, 38};
int ar21[] = {2, 13, 17, 30, 45 };
n1 = sizeof(ar11)/sizeof(ar11[0]);
n2 = sizeof(ar21)/sizeof(ar21[0]);
printf("Median is 16 = %f\n", findMedianSortedArrays(ar11, n1, ar21, n2));
int a1[] = {1, 2, 5, 6, 8 };
int a2[] = {13, 17, 30, 45, 50};
n1 = sizeof(a1)/sizeof(a1[0]);
n2 = sizeof(a2)/sizeof(a2[0]);
printf("Median is 10.5 = %f\n", findMedianSortedArrays(a1, n1, a2, n2));
int a10[] = {1, 2, 5, 6, 8, 9, 10 };
int a20[] = {13, 17, 30, 45, 50};
n1 = sizeof(a10)/sizeof(a10[0]);
n2 = sizeof(a20)/sizeof(a20[0]);
printf("Median is 9.5 = %f\n", findMedianSortedArrays(a10, n1, a20, n2));
int a11[] = {1, 2, 5, 6, 8, 9 };
int a21[] = {13, 17, 30, 45, 50};
n1 = sizeof(a11)/sizeof(a11[0]);
n2 = sizeof(a21)/sizeof(a21[0]);
printf("Median is 9 = %f\n", findMedianSortedArrays(a11, n1, a21, n2));
int a12[] = {1, 2, 5, 6, 8 };
int a22[] = {11, 13, 17, 30, 45, 50};
n1 = sizeof(a12)/sizeof(a12[0]);
n2 = sizeof(a22)/sizeof(a22[0]);
printf("Median is 11 = %f\n", findMedianSortedArrays(a12, n1, a22, n2));
int b1[] = {1 };
int b2[] = {2,3,4};
n1 = sizeof(b1)/sizeof(b1[0]);
n2 = sizeof(b2)/sizeof(b2[0]);
printf("Median is 2.5 = %f\n", findMedianSortedArrays(b1, n1, b2, n2));
return 0;
}
