选择算法

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;
}

版权声明：本文为博主原创文章，未经博主允许不得转载。