Поиск N-ого количества максимальных значений в массиве

void search_k_max(int arr[], int size, int k) {
    int max = arr[0];//Переменная для поиска максимального элемента
    int count = 0;//Счетчик элемента
    for (int i = 0; i < size; i++) {//Поиск максимального элемента
        if (arr[i] > max)
            max = arr[i];
    }
    for (int i = 0; i < size&&count < k; i++) {//Поиск и вывод на экран всех максимальных значений K раз
        if (arr[i] == max) {
            cout << arr[i] << ' ';
            count++;
        }
 
    }
    if (count < k) {//Если максимальных значений меньше чем K
        while (count < k) {
            max--;//Следующее максимальное значение,меньше предыдущего на 1
            for (int i = 0; i < size&&count < k; i++)
                if (arr[i] == max) {
                    cout << arr[i] << ' ';
                    count++;
                }
        }
    }
    cout << endl;
}

//g++  5.4.0
 
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
 
template<typename ForwardIterator>
std::vector<ForwardIterator> max_n(ForwardIterator begin, ForwardIterator end, size_t count)
{
    std::vector<ForwardIterator> result;
    if (count == 0 || begin == end) {
        return result;
    }
    size_t st_count = std::min<size_t>(std::distance(begin, end), count);
    result.reserve(st_count + 1);
    ForwardIterator current = begin;
    std::advance(current, st_count);
    result.resize(st_count);
    std::iota(result.begin(), result.end(), begin);
    auto cmp = [](auto f, auto s) { return *f > *s; };
    std::sort(result.begin(), result.end(), cmp);
    if (st_count != count) {
        return result;
    }
    for (; current != end; ++current) {
        if (*current > *result.back()) {
            auto lbound = std::lower_bound(result.begin(), result.end(), current, cmp);
            result.insert(lbound, current);
            result.pop_back();
        }
    }
    return result;
}
 
 
int main()
{
    int arr[] = {9, 1, 4, 5, 2, 8, 3, 7, 8, 3, 7, 4, 5, 8, 6};
    for (auto e: max_n(arr, arr + sizeof(arr) / sizeof(*arr), 8)) {
        std::cout << *e << ' ';
    }
}

#include <iostream>
#include <iterator>
 
void search_k_max(int *arr, int size, int *dst, int k){
    dst[0] = arr[0];
    int m = 1;
    for(int i = 1; i < size; i++) {
        int j = m;
        while(j > 0 && dst[j - 1] < arr[i]) {
            if(j < m) dst[j] = dst[j - 1];
            j--;
        }
        if(j < m || m < k) dst[j] = arr[i];
        if(m < k) m++;
    }
}
 
int main()
{
    int a[] = {146, 27, 15, 3, 7, 82, 9, 32, 5, 12};
    int a_size = sizeof(a) / sizeof(int);
    int b[] = {0, 0, 0 };
    int b_size = sizeof(b) / sizeof(int);
    search_k_max(a, a_size, b, b_size);
    std::copy(b, b + b_size, std::ostream_iterator<int>(std::cout, " "));
    return 0;
}

//Запись k наибольших элементов массива arr размером size в массив dst.
void search_k_max(int *arr, int size, int *dst, int k){
    dst[0] = arr[0]; //Берем 0-ой элемент массива arr в массив dst.
    int j, m = 1;
    //Для элементов массива arr с индексами от 1 до size-1...
    for(int i = 1; i < size; i++) {
        //Проходим по позициям массива dst с индексами от m до 0 и ищем позицию,
        //куда можно вставить i-й элемент массива arr так, чтобы он был
        //больше следующего за ним элемента массива dst. Если наименьший
        //элемент массива dst больше или равен i-му элемент массива arr,
        //то i-й элемент массива arr вставляется в конец массива dst.
        for(j = m; j > 0; j--) {
            if(dst[j - 1] >= arr[i]) break;
            //Если i-й элемент массива arr вставляется не в конец массива dst,
            //а в начало или середину массива, то сдвигаем элементы массива dst так,
            //чтобы i-й элемент массива arr можно было вставить на выбранную позицию.
            if(j < m) dst[j] = dst[j - 1];
        }
        //Если найдена позиция для вставки i-го элемента массива arr внутрь
        //или в начало массива dst, вставляем этот элемент. Иначе добавляем
        //i элемент массива arr в конец массива dst, если в нем еще есть свободные
        //места.
        if(j < m || m < k) dst[j] = arr[i];
        //Если количество занятых мест еще не равно максимальному размеру массива,
        //увеличиваем счетчик количества занятых мест.
        if(m < k) m++;
    }
}

#include <iostream>
 
void search_k_max(int *arr, int size, int k){
    for(int i = 0; i < k; i++)
        for(int j = 0; j < size - i - 1; j++)
            if(arr[j] > arr[j + 1]) std::swap(arr[j], arr[j + 1]);
}
 
int main()
{
    int a[] = {146, 27, 15, 3, 7, 82, 9, 32, 5, 12};
    int a_size = sizeof(a) / sizeof(int);
    int k = 3;
    search_k_max(a, a_size, k);
    for(int i = a_size - k; i < a_size; i++)
        std::cout << a[i] << " ";
    return 0;
}