两个排序数组的中位数
求两个排序数组中位数，这道题是很有意思的一道题目，算法导论中9.3-8题，这题必须在O(logn)的时间复杂度求解，否则肯定悲剧。。。
这题有个关键的条件，那就是这两个数组长度相等
思路如下：
数组A：1, 3, 5, 7, 9
数组B：2, 4, 6, 8, 10
首先取二者的中位数，在O(1)时间复杂度内求出，那么数组A的midValue = 5，数组B的midValue = 6，则较小的元素midValue的左边所有元素，也就是midPosition个，和较大元素右边的所有元素，都要去掉，由于去掉的元素占所有元素的一半，所以复杂度为O(logn)。只需要移动begin和end的position即可。
第一轮：
数组A：1, 3, 5, 7, 9
数组B：2, 4, 6, 8, 10
第二轮：
数组A：1, 3, 5, 7, 9
数组B：2, 4, 6, 8, 10
只剩下两个元素，由于这种情形下midValue始终是偏左的元素，因此循环无法退出，所以满足lhsBegin == lhsEnd - 1和 rhsBegin == rhsEnd - 1时，循环退出！
如果两个
上述情形是当数组中有两个及以上元素才成立，必须考虑两个数组只存在一个元素的情形，那么直接取较小的元素即可！
#include
using namespace std;
int findMidValue(int *lhs, int *rhs, int size)
{
if (lhs == NULL || rhs == NULL || size <= 0)
return -1;
int lhsBegin = 0;
int rhsBegin = 0;
int lhsEnd = size - 1;
int rhsEnd = size - 1;
int result;
while ((lhsBegin < lhsEnd && rhsBegin < rhsEnd))
{
if ((lhsBegin == lhsEnd - 1 && rhsBegin == rhsEnd - 1))
break;
int lhsMid = (lhsBegin + lhsEnd) >> 1;
int rhsMid = (rhsBegin + rhsEnd) >> 1;
if (lhs[lhsMid] == rhs[rhsMid])
{
result = lhs[lhsMid];
break;
}
else if (lhs[lhsMid] < rhs[rhsMid])
{
lhsBegin = lhsMid;
rhsEnd = rhsMid;
} else
{
lhsEnd = lhsMid;
rhsBegin = rhsMid;
}
}
if (lhsBegin == lhsEnd && rhsBegin == rhsEnd)
result = min(lhs[lhsBegin], rhs[rhsBegin]);
else if (lhsBegin == lhsEnd - 1 && rhsBegin == rhsEnd - 1)
{
if (lhs[lhsBegin] < rhs[rhsBegin])
{
result = min(lhs[lhsEnd], rhs[rhsBegin]);
}
else
{
result = min(lhs[lhsBegin], rhs[rhsEnd]);
}
}
return result;
}
void main()
{
int lhs[] = {1, 2, 3, 4};
int rhs[] = {0, 2, 3, 4};
const int size = sizeof lhs / sizeof *lhs;
int result = findMidValue(lhs, rhs, size);
cout << "mid value = " << result << endl;
} 当两个数组长度不等时，这种情形比较复杂：
情形一：
当一个数组长度为1，另一个数组长度为奇数的情形：
例如A：1 B：2, 3, 4
这个时候的比较策略是，A的元素同B的中位数进行比较，若A的元素较小，则中位数一定是max(A[0], B[mid - 1])，若A的元素较大，则中位数一定是B[mid]
情形二：
例如A： 1 B：2, 3, 4, 5
这个时候的比较策略是，A的元素同B的中位数进行比较，若A的元素较小，则中位数一定是B[mid]，若A的元素较大，则中位数一定是min(A[0], B[mid + 1])
下面引申一种情形：
当一个数组长度为2，另一个数组长度为奇数时：
例如A：1, 3 B：2, 4, 6
如果A[mid] < B[mid]，那么A[mid]肯定不会是中位数，由于A只有两个元素，那么A[1]将会是中位数的候选对象，那么此情形退化为上面第一种情形
下面对一个例子进行分析：
数组A：1, 3, 5, 7, 9, 11
数组B：2, 4, 6, 8
第一轮：
数组A：1, 3, 5, 7, 9, 11
数组B：2, 4, 6, 8
第二轮：
数组A：1, 3, 5, 7, 9, 11
数组B：2, 4, 6, 8
进行到这里，那么删除将不能再进行下去，可以肯定的是其中一个数组只有可能是1个或者2个元素，适用于上面分析的情形。
说下上面的删除策略：
if (A[amid] < B[bmid])
{
int leftA = amid;
int rightB = bend - amid - 1;
int minValue = min(leftA, rightB);
abegin = leftA + minValue;
bend = bend - minValue;
}即删除较小的左边元素和较大的右边元素较小的个数。
删除策略进行不下去还有一种情况，那就是rightB为0，当rightB为0时，B的元素只有可能是一个，因为B有多个元素时，B的中位数右边肯定还存在元素。
不难写出代码如下：
#include
using namespace std;
int findMidValue(int *lhs, int sizeLhs, int *rhs, int sizeRhs)
{
if (lhs == NULL || rhs == NULL || sizeLhs <= 0 || sizeRhs <= 0)
return -1;
int lhsBegin = 0;
int rhsBegin = 0;
int lhsEnd = sizeLhs - 1;
int rhsEnd = sizeRhs - 1;
int result;
bool flagLhs = false;
while ((lhsBegin <= lhsEnd && rhsBegin <= rhsEnd))
{
int lhsMid = (lhsBegin + lhsEnd) >> 1;
int rhsMid = (rhsBegin + rhsEnd) >> 1;
int lhsLeft, lhsRight;
int rhsLeft, rhsRight;
if (lhs[lhsMid] < rhs[rhsMid])
{
lhsLeft = lhsMid - lhsBegin;
rhsRight = rhsEnd - rhsMid;
int minValue = min(lhsLeft, rhsRight);
if (minValue == 0)
{
if (lhsLeft == 0 && rhsRight == 0)
{
if ((lhsEnd - lhsBegin) & 0x01)
{
result = max(lhs[lhsMid], rhs[rhsBegin]);
}
else
{
result = min(lhs[lhsMid], rhs[rhsBegin]);
}
}
else if (lhsLeft == 0)
{
//lhs has one elem
if (lhsBegin == lhsEnd)
{
if ((rhsEnd - rhsBegin) & 0x01)
{
if (lhs[lhsBegin] < rhs[rhsMid])
result = rhs[rhsMid];
else
result = min(lhs[lhsBegin], rhs[rhsMid + 1]);
}
else
{
if (lhs[lhsBegin] < rhs[rhsMid])
result = max(lhs[lhsBegin], rhs[rhsMid - 1]);
else
result = rhs[rhsMid];
}
}
//lhs two elems
else
{
if (lhs[lhsEnd] <= rhs[rhsEnd])
{
rhsEnd = rhsEnd - 1;
if ((rhsEnd - rhsBegin) & 0x01)
{
if (lhs[lhsEnd] <= rhs[(rhsBegin + rhsEnd) >> 1])
result = rhs[(rhsBegin + rhsEnd) >> 1];
else
result = min(lhs[lhsEnd], rhs[(rhsBegin + rhsEnd) / 2 + 1]);
}
else
{
if (lhs[lhsEnd] <= rhs[rhsMid])
result = max(lhs[lhsEnd], rhs[rhsMid]);
else
result = rhs[rhsMid];
}
}
else
{
result = rhs[rhsMid];
}
}
}
else
{
//rsh must have one elem
if ((lhsEnd - lhsBegin) & 0x01)
{
if (rhs[rhsBegin] < lhs[lhsMid])
result = lhs[lhsMid];
else
result = min(rhs[rhsBegin], lhs[lhsMid + 1]);
}
else
{
if (rhs[rhsBegin] < lhs[lhsMid])
result = max(rhs[rhsBegin], lhs[lhsMid - 1]);
else
result = lhs[lhsMid];
}
}
break;
}
lhsBegin = lhsBegin + minValue;
rhsEnd = rhsEnd - minValue;
}
else
{
lhsRight = lhsEnd - lhsMid;
rhsLeft = rhsMid - rhsBegin;
int minValue = min(lhsRight, rhsLeft);
if (minValue == 0)
{
if (lhsRight == 0 && rhsLeft == 0)
{
if ((rhsEnd - rhsBegin) & 0x01)
{
result = max(lhs[lhsBegin], rhs[rhsMid]);
}
else
{
result = min(lhs[lhsBegin], rhs[rhsMid]);
}
}
else if (rhsLeft == 0)
{
//rhs has one elem
if (rhsBegin == rhsEnd)
{
if ((lhsEnd - lhsBegin) & 0x01)
{
if (rhs[rhsBegin] < lhs[lhsMid])
result = lhs[lhsMid];
else
result = min(rhs[rhsBegin], lhs[lhsMid + 1]);
}
else
{
if (rhs[rhsBegin] < lhs[lhsMid])
result = max(rhs[rhsBegin], lhs[lhsMid - 1]);
else
result = lhs[lhsMid];
}
}
//rhs two elems
else
{
if (rhs[rhsEnd] <= lhs[lhsEnd])
{
lhsEnd = lhsEnd - 1;
if ((lhsEnd - lhsBegin) & 0x01)
{
if (rhs[rhsEnd] <= lhs[(lhsBegin + lhsEnd) >> 1])
result = lhs[(lhsBegin + lhsEnd) >> 1];
else
result = min(rhs[rhsEnd], lhs[(lhsBegin + lhsEnd) / 2 + 1]);
}
else
{
if (rhs[rhsEnd] <= lhs[(lhsBegin + lhsEnd) >> 1])
result = max(rhs[rhsEnd], lhs[(lhsBegin + lhsEnd) / 2 - 1]);
else
result = lhs[(lhsBegin + lhsEnd) >> 1];
}
}
else
{
result = lhs[lhsMid];
}
}
}
else
{
//lsh must have one elem
if ((rhsEnd - rhsBegin) & 0x01)
{
if (lhs[lhsBegin] < rhs[rhsMid])
result = rhs[rhsMid];
else
result = min(lhs[lhsBegin], rhs[rhsMid + 1]);
}
else
{
if (lhs[lhsBegin] < rhs[rhsMid])
result = max(lhs[lhsBegin], rhs[rhsMid - 1]);
else
result = rhs[rhsMid];
}
}
break;
}
lhsEnd = lhsEnd - minValue;
rhsBegin = rhsBegin + minValue;
}
}
return result;
}
void main()
{
int lhs[] = {1};
int rhs[] = {2, 3, 4};
const int size1 = sizeof lhs / sizeof *lhs;
const int size2 = sizeof rhs / sizeof *rhs;
int result = findMidValue(lhs, size1, rhs, size2);
cout << "mid value = " << result << endl;
} (rhsEnd - rhsBegin) & 0x01成立表示有偶数个数组，不信用笔画一画下标index~~~
关于中位数的其他求法，罗列如下：
1,题目
有两个数组,均已经按升序排列好,编程序计算这两个数组的中位数
要求:要求时间复杂度O(lgn) 空间复杂度O(1)
例子:
数组A:{1,4,6,7,9} B{2,3,5,8} 两数组合并后{1,2,3,4,5,6,7,8,9} 中位数就是中间的那个数: 5
2,方法:
对两个数组分别二分找解
对每个元素可以O(1)判断它在另外一个数组应该所在的位置，从而可以判断选大了还是小了，继续二分直到找到解为止
先二分第一个数组找解，可选区域为[0,4]。选中A[2]=6,6前面有两个元素，如果将其插入第二个数组，那么6如果是解，则必须前面有4-2=2个元素（排第三位）
通过比较前后元素发现6放在B中的第三位明显大了，需要更小的元素，这样就将下一次二分的区域减了一半.
在A和B中重复这个过程，直到找到解为止
3，3,扩展
M个长度为N的排序好的数组 求中位数
目前有两个比较好的算法
算法一
(1)取所有数组的最小值和最大值,求出全体的最大值和最小值min max 然后取m=(min+max)/2
(2)用m在所有数组中搜索 找到比m小的数的个数n1 若n1大于M*N/2 则mid=(min+mid)/2 否则mid=(mid+max)/2
(3)重复上述搜索一共循环log(max-min)次
算法二
(1)取所有数组的中值排序
弃掉这个最大值所在数组的后半部分和最小值所在数组的前半部分 再将这两个只剩一半的数组合并 O(N)
(2)从合并后的数组中找出中值插入到之前的中值排序数组里 o(logN)
(3)重复(1)(2),每次循环可以舍掉一个数组,一共需要循环M次
思想与本文实质相同！