C++ 快排思想 最小的k个数、最大的k个数
1、思路

快速排序的思路中，有一个分块函数partition.
partition函数，以升序数组a[]为例，它的作用：
以a[l]为基准，将“<a[l]”的数据全部存放在 a[l]的左边，“>a[l]”的数据全部存放在 a[l]的右边。返回a[l]最终所在数组的正确索引位置。
采用双路快排，从数组的两端开始，向中间推进。
故：最小的k个数，就是找到查看 partition函数返回的索引p是否与索引k相等，
// l:数组a最左边的数据，r:数组a最右边的数据
p<k,则检查[p+1,r]范围的数据
p>k,则检查[l,p-1]范围的数据.
p=k，结束递归。
此时数组a[]中，索引k左边的数据都"<a[k]"，即第0~k-1个数都“<a[k]”,即找到了最小的k个数。

2、快排思想 找最小的k个数、最大的k个数 头文件

#ifndef QUICKSORT_H
#define QUICKSORT_H

#include<iostream>
#include<algorithm>
#include<ctime>
using namespace std;

//-------------------------------------------------------
//二路快排 最大的k个数
void _qSort_big(int a[], int l, int r, int k);
void quickSort_big(int a[], int n, int k){
    srand(time(NULL));
    _qSort_big(a, 0, n - 1, k);

    for (int i = 0; i < k; ++i)//第0~k-1个数,即为最大的k个数
        cout << a[i] << "\t";
    cout << endl;
}
//l:数组a最左边的数据，r:数组a最右边的数据
int partition_big(int a[], int l, int r);//降序
//快排找到第k大的数
void _qSort_big(int a[], int l, int r, int k){
    if (l >= r)return;
    int p = partition_big(a, l, r);
    if (p == k)return;
    else if (p < k) _qSort_big(a, p + 1, r, k);//递归调用函数本身
    else _qSort_big(a, l, p - 1, k);
}
int partition_big(int a[], int l, int r){//降序
    swap(a[l], a[rand() % (r - l + 1) + l]);//随机挑选数组中的某个数作为分块基准，将使得该算法对于一个近乎有序的数组尽可能的避免退化成一个O(n^2)的算法。
    int v = a[l];
    int i = l + 1;//a[l+1...i-1]>0
    int j = r;//a[j+1...r]<0
    while (true){
        while (a[i] > v && i <= r)i++;//降序
        while (a[j] < v && j >= l + 1)j--;
        if (i > j)break;
        swap(a[i], a[j]);
        i++;
        j--;
    }
    swap(a[l], a[j]);
    return j;
}
//-------------------------------------------------------
//快排找到最小的k个数 法一
int partition(int a[], int l, int r);
void _qSort2(int a[], int l, int r, int k);
void quickSort2(int a[], int n, int k){
    srand(time(NULL));
    _qSort2(a, 0, n - 1, k);

    for (int i = 0; i < k; ++i)
        cout << a[i] << "\t";
    cout << endl;
}

void _qSort2(int a[], int l, int r, int k){
    if (l >= r)return;
    int p = partition(a, l, r);
    if (p == k)return;
    else if (p < k) _qSort2(a, p + 1, r, k);//递归调用函数本身
    else _qSort2(a, l, p - 1, k);
}

//-------------------------------------------------------
//快排找到最小的k个数 法二
void _qSort(int a[], int l, int r, int k);
void quickSort(int a[], int n, int k){
    srand(time(NULL));
    _qSort(a, 0, n - 1, k);
}

void _qSort(int a[], int l, int r, int k){
    if (l >= r)return;

    int p = partition(a, l, r);
    while (p!=k-1){
        if (p < k-1) p = partition(a, p + 1, r);//重复调用  partition
        if (p > k-1) p = partition(a, l, p - 1);
    }

    for (int i = 0; i < k; ++i)
        cout << a[i] << "\t";
    cout << endl;
}
//-------------------------------------------------------
//双路快排，从数组的两端开始，向中间推进。
//以a[l]为基准，将“<a[l]”的数据全部存放在 a[l]的左边，“>a[l]”的数据全部存放在 a[l]的右边
int partition(int a[], int l, int r){//升序  分块函数 
    swap(a[l], a[rand() % (r - l + 1) + l]);
    int v = a[l];
    int i = l + 1;//a[l+1...i-1]<0
    int j = r;//a[j+1...r]>0
    while (true){
        while (a[i] < v && i <= r)i++;
        while (a[j] > v && j >= l + 1)j--;
        if (i > j)break;
        swap(a[i], a[j]);
        i++;
        j--;
    }
    swap(a[l], a[j]);
    return j;
}

#endif//!QUICKSORT_H

3、主函数、测试用例

#include<iostream>
#include"quickSort.h"
using namespace std;

void test_quickSort();
void test_quickSort2();
void test_quickSort_big();
int main(){
    test_quickSort();
    test_quickSort2();
    test_quickSort_big();
    return 0;
}

void test_quickSort(){
    cout << "quickSort---最小的k个数----" << endl;
    int a[] = { 4, 0, 2, 9, 3, 4, 5, 1, 10, 3, 8, 2 };
    int n = sizeof(a) / sizeof(a[0]);
    for (int i = 1; i <= n;++i)
        quickSort(a, n, i);
}
void test_quickSort2(){
    cout << "quickSort2---最小的k个数----" << endl;
    int a[] = { 4, 0, 2, 9, 3, 4, 5, 1, 10, 3, 8, 2 };
    int n = sizeof(a) / sizeof(a[0]);
    for (int i = 1; i <= n; ++i)
        quickSort2(a, n, i);
}
void test_quickSort_big(){
    cout << "quickSort_big---最大的k个数----" << endl;
    int a[] = { 4, 0, 2, 9, 3, 4, 5, 1, 10, 3, 8, 2 };
    int n = sizeof(a) / sizeof(a[0]);
    for (int i = 1; i <= n; ++i)
        quickSort_big(a, n, i);
}