算法导论9.36算法导论9.36 .

题目:

对一个含有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个分位数,再以这个分位数为主元把数组分为两段,分别对这两段来找分位数,这个时候找的范围变小了,效率也就提高了

代码:

  1 #include <iostream>
  2 using namespace std;
  3 
  4 int t, length_A;
  5 void Print(int *A, int len)
  6 {
  7     int i;
  8     for(i = 1; i <= len; i++)
  9         cout<<A[i]<<' ';
 10     cout<<endl;
 11 }
 12 /*************最坏情况线性时间的选择**************************************************/
 13 //已经出现很多次了,不解释
 14 int Partition(int *A, int p, int r)
 15 {
 16     int x = A[r], i = p-1, j;
 17     for(j = p; j < r; j++)
 18     {
 19         if(A[j] <= x)
 20         {
 21             i++;
 22             swap(A[i], A[j]);
 23         }
 24     }
 25     swap(A[i+1], A[r]);
 26     return i+1;
 27 }
 28 int Select(int *A, int p, int r, int i);
 29 //对每一组从start到end进行插入排序,并返回中值
 30 //插入排序很简单,不解释
 31 int Insert(int *A, int start, int end, int k)
 32 {
 33     int i, j;
 34     for(i = 2; i <= end; i++)
 35     {
 36         int t = A[i];
 37         for(j = i; j >= start; j--)
 38         {
 39             if(j == start)
 40                 A[j] = t;
 41             else if(A[j-1] > t)
 42                 A[j] = A[j-1];
 43             else
 44             {
 45                 A[j] = t;
 46                 break;
 47             }
 48         }
 49     }
 50     return A[start+k-1];
 51 }
 52 //根据文中的算法,找到中值的中值
 53 int Find(int *A, int p, int r)
 54 {
 55     int i, j = 0;
 56     int start, end, len = r - p + 1;
 57     int *B = new int[len/5+1];
 58     //每5个元素一组,长度为start到end,对每一组进行插入排序,并返回中值
 59     for(i = 1; i <= len; i++)
 60     {
 61         if(i % 5 == 1)
 62             start = i+p-1;
 63         if(i % 5 == 0 || i == len)
 64         {
 65             j++;
 66             end = i+p-1;
 67             //对每一组从start到end进行插入排序,并返回中值,如果是最后一组,组中元素个数可能少于5
 68             int ret = Insert(A, start, end, (end-start)/2+1);
 69             //把每一组的中值挑出来形成一个新的数组
 70             B[j] = ret;    
 71         }
 72     }
 73     //对这个数组以递归调用Select()的方式寻找中值
 74     int ret = Select(B, 1, j, (j+1)/2);
 75     //delete []B;
 76     return ret;
 77 }
 78 //以f为主元的划分
 79 int Partition2(int *A, int p, int r, int f)
 80 {
 81     int i;
 82     //找到f的位置并让它与A[r]交换
 83     for(i = p; i < r; i++)
 84     {
 85         if(A[i] == f)
 86         {
 87             swap(A[i], A[r]);
 88             break;
 89         }
 90     }
 91     return Partition(A, p, r);
 92 }
 93 //寻找数组A[p..r]中的第i大的元素,i是从1开始计数,不是从p开始
 94 int Select(int *A, int p, int r, int i)
 95 {
 96     //如果数组中只有一个元素,则直接返回
 97     if(p == r)
 98         return A[p];
 99     //根据文中的算法,找到中值的中值
100     int f = Find(A, p, r);
101     //以这个中值为主元的划分,返回中值在整个数组A[1..len]的位置
102     //因为主元是数组中的某个元素,划分好是这样的,A[p..q-1] <= f < A[q+1..r]
103     int q = Partition2(A, p, r, f);
104     //转换为中值在在数组A[p..r]中的位置
105     int k = q - p + 1;
106     //与所寻找的元素相比较
107     if(i == k)
108         return A[q];
109     else if(i < k)
110         return Select(A, p, q-1, i);
111     else
112         //如果主元是数组中的某个元素,后面一半要这样写
113         return Select(A, q+1, r, i-k);
114         //但是如果主元不是数组中的个某个元素,后面一半要改成Select(A, q, r, i-k+1)
115 }
116 //数组A中,求从start到end这段的分位数。这一段有k个分位数,即第ks+1个分位到第ks+k个分位数
117 void K_Quantile(int *A, int *B, int k, int start, int end, int ks)
118 {
119     if(k == 0)
120         return;
121     //先找最中间的分位数
122     int x = Select(A, start, end, ((k+1)/2)*t);
123     //记录这个分位数
124     B[ks+(k+1)/2] = x;
125     //以这个分位数为主元把数组分为两段,调度的时候发现这一步没什么用,因为SELECT已经包含了分段的过程
126     Partition2(A, start, end, x);
127     //分别找前后两个的分位数
128     K_Quantile(A, B, (k-1)/2, start, (ks+(k+1)/2)*t, 0);
129     K_Quantile(A, B, k/2, (ks+(k+1)/2)*t+1, end, ks+(k+1)/2);
130 }
131 int main()
132 {
133     int i, k;
134     while(cin>>length_A>>k)
135     {
136         if(length_A % k)
137         {
138             cout<<"不能划分为k个大小相等的集合"<<endl;
139             continue;
140         }
141         t = length_A / k;
142         //A是输入数组
143         int *A = new int[length_A+1];
144         //B是输出数组,记录k-1个分位数
145         int *B = new int[k];
146         //构造随机数据
147         for(i = 1; i <= length_A; i++)
148             A[i] = rand() % 100;
149         //打印输入数组
150         Print(A, length_A);
151         //求k分位数算法
152         K_Quantile(A, B, k-1, 1, length_A, 0);
153         //打印输出数组
154         Print(B, k-1);
155     }
156     return 0;
157 }
原文地址:https://www.cnblogs.com/windmissing/p/2561157.html