@decoder12

#include "pch.h"
#include <iostream>
#include<stdio.h>
#include<ctime>
#include<vector>
#include<thread>
#include<chrono>
#include<mutex>
using namespace std;
using namespace chrono;
mutex mut;

void ThreadQuickSort(int arr[], int left1, int right1) {
mut.lock();
int i1 = left1, j1 = right1;
int tmp1;
int pivot1 = arr[(left1 + right1) / 2];
while (i1 <= j1) {
while (arr[i1] < pivot1)
i1++;
while (arr[j1] > pivot1)
j1--;
if (i1 <= j1) {
tmp1 = arr[i1];
arr[i1] = arr[j1];
arr[j1] = tmp1;
i1++;
j1--;
}
};
mut.unlock();
if (left1 < j1) {
thread thr3(ThreadQuickSort, arr, left1, j1);
thr3.join();
}
if (i1 < right1) {
thread thr4(ThreadQuickSort, arr, i1, right1);
thr4.join();
}
}

void quickSort(int arr[], int left, int right) {
int i = left, j = right;
mut.lock();
int i1 = left, j1 = right;
int tmp1;
int pivot1 = arr[(left + right) / 2];
while (i1 <= j1) {
while (arr[i1] < pivot1)
i1++;
while (arr[j1] > pivot1)
j1--;
if (i1 <= j1) {
tmp1 = arr[i1];
arr[i1] = arr[j1];
arr[j1] = tmp1;
i1++;
j1--;
}
};
mut.unlock();
if (left < j1) {
thread thr3(ThreadQuickSort, arr, left, j1);
thr3.join();
}
if (i1 < right) {
thread thr4(ThreadQuickSort, arr, i1, right);
thr4.join();
}
}

void quickRecurSort(int arr[], int left, int right) {
int i = left, j = right;
int tmp;
int pivot = arr[(left + right) / 2];
while (i <= j) {
while (arr[i] < pivot)
i++;
while (arr[j] > pivot)
j--;
if (i <= j) {
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
i++;
j--;
}
};

if (left < j)
quickSort(arr, left, j);
if (i < right)
quickSort(arr, i, right);
}

void print(int arr[], int n) {
for (int i = 0; i < n; i++) {
cout << arr[i] << endl;
}
cout << endl;
}

int main()
{
double diffrence;
setlocale(LC_ALL, "rus");
int n;
cin >> n;
int i,j;
double RecursDiffrence;
int* arr = new int[n];
for (i = 0; i < n; i++) {
arr[i] = rand() % 10000;
}
chrono::steady_clock::time_point threadBegin = chrono::steady_clock::now();
quickSort(arr, 0, n - 1);
chrono::steady_clock::time_point threadEnd = chrono::steady_clock::now();
mut.lock();
cout << "Thread sorted array :" << endl;
for (int i = 0; i < n; i++) {
cout << arr[i] << endl;
}
mut.unlock();
diffrence = chrono::duration_cast<chrono::microseconds>(threadEnd - threadBegin).count();
cout << endl << endl << "Thread USE Time = " << diffrence / 1000000 << endl;
int *arr1 = new int[n];
for(j= 0; j < n; j++) {
arr1[j] = rand() % 10000;
}
chrono::steady_clock::time_point recursBegin = chrono::steady_clock::now();
quickRecurSort(arr1, 0, n - 1);
chrono::steady_clock::time_point recursEnd = chrono::steady_clock::now();
cout << "Recurs sorted array :" << endl;
for (int j = 0; j < n; j++) {
cout << arr1[j] << endl;
}
RecursDiffrence = chrono::duration_cast<chrono::microseconds>(recursEnd - recursBegin).count();
cout << endl <<endl << "Recurs USE Time = " << RecursDiffrence / 1000000 << endl;
delete[] arr;
delete[] arr1;
}

0