算法导论 9.3-6 nlgk时间求k分位数

一、题目

对一个含有n个元素的集合来说，所谓k分位数（the kth quantile），就是能把已排序的集合分成k个大小相等的集合的k-1个顺序统计量。给出一个能列出某一集合的k分位数的O(nlgk)时间的算法

二、思考

令每个子集合的元素个数为t = n / k，A[j]是数组A中下标为j的元素，A(j)是数组是第j大的元素

则所求的k分位数是指A(t)，A(2t)，A(3t)，……，A((k-1)t)

按顺序依次求这k-1个数的运行时(k-1)*n

要使运行时间为O(nlgk)，改进方法是不要依次寻找这k-1个数，而是借用二分的方法来找。

先找第k/2个分位数，再以这个分位数为主元把数组分为两段，分别对这两段来找分位数，这个时候找的范围变小了，效率也就提高了

三、代码

#include <iostream>
using namespace std;

int t, length_A;
void Print(int *A, int len)
{
	int i;
	for(i = 1; i <= len; i++)
		cout<<A[i]<<' ';
	cout<<endl;
}
/*************最坏情况线性时间的选择**************************************************/
//已经出现很多次了，不解释
int Partition(int *A, int p, int r)
{
	int x = A[r], i = p-1, j;
	for(j = p; j < r; j++)
	{
		if(A[j] <= x)
		{
			i++;
			swap(A[i], A[j]);
		}
	}
	swap(A[i+1], A[r]);
	return i+1;
}
int Select(int *A, int p, int r, int i);
//对每一组从start到end进行插入排序，并返回中值
//插入排序很简单，不解释
int Insert(int *A, int start, int end, int k)
{
	int i, j;
	for(i = 2; i <= end; i++)
	{
		int t = A[i];
		for(j = i; j >= start; j--)
		{
			if(j == start)
				A[j] = t;
			else if(A[j-1] > t)
				A[j] = A[j-1];
			else
			{
				A[j] = t;
				break;
			}
		}
	}
	return A[start+k-1];
}
//根据文中的算法，找到中值的中值
int Find(int *A, int p, int r)
{
	int i, j = 0;
	int start, end, len = r - p + 1;
	int *B = new int[len/5+1];
	//每5个元素一组，长度为start到end，对每一组进行插入排序，并返回中值
	for(i = 1; i <= len; i++)
	{
		if(i % 5 == 1)
			start = i+p-1;
		if(i % 5 == 0 || i == len)
		{
			j++;
			end = i+p-1;
			//对每一组从start到end进行插入排序，并返回中值,如果是最后一组，组中元素个数可能少于5
			int ret = Insert(A, start, end, (end-start)/2+1);
			//把每一组的中值挑出来形成一个新的数组
			B[j] = ret;	
		}
	}
	//对这个数组以递归调用Select()的方式寻找中值
	int ret = Select(B, 1, j, (j+1)/2);
	//delete []B;
	return ret;
}
//以f为主元的划分
int Partition2(int *A, int p, int r, int f)
{
	int i;
	//找到f的位置并让它与A[r]交换
	for(i = p; i < r; i++)
	{
		if(A[i] == f)
		{
			swap(A[i], A[r]);
			break;
		}
	}
	return Partition(A, p, r);
}
//寻找数组A[p..r]中的第i大的元素，i是从1开始计数，不是从p开始
int Select(int *A, int p, int r, int i)
{
	//如果数组中只有一个元素，则直接返回
	if(p == r)
		return A[p];
	//根据文中的算法，找到中值的中值
	int f = Find(A, p, r);
	//以这个中值为主元的划分，返回中值在整个数组A[1..len]的位置
	//因为主元是数组中的某个元素，划分好是这样的，A[p..q-1] <= f < A[q+1..r]
	int q = Partition2(A, p, r, f);
	//转换为中值在在数组A[p..r]中的位置
	int k = q - p + 1;
	//与所寻找的元素相比较
	if(i == k)
		return A[q];
	else if(i < k)
		return Select(A, p, q-1, i);
	else
		//如果主元是数组中的某个元素，后面一半要这样写
		return Select(A, q+1, r, i-k);
		//但是如果主元不是数组中的个某个元素，后面一半要改成Select(A, q, r, i-k+1)
}
//数组A中，求从start到end这段的分位数。这一段有k个分位数，即第ks+1个分位到第ks+k个分位数
void K_Quantile(int *A, int *B, int k, int start, int end, int ks)
{
	if(k == 0)
		return;
	//先找最中间的分位数
	int x = Select(A, start, end, ((k+1)/2)*t);
	//记录这个分位数
	B[ks+(k+1)/2] = x;
	//以这个分位数为主元把数组分为两段，调度的时候发现这一步没什么用，因为SELECT已经包含了分段的过程
	Partition2(A, start, end, x);
	//分别找前后两个的分位数
	K_Quantile(A, B, (k-1)/2, start, (ks+(k+1)/2)*t, 0);
	K_Quantile(A, B, k/2, (ks+(k+1)/2)*t+1, end, ks+(k+1)/2);
}
int main()
{
	int i, k;
	while(cin>>length_A>>k)
	{
		if(length_A % k)
		{
			cout<<"不能划分为k个大小相等的集合"<<endl;
			continue;
		}
		t = length_A / k;
		//A是输入数组
		int *A = new int[length_A+1];
		//B是输出数组，记录k-1个分位数
		int *B = new int[k];
		//构造随机数据
		for(i = 1; i <= length_A; i++)
			A[i] = rand() % 100;
		//打印输入数组
		Print(A, length_A);
		//求k分位数算法
		K_Quantile(A, B, k-1, 1, length_A, 0);
		//打印输出数组
		Print(B, k-1);
	}
	return 0;
}