算法20：两个排序数组merge后的中值

算法分析：

思路一：遍历计数法

此题可以变为求：有序数组A的长度是m，有序数组B的长度是n，返回A和B合并后的第k个值。

通过遍历两个有序数组，采用计数的方法，当计数到第k个值时，返回数组合并后的第k个值。时间复杂度为O(m+n)，空间复杂度为O（1）。

c++代码如下

//aBuffer:有序数组a
//aLen：有序数据a的长度
//bBuufer:有序数组b
//bLen:有序数组b的长度
//k:第k个值
//kValue：返回k位置的值
int GetKthByMerge(int* aBuffer,int aLen,int* bBuffer,int bLen,int k,int& kValue)
{
if(aBuffer == NULL || bBuffer == NULL)
{
return -1;
}

if(aLen == 0 || bLen == 0)
{
return -1;
}

if(k <=0 || k > aLen+bLen)
{
return -1;
}

//特殊情况
if(k == 1)
{
kValue = aBuffer[0] > bBuffer[0] ? bBuffer[0]:aBuffer[0];
return kValue;
}

if(k == aLen+bLen)
{
kValue = aBuffer[aLen-1] > bBuffer[bLen-1] ? aBuffer[aLen-1]:bBuffer[bLen-1];
return 0;
}

int ai = 0;
int bi = 0;
while(ai < aLen && bi < bLen && k > 0)
{
if(aBuffer[ai] < bBuffer[bi])
{
kValue = aBuffer[ai];
ai++;
}
else
{
kValue = bBuffer[bi];
bi++;
}

k--;
}

if(k > 0 && ai < aLen)
{
kValue = aBuffer[ai+k-1];
}

if(k > 0 && bi < bLen)
{
kValue = bBuffer[bi+k-1];
}

return 0;
}

思路二：充分利用排序数组的特性，采用二分递归的方法，时间复杂度是O(m+n)

c++代码如下

//aBuffer: 有序数组a
//bBuffer: 有序数组b
//aStart: a数组起始位置
//aEnd: a数组结束位置
//bStart: b数组起始位置
//bEnd: b数组结束位置
//k:k值
static int FindKValue(int* aBuffer,int* bBuffer,int aStart,int aEnd,int bStart,int bEnd,int k)
{
int aLen = aEnd - aStart + 1;
int bLen = bEnd - bStart + 1;

//递归结束的条件
if(aLen == 0)
{
return bBuffer[bStart + k];
}

if(bLen == 0)
{
return aBuffer[aStart + k];
}

if(k == 0)
{
return bBuffer[bStart] > aBuffer[aStart] ? aBuffer[aStart] : bBuffer[bStart];
}

if(k == aLen+bLen-1)
{
return bBuffer[bEnd] > aBuffer[aEnd] ? bBuffer[bEnd] : aBuffer[aEnd];
}

//ka+kb=k+1;
int ka = (k+1)*aLen/(aLen+bLen);
int kb = (k+1) - ka;

ka = ka + aStart;
kb = kb + bStart;

//递归
if(aBuffer[ka] > bBuffer[kb])
{
//重新调整k值
k = k - (kb-bStart);
//k值不在 bStart~kb之间
bStart = kb;
//k值不在ka~aEnd之间
aEnd = ka;
}
else
{
//重新调整k值
k = k - (ka-aStart);
//k值不在 aStart~ka之间
aStart = ka;
//k值不在kb~bEnd之间
bEnd = kb;
}

return FindKValue(aBuffer,bBuffer,aStart,aEnd,bStart,bEnd,k);
}

此算法只适合算中值，对于任意的K值还有待修正

[b]***[/b]未完待续[b]*******[/b]