算法导论：第9章 中位数和顺序统计量_2最坏情况为线性时间的选择算法

本文参考这位作者的思想，其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;
}