本文参考这位作者的思想,其blog地址:http://blog.csdn.net/whispermyname/article/details/6667690
但与他的实现不完全相同,下面的测试用例全部通过
/*
最坏情况为线性时间的选择算法:
算法步骤:
1将n个元素划为n/5组
2寻找这n/5个数组中每一组的中位数。对每一组采用插入排序来寻找中位数
3对各组中位数,递归寻找中位数x
4按中位数的中位数x对输入数组进行划分。让k比划分后低区数目多1,x是第k小的元素
5如果i == k,返回x;
i < k,低区递归调用算法
i > k,高区递归查找第i-k小的元素
插入排序:
对于前面已经排好的数组[1...p],从剩余数组[p+1...r]中选择最小的元素插入到第p+1的位置。
每一趟确定一个元素的最终位置
对于未排序数据,从已排序序列中从后向前扫描
给定线性序集中n个元素和一个整数k,1≤k≤n,
要求找出这n个元素中第k小的元素。
关键易错点:这里求得的中位数是上中位数,也就是说对于数组A[n],中位数=A[ (n+1)/2 - 1 ],
而不是A[n/2]
参见算法导论第三版中文本123页,“如果有偶数个中位数,为了方便,约定x是较小的中位数”
输入:
3 2
1 3 2
4 3
1 4 3 2
5 3
1 4 3 2 5
10 5
1 9 8 5 6 3 4 2 0 7
29 18
8,31,60,33,17,4,51,57,49,35,
11,43,37,3,13,52,6,19,25,32,
54,16,5,41,7,23,22,46,29
输出:
2
3
3
4
33
*/
#include <iostream>
#include <string.h>
using namespace std;
const int MAXSIZE = 10000;
int gMidArray[MAXSIZE];//中位数数组
//简单选择排序:第一趟从n个数中选择最小的与第一个记录交互
void selectSort(int* pArr , int n)
{
if(!pArr || n < 0)
{
return;
}
//插入排序共n-1趟,每趟确定从剩余数组中选择一个最小的元素摆放到正确位置
for(int i = 0 ; i < n - 1; i++ )
{
for(int j = i + 1 ; j < n ; j++)
{
//如果后面的元素比当前位置上的元素要小,就把当前需要确定位置上的元素与较小的元素进行交换,确保该位置上一定是最小的元素
if(pArr[j] < pArr[i])
{
int iTemp = pArr[j];
pArr[j] = pArr[i];
pArr[i] = iTemp;
}
}
}
}
//插入排序:将当前元素插入到前面的已经排序的序列,从大向小扫描
void insertSort(int* pArr , int n)
{
if(!pArr || n < 0)
{
return;
}
for(int i = 1 ; i < n ; i++)
{
//获取当前待插入元素
int target = pArr[i];
int j = i;
while(j > 0 && target < pArr[j - 1])
{
//将比较元素后移
pArr[j] = pArr[j-1];
j--;
}
pArr[j] = target;
}
}
//对数组中的iLow~iHigh范围内进行排序,其中iHigh取不到
void insertSort(int* pArr , int iLow , int iHigh)
{
if(!pArr || iLow < 0 || iHigh < 0 || iHigh < iLow)
{
return;
}
for(int i = iLow + 1 ; i < iHigh ; i++)
{
int j = i;
int target = pArr[i];
while(j >= iLow && target < pArr[j-1])
{
pArr[j] = pArr[j-1];
j--;
}
pArr[j] = target;
}
}
//寻找中位数的递归算法,这里在有偶数个中位数的时候取较小的那一个,所以测试用例没有通过
int midNum(int* pArr , int iLow , int iHigh)
{
//如果只有1个元素,那么就是中位数,注意:这里的iHigh其实表示的数组的元素数目,是取不到的,而且其实iLow应该每次为0
if(iHigh == 1)
{
return pArr[iLow];
}
//计算剩余的数组的元素数量
int iRemainder = (iHigh - iLow) % 5;
//划分为n/5组,对每组采用插入排序
int iCount = 0;
int i = 0;
for(i = iLow ; i < (iHigh - iRemainder) ; i += 5 )
{
insertSort(pArr , i , i + 5);
//获取排序后每一组的中位数,并放入中位数数组中
gMidArray[iCount++] = pArr[i + 2];
}
//对划分后的剩余一组进行插入排序
if(iRemainder != 0)
{
insertSort(pArr , iHigh - iRemainder , iHigh);
//注意,易错,这里取当有偶数个中位数时,取较小的那一个
//3个数时,(3+1)/2-1取A[1],4个数取(4+1)/2-1取A[1],第n个数取A[(n+1)/2-1]
//gMidArray[iCount++] = pArr[ i + iRemainder/2];
gMidArray[iCount++] = pArr[ i + (iRemainder+1)/2 - 1];
}
//对于中位数的中位数数组,递归调用求中位数
int x = midNum(gMidArray , 0 , iCount);
return x;
}
//指定的划分函数,用x为枢轴进行划分,那么还需要确定x对应的下标,因为最后返回的枢轴
//求midNum是需要iLow~iHigh,但是快速排序中的划分函数是取不到iHigh的
int linearPartition(int* pArr,int iLow , int iHigh)
{
//中位数的计算在划分过程中,注意,这里求midNum,iHigh是最后一个元素的下标,
int x = midNum(pArr , iLow , iHigh + 1);
int index = -1;
//pArr取不到iHigh
for(int i = iLow; i <= iHigh ; i++)
{
if(x == pArr[i])
{
index = i;
break;
}
}
//确定枢轴对应的下标后,就是交换枢轴与起始元素
int iTemp = pArr[iLow];
pArr[iLow] = pArr[index];
pArr[index] = iTemp;
//开始进行划分,划分取不到iHigh
while(iLow < iHigh)
{
while(iLow < iHigh && pArr[iHigh] >= x)
{
iHigh--;
}
pArr[iLow] = pArr[iHigh];
while(iLow < iHigh && pArr[iLow] <= x)
{
iLow++;
}
pArr[iHigh] = pArr[iLow];
}
pArr[iLow] = x;
return iLow;
}
//线性时间选择,与之前的算法框架一样:划分,判断3种情况,与之前随机选择不同,随机选择r不能取到,这里可以取到
int linearSelect(int* pArr , int p , int r , int i)
{
if(p == r)
{
return pArr[p];
}
//中位数的选取在划分过程中
int q = linearPartition(pArr , p , r);
//因为这里已经每次,注意这里
int k = q - p + 1;
if(i == k)
{
//注意,返回的是pArr[q],即主元,而不是是其他pArr[i]
return pArr[q];
}
//在低区间
else if(i < k)
{
return linearSelect(pArr , p , q - 1 , i );
}
else
{
return linearSelect(pArr , q + 1 , r, i - k);
}
}
void print(int* pArr , int n)
{
for(int i = 0 ; i < n ; i++)
{
cout << pArr[i] << " ";
}
}
void process()
{
int n , u;
while(cin >> n >> u)
{
int* pArr = new int[n];
for(int i = 0 ; i < n ; i++)
{
cin >> pArr[i];
}
//insertSort(pArr , n);
//print(pArr , n);
int iResult = linearSelect(pArr , 0 , n - 1 , u);
cout << iResult << endl;
delete[] pArr;
}
}
int main(int argc,char* argv[])
{
process();
getchar();
return 0;
}