Переделать код, изменить алгоритм и тип элемента данных

#include <fstream>
#include <iostream>
#include <conio.h>
#include <stdlib.h>
#include <string>
#include <thread>
#include <omp.h>
using namespace std;
void ArrayShow(int** A, int row, int cols);// Вывод массива на экран
void ArrayInit(int** A, int row, int cols);// Заполнение массива случайными числами
 
 
int main()
{
    setlocale(LC_ALL, "");
    int k, i, j, tmp = 0;
    int** A;
    int P;
    const int row = 10;
    const int cols = 10;
    int first;
    double timein, timeout, timein1, timeout2, dt, dt2;
    cout << "В какое количество потоков будем сортировать?\n";
    cin >> P;
 
    {
        A = new int* [row];
        for (int i = 0; i < row; i++) A[i] = new int[cols];
        ArrayInit(A, row, cols);
        cout << "массив сгенирирован\n";
        ArrayShow(A, row, cols);
        cout << "Сортировка методом пузырька\n";
        timein = omp_get_wtime();
        for (int k = 0; k < row * cols; ++k) {
            int temp;
#pragma omp parallel num_threads(P)\
  default(none), shared(A, first, row,cols,k,tmp, i)
#                pragma omp for
            for (int i = 0; i < row; ++i) {
                for (int j = 0; j < cols; ++j) {
                    if (i != cols - 1) {
                        if (A[i + 1][j] < A[i][j]) {
                            int tmp = A[i + 1][j];
                            A[i + 1][j] = A[i][j];
                            A[i][j] = tmp;
                        }
                    }
 
                }
            }
        }
        timeout = omp_get_wtime();
        dt = timeout - timein;
        cout << "Сортировка завершена:\n";
        ArrayShow(A, row, cols);
        cout << "Время вычислений: " << dt << " секунд. " << "Кол-во потоков: " << P << "\n" << endl;
    }
    return 0;
}
 
//Заполнение массива
void ArrayInit(int** A, int row, int cols)
{
    cout << "Заполняем массив случайными числами:\n";//Ввод чисел в двумерный массив А
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            A[i][j] = 0 + rand() % 100;
        }
    }
}
// Отображение массива
void ArrayShow(int** A, int row, int cols)
{
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            cout << " " << A[i][j];
        }
        cout << "\n";
    }
}

#include <fstream>
#include <iostream>
#include <conio.h>
#include <stdlib.h>
#include <string>
#include <thread>
#include <omp.h>
using namespace std;
void ArrayShow(int* A, int n);// Вывод массива на экран
void ArrayInit(int* A, int n);// Заполнение массива случайными числами
void heapSort(int* A, int n);//Сортировка методом пирамиды
int P=5;
 
 
int main()
{
    setlocale(LC_ALL, "");
    double timein, timeout, dt;
    cout << "В какое количество потоков будем сортировать?\n";
   
    int A[] = { 78,12,56,12,42,76,34,9,11,8,88 };
        int n = sizeof(A) / sizeof(A[0]);
        for (int i = 0; i < n; i++) ;
        //ArrayInit(A, n);
        cout << "Массив сгенирирован\n";
 
        for (int i = 0; i < n; i++)
        {
            cout << " " << A[i];
        }
 
        cout << "\nСортировка методом пирамиды\n";
        timein = omp_get_wtime();
        heapSort(A, n);
       
      
        timeout = omp_get_wtime();
        dt = timeout - timein;
        cout << "Сортировка завершена:\n";
 
        for (int i = 0; i < n; i++)
        {
            cout << " " << A[i];
        }
 
        cout << "\nВремя вычислений: " << dt << " секунд. " << "Кол-во потоков: " << P << "\n" << endl;
        
        cout << endl;
    return 0;
}
 
void heapify(int A[], int n, int i)
{
    int largest = i;
    // Инициализируем наибольший элемент как корень
    int l = 2 * i + 1; // левый = 2*i + 1
    int r = 2 * i + 2; // правый = 2*i + 2
 
 // Если левый дочерний элемент больше корня
    if (l < n && A[l] > A[largest])
        largest = l;
 
    // Если правый дочерний элемент больше, чем самый большой элемент на данный момент
    if (r < n && A[r] > A[largest])
        largest = r;
 
    // Если самый большой элемент не корень
    if (largest != i)
    {
        swap(A[i], A[largest]);
 
        // Рекурсивно преобразуем в двоичную кучу затронутое поддерево
        heapify(A, n, largest);
    }
}
 
// Основная функция, выполняющая пирамидальную сортировку
void heapSort(int A[], int n)
{
#pragma omp parallel num_threads(P)\
  default(none), shared(A,n)
#                pragma omp for
 
    // Построение кучи (перегруппируем массив)
    for (int i = n / 2 - 1; i >= 0; i--)
 
        heapify(A, n, i);
 
    // Один за другим извлекаем элементы из кучи
    for (int i = n - 1; i >= 0; i--)
    {
        // Перемещаем текущий корень в конец
        swap(A[0], A[i]);
 
        // вызываем процедуру heapify на уменьшенной куче
        heapify(A, i, 0);
    }
}