选择算法

1. 概念

顺序统计量：在一个由n个元素组成的集合中，第i个顺序统计量是指该集合中第i小的元素。例如最小值是第1个顺序统计量，最大值是第n个顺序统计量。

中位数：一般来说，中位数是指它所在集合的“中间元素”，当n为奇数时，中位数是唯一的，出现位置为n/2；当n为偶数时候，存在两个中位数，位置分别为n/2（上中位数）和n/2+1（下中位数）。

选择问题：

输入：一个包含n个（不同的）数的集合A和一个数i，1≤i≤n。

输出：元素x∈A，它恰大于A中其他的i-1个元素。

2.最小值和最大值

要在集合中选择最大值和最小值，可以通过两两元素比较，并记录最大值和最小值，n元素的集合需要比较n-1次，这样运行时间为O(n)。

伪代码：

MINMUN(A)
min = A[1]
for i=1 to length(A)
do if min > A[i]
min >= A[i]
return min

同时找出集合的最大值和最小值：

方法一：按照上面讲到的方法，分别独立的找出集合的最大值和最小值，各用n-1次比较，共有2n-2次比较。

方法二：输入元素与当前的最大值和最小值进行比较，而是成对的处理元素，先将一对输入元素进行比较，然后把较大者与当前最大值比较，较小者与当前最小者比较，因此每两个元素需要3次比较。

初始设置最大值和最小值方法：

如何n为奇数，就将最大值和最小值都设置为第一个元素的值，然后成对的处理后续的元素。

如果n为偶数，那么先比较前面两个元素的值，较大的设置为最大值，较小的设置为最小值，然后成对处理后续的元素。实际上只需要最多3⌊n/2⌋次比较。

3. 以期望线性时间的选择算法

以期望线性时间选择顺序统计量的方法是以快速排序为模型。如同在快速排序中一样，此算法的思想也是对输入数组进行递归划分。

但和快速排序不同的是，快速排序会递归处理划分的两边，而randomized-select只处理划分的一边。并由此将期望的运行时间由O(nlgn)下降到了O(n)。

这就是顺序统计量算法能够如此高效的核心原因所在！

伪代码：

RANDOMIZED_SELECT(A,p,r,i)
if p==r
return A[p]
q = RANDOMIZED_PARTITION(A,p,r)
k = q-p+1;
if i==k
return A[q]
else  if i<k
return RANDOMIZED_SELECT(A,p,q-1,i)
else
RANDOMIZED_SELECT(A,q+1,r,i-k)

RANDOMIZED_SELECT通过对输入数组的递归划分来找出所求元素，该算法要保证对数组的划分是个好划分才更加高效。

RANDOMIZED_SELECT的最坏情况运行时间为θ(n^2)，即使是选择最小元素也是如此。因为在每次划分过程中，导致划分后两边不对称，总好是按照剩下元素中最大的划分进行。



以期望线性时间的选择算法

同时求数组的最大值和最小值

完整代码：

#include <iostream>
#include<cstdlib>
#include<ctime>

using namespace std;

/*
* 包含结果的结构体，里面含有最大值和最小值
*/
struct result {
public:
int max;
int min;
result() : max(0), min(0) {}
};

result* getMinMax(int a[], int len)
{
result* re = new result();
if (len == 0) {
return 0;
}
if (len == 1) {
re->max = a[0];
re->min = a[0];
return re;
}
if (len == 2) {
re->max = a[0] > a[1] ? a[0] : a[1];
re->min = a[0] < a[1] ? a[0] : a[1];
return re;
}

int max, min;
int i = 0;
if (len % 2 == 0) {
//元素个数为偶数的情况
re->max = a[i] > a[i + 1] ? a[i] : a[i + 1];
re->min = a[i] < a[i + 1] ? a[i] : a[i + 1];
i += 2;
}
else {
//元素个数为奇数的情况
re->max = a[i];
re->min = a[i];
i++;
}

while (i < len) {
//在成对的数中比较取值，然后再分别与max和min进行比较
max = a[i] > a[i + 1] ? a[i] : a[i + 1];
min = a[i] < a[i + 1] ? a[i] : a[i + 1];
i += 2;
re->max = re->max > max ? re->max : max;
re->min = re->min < min ? re->min : min;
}
return re;
}

void Swap(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
}

int Partition(int arr[], int begin, int end)
{
int pivot = arr[begin];
int i = begin;
for (int j = begin + 1; j <= end; ++j)
if (arr[j] <= pivot)
{
++i;
Swap(arr[i], arr[j]);
}

Swap(arr[i], arr[begin]);

return i;
}

int Rand_Partition(int arr[], int begin, int end)
{
srand(time(NULL));   //根据系统时间设置随机数种子
int i = rand() % (end - begin + 1) + begin;   //取得区间[begin,end+1)的整数

Swap(arr[i], arr[begin]);

return Partition(arr, begin, end);

}

void Rand_QuickSort(int arr[], int begin, int end)
{
if (begin < end)
{
int q = Rand_Partition(arr, begin, end);

Rand_QuickSort(arr, begin, q - 1);
Rand_QuickSort(arr, q + 1, end);

}
}

int Rand_Select(int arr[], int begin, int end, int i)
{
if (begin == end)
return arr[begin];

int q = Rand_Partition(arr, begin, end);
int k = q - begin + 1;

if (i == k)
return arr[q];

else if (i < k)
return Rand_Select(arr, begin, q - 1, i);
else
return Rand_Select(arr, q + 1, end, i - k);

}

int main()
{

int a[9] = { 5, 8, 0, -89, 9, 22, -1, -31, 98 };
result* r1 = getMinMax(a, 9);
cout << "最大值为：" << r1->max << "，最小值为：" << r1->min << endl;

int b[10] = { 5, 8, 0, -89, 9, 22, -1, -31, 98, 2222 };
result* r2 = getMinMax(b, 10);
cout << "最大值为：" << r2->max << "，最小值为：" << r2->min << endl;

delete r1;
delete r2;

int c[] = { 12, 23, 34, 45, 11, 32, 9, 22, 55 };

cout << "第5小的数是：";
cout << Rand_Select(c, 0, 8, 5) << endl;

Rand_QuickSort(c, 0, 8);

cout << "随机化的快速排序：";
for (int i = 0; i <= 8; i++)
cout << c[i] << " ";
cout << endl;

system("pause");
return 0;
}

4. 最坏线性时间选择顺序统计量的方法

核心在于：要保证对数组的划分是一个好的划分。

对PARTITION过程进行了修改。现在通过SELECT算法来确定n个元素的输入数组中的第i小的元素，具体操作步骤如下：

（1）将输入数组的n个元素划分为n/5（上取整）组，每组5个元素，且至多只有一个组有剩下的n%5个元素组成。（为何是5，而不是其他数，有点不明白。）

（2）寻找每个组织中中位数。首先对每组中的元素（至多为5个）进行插入排序，然后从排序后的序列中选择出中位数。

（3）对第2步中找出的n/5（上取整）个中位数，递归调用SELECT以找出其中位数x。（如果是偶数去下中位数）

（4）调用PARTITION过程，按照中位数x对输入数组进行划分。确定中位数x的位置k。

（5）如果i=k，则返回x。否则，如果i小于k，则在地区间递归调用SELECT以找出第i小的元素，若干i>k，则在高区找第(i-k)个最小元素。

SELECT算法通过中位数进行划分，可以保证每次划分是对称的，这样就能保证最坏情况下运行时间为θ(n)。

举个例子说明此过程，求集合A={32,23,12,67,45,78,10,39,9,58,125,84}的第5小的元素，操作过程如下图所示：



最坏线性时间选择顺序统计量的方法

完整代码：

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <random>
using namespace std;

int find_mid(int M[], int size = 5) {
vector<int> v{};
for (int i = 0; i < size; ++i)
v.push_back(M[i]);
sort(v.begin(), v.end());
return v[(size - 1) / 2];
}

void bult_the_mids(int A[], int mids_array[], int begin, int end, int sub_array_num, int last_array_size) {
for (int i = 0; i < sub_array_num; ++i) {
if (i != sub_array_num - 1) {
int* M = new int[5] {};
for (int j = 0; j < 5; ++j) {
M[j] = A[begin + i * 5 + j];
}
mids_array[i] = find_mid(M);
delete[]M;
}
else {
int* M = new int[last_array_size] {};
for (int j = 0; j < last_array_size; ++j) {
M[j] = A[begin + i * 5 + j];
}
mids_array[i] = find_mid(M, last_array_size);
delete[]M;
}
}
}

int find_index_by_value(int A[], int begin, int end, int x) {
int i{};
for (i = begin; i <= end; ++i) {
if (A[i] == x)
break;
}
return i;
}

int partition(int A[], int begin, int end, int choice) {
int i{ begin - 1 };
int j{ begin };
swap(A[end], A[choice]);
for (; j <= end - 1; ++j) {
if (A[j] <= A[end]) {
i++;
swap(A[i], A[j]);
}
}
swap(A[i + 1], A[end]);
return i + 1;
}

int select(int A[], int begin, int end, int xth) {
if (end <= begin) {
return A[begin];
}
else {
int size_of_A = end - begin + 1;
int sub_array_num = ceil(size_of_A / 5.0f);
int last_array_size = (size_of_A % 5) == 0 ? 5 : size_of_A % 5;
int* mids_array = new int[sub_array_num] {};
bult_the_mids(A, mids_array, begin, end, sub_array_num, last_array_size);
int the_mid_of_mids = select(mids_array, 0, sub_array_num - 1, (sub_array_num - 1) / 2);
delete[]mids_array;
int index_of_final_mid{};
index_of_final_mid = find_index_by_value(A, begin, end, the_mid_of_mids);
int pivot{};
pivot = partition(A, begin, end, index_of_final_mid);
if (pivot == xth) {
return A[pivot];
}
if (pivot > xth){
return select(A, begin, pivot - 1, xth);
}
else{
return select(A, pivot + 1, end, xth);
}
}
}

bool check_exist(vector<int> v, int x) {
for (auto i : v) {
if (i == x)
return false;
}
return true;
}

int main(int argc, const char * argv[]) {
int n;
cout << "please enter the sum of elements you want to produce :" << endl;
cin >> n;
random_device rd{};
default_random_engine e{ rd() };
uniform_int_distribution<int> u{ -100, 500 };
vector<int> v{};
while (v.size() < n) {
int element{ static_cast<int>(round(u((e)))) };
if (check_exist(v, element))
v.push_back(element);
}
cout << "the array is :" << endl;
for (auto i : v) {
cout << i << " ";
}
cout << endl;
int* A = new int[v.size()]{};
int  index{};
for_each(v.begin(), v.end(), [=](int x)mutable{ A[index++] = x; });
int xth{};
cout << "please choose the index you want to select:" << endl;
cin >> xth;
cout << "the result is :" << endl;
int result{};
result = select(A, 0, static_cast<int>(v.size() - 1), xth);
cout << result << endl;
delete[]A;
cout << "(cheat here) sorted array :" << endl;
sort(v.begin(), v.end());
for (auto i : v) {
cout << i << " ";
}
cout << endl;
system("pause");
return 0;
}