线性时间选择

         线性时间选择问题：给定线性序集中n个元素和一个整数k，1≤k≤n，要求找出这n个元素中第k小的元素，（这里给定的线性集是无序的）。

       1、随机划分线性选择

       线性时间选择随机划分法可以模仿随机化快速排序算法设计。基本思想是对输入数组进行递归划分，与快速排序不同的是，它只对划分出的子数组之一进行递归处理。

程序如下：

//2-1 随机划分线性时间选择
//#include "stdafx.h"
#include  
#include 
using namespace std; 
 
int a[] = {5,7,3,4,8,6,9,1,2};
 
template 
void Swap(Type &x,Type &y);
 
inline int Random(int x, int y);
 
template 
int Partition(Type a[],int p,int r);
 
template
int RandomizedPartition(Type a[],int p,int r);
 
template 
Type RandomizedSelect(Type a[],int p,int r,int k);
 
int main()
{
  for(int i=0; i<9; i++)
  {
    cout<  }
  cout<  cout<}
 
template 
void Swap(Type &x,Type &y)
{
  Type temp = x;
  x = y;
  y = temp;
}
 
inline int Random(int x, int y)
{
     srand((unsigned)time(0));
     int ran_num = rand() % (y - x) + x;
     return ran_num;
}
 
template 
int Partition(Type a[],int p,int r)
{
  int i = p,j = r + 1;
  Type x = a[p];
 
  while(true)
  {
    while(a[++i]    while(a[--j]>x);
    if(i>=j)
    {
      break;
    }
    Swap(a[i],a[j]);
  }
  a[p] = a[j];
  a[j] = x;
  return j;
}
 
template
int RandomizedPartition(Type a[],int p,int r)
{
  int i = Random(p,r);
  Swap(a[i],a[p]);
  return Partition(a,p,r);
}
 
template 
Type RandomizedSelect(Type a[],int p,int r,int k)
{
  if(p == r)
  {
    return a[p];
  }
  int i = RandomizedPartition(a,p,r);
  int j = i - p + 1;
  if(k <= j)
  {
    return RandomizedSelect(a,p,i,k);
  }
  else
  {
    //由于已知道子数组a[p:i]中的元素均小于要找的第k小元素
    //因此，要找的a[p:r]中第k小元素是a[i+1:r]中第k-j小元素。
    return RandomizedSelect(a,i+1,r,k-j);
  }
}

输出如下：

 程序解释：利用随机函数产生划分基准，将数组a[p:r]划分成两个子数组a[p:i]和a[i+1:r]，使a[p:i]中的每个元素都不大于a[i+1:r]中的每个元素。接着"j=i-p+1"计算a[p:i]中元素个数j.如果k<=j，则a[p:r]中第k小元素在子数组a[p:i]中，如果k>j，则第k小元素在子数组a[i+1:r]中。注意：由于已知道子数组a[p:i]中的元素均小于要找的第k小元素，因此，要找的a[p:r]中第k小元素是a[i+1:r]中第k-j小元素。

      在最坏的情况下，例如：总是找到最小元素时，总是在最大元素处划分，这是时间复杂度为O(n^2)。但平均时间复杂度与n呈线性关系，为O(n)(数学证明过程略过,可参考王云鹏论文《​​线性时间选择算法时间复杂度深入研究​​》)。

 2、利用中位数线性时间选择

      中位数：是指将数据按大小顺序排列起来，形成一个数列，居于数列中间位置的那个数据。

      算法思路：如果能在线性时间内找到一个划分基准使得按这个基准所划分出的2个子数组的长度都至少为原数组长度的ε倍(0<ε<1),那么就可以在最坏情况下用O(n)时间完成选择任务。例如，当ε=9/10，算法递归调用所产生的子数组的长度至少缩短1/10。所以，在最坏情况下，算法所需的计算时间T(n)满足递推式T(n)<=T(9n/10)+O(n)。由此可得T(n)=O(n)。

     实现步骤：

      (1)将所有的数n个以每5个划分为一组共组，将不足5个的那组忽略，然后用任意一种排序算法，因为只对5个数进行排序，所以任取一种排序法就可以了。将每组中的元素排好序再分别取每组的中位数，得到个中位数。

      (2)取这个中位数的中位数，如果是偶数，就找它的2个中位数中较大的一个作为划分基准。

      (3)将全部的数划分为两个部分，小于基准的在左边，大于等于基准的放右边。在这种情况下找出的基准x至少比个元素大。因为在每一组中有2个元素小于本组的中位数，有个小于基准，中位数处于，即个中位数中又有个小于基准x。因此至少有个元素小于基准x。同理基准x也至少比个元素小。而当n≥75时≥n/4所以按此基准划分所得的2个子数组的长度都至少缩短1/4。

当然有的教科书上也会这样：

算法分析：

 举个例子说明：将54个元素分为下列组，每组5个，要找第15个小的元素

 然后将每组进行排序，得到如下：蓝色是中位数数组

 现在求中位数数组的中位数，为节省空间，将中位数数组移到前两列：

 然后将前两列进行排序：

 知道28是中位数后，然后进行快速排序划分

 比较明显，下面框框是比28小的元素

 由于15<28,应该在框框元素内找到第15小的元素，如下

 然后在上述元素中继续划分5组，进行排序，排序结果如下：

 然后选出中位数数组的中位数是15

 然后继续将所有元素快排，得到下面：

 然后比15小的14个，我们要找第15小的元素，就是这个数15，两轮结束。

 注意：算法将每一组大小定为5，并取75作为是否作递归调用的分界点。当然除了5和75以外，还有其他选择。

       中位数线性时间选择程序清单如下：

//2-2 中位数线性时间选择
#include "stdafx.h"
#include 
#include  
using namespace std; 
 
template 
void Swap(Type &x,Type &y);
 
inline int Random(int x, int y);
 
template 
void BubbleSort(Type a[],int p,int r);
 
template 
int Partition(Type a[],int p,int r,Type x);
 
template 
Type Select(Type a[],int p,int r,int k);
 
int main()
{
  //初始化数组
  int a[100];
 
  //必须放在循环体外面
  srand((unsigned)time(0));
 
  for(int i=0; i<100; i++)
  {
    a[i] = Random(0,500);
    cout<<"a["<  }
  cout< 
  cout<<"第83小元素是"< 
  //重新排序，对比结果
  BubbleSort(a,0,99);
 
  for(int i=0; i<100; i++)
  {
    cout<<"a["<  }
  cout<}
 
template 
void Swap(Type &x,Type &y)
{
  Type temp = x;
  x = y;
  y = temp;
}
 
inline int Random(int x, int y)
{
     int ran_num = rand() % (y - x) + x;
     return ran_num;
}
 
//冒泡排序
template 
void BubbleSort(Type a[],int p,int r)
{
   //记录一次遍历中是否有元素的交换   
     bool exchange;  
     for(int i=p; i<=r-1;i++)  
     {  
    exchange = false ;  
        for(int j=i+1; j<=r; j++)  
        {  
      if(a[j]            {  
                Swap(a[j],a[j-1]); 
                exchange = true;  
            }   
        }   
        //如果这次遍历没有元素的交换,那么排序结束   
        if(false == exchange)  
    {
             break ;  
    }
   }
}
 
template 
int Partition(Type a[],int p,int r,Type x)
{
  int i = p-1,j = r + 1;
 
  while(true)
  {
    while(a[++i]    while(a[--j]>x);
    if(i>=j)
    {
      break;
    }
    Swap(a[i],a[j]);
  } 
  return j;
}
 
 
template 
Type Select(Type a[],int p,int r,int k)
{
  if(r-p<75)
  {
    BubbleSort(a,p,r);
    return a[p+k-1];
  }
  //(r-p-4)/5相当于n-5
  for(int i=0; i<=(r-p-4)/5; i++)
  {
    //将元素每5个分成一组，分别排序，并将该组中位数与a[p+i]交换位置
    //使所有中位数都排列在数组最左侧，以便进一步查找中位数的中位数
    BubbleSort(a,p+5*i,p+5*i+4);
    Swap(a[p+5*i+2],a[p+i]);
  }
  //找中位数的中位数
  Type x = Select(a,p,p+(r-p-4)/5,(r-p-4)/10);
  int i = Partition(a,p,r,x);
  int j = i-p+1;
  if(k<=j)
  {
    return Select(a,p,i,k);
  }
  else
  {
    return Select(a,i+1,r,k-j);
  }
}

运行结果：

 参考：王晓东编注《算法设计与分析第二版》