Рекомендация: прочитайте задачу! Выполните ее и сравните полученный результат с картинкой CMD

Если вы полностью уверены что не можете осилить эту задачу, советую вам просмотреть код и полностью в нем разобраться! Протестировать все в отладчике!

Написать многофайловую программу, в которой реализованы следующие возможности:
 Генерация одномерного массива вещественных чисел (количество элементов и границы диапазона выступают как параметры).
 Вывод массива на экран одной строкой.
 Клонирование массива.
 Сортировка массива выбором.
 «Пузырьковая» сортировка массива.
 Сортировка массива вставками.
 Быстрая сортировка Хоара
Каждая задача в программе реализована отдельной процедурой или функцией.
Функции, реализующие сортировки, вынести в отдельный файл (все в один или каждую по отдельности).
При выполнении сортировки провести замер времени выполнения программы. Продемонстрировать работу кода путем генерации массива и его сортировки различными методами.
Внимание: сортировку необходимо сделать именно для первоначально сгенерированного массива.

#pragma once
#include <iostream> 
#include <ctime>
using namespace std; 
#define STOP_Program system("PAUSE>>VOID"); 
void Array_Rand(int * arr, int size, int max, int min);
void Print_Array(int * arr, int size);
void Cloning_Array(int * arr, int size);
void Sort_Boobble_Array(int * arr, int size);
void Insert_Sort_Array(int * arr, int size);
void Selection_Sort_Array(int * arr, int size);
void Quick_Sort_Array(int * arr, int length);
void Backup_Array(int * arr, int * BackupArr, int length);	

//Functions.cpp	
#include "H.h"

void Backup_Array(int * arr, int * CopyArr, int length) { // Backup arrays
	for (int i = 0; i < length; i++)
		arr[i] = CopyArr[i];
}
void Array_Rand(int * arr, int size, int max, int min) { // Fill an array with random numbers with given ranges
	srand(time(NULL));
	for (int i = 0; i < size; i++)
		arr[i] = min + rand() % (max - min);
}
void Print_Array(int * arr, int size) { // Displaying an array on the screen
	for (int i = 0; i < size; i++) {
		cout << arr[i] << "\t";
	}
}
void Cloning_Array(int * arr, int size) { //Elements of the array are written to the array in reverse order
	int tmp = 0, counter = 0;
	for (int j = (size - 1) - counter; j > counter; j--) {
		tmp = arr[counter];
		arr[counter] = arr[j];
		arr[j] = tmp;
		counter++;
	}
}	

//#include "Functions_Sort.cpp"	
#include "H.h"

void Sort_Boobble_Array(int * arr, int size) { // boobble sort
	int tmp = 0;
	for (int i = 0; i < size; i++) {
		for (int j = size - 1; j > i; j--) {
			if (arr[j - 1] > arr[j]) { // Rearrange elements
				tmp = arr[j - 1];
				arr[j - 1] = arr[j];
				arr[j] = tmp;
			}
		}
	}
}
void Insert_Sort_Array(int * arr, int size) { // insert sort
	int tmp = 0;
	for (int i = 1; i < size; i++) {
		for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
			tmp = arr[j - 1]; // Rearrange elements
			arr[j - 1] = arr[j];
			arr[j] = tmp;
		}
	}
}
void Selection_Sort_Array(int * arr, int size) { //Selection Sort
	int i, j, min;
	int tmp;
	for (i = 0; i < size; i++) {
		min = i;
		tmp = arr[i];
		for (j = i + 1; j < size; j++) {
			if (arr[j] < tmp) {
				min = j; // index MIN 
				tmp = arr[j]; // Rearrange elements
			}
		}
		arr[min] = arr[i];
		arr[i] = tmp; //MIN = Array[i]
	}
}
void Quick_Sort_Array(int * arr, int length) { // Quick Sort
	int i = 0, j = length; // i = LEFT j = RIGHT
	int tmp = 0, Median = 0; // Median = supporting element
	Median = arr[(i + j / 2)]; //supporting element
	do {
		while (arr[i] < Median) i++;
		while (arr[j] > Median) j--;
		if (i <= j) { // Rearrange elements
			tmp = arr[i];
			arr[i] = arr[j];
			arr[j] = tmp;
			i++;
			j--;
		}
	} while (i <= j);
	// recursive calls, if there is, what to sort
	if (j > 0) Quick_Sort_Array(arr, j);
	if (length > i) Quick_Sort_Array(arr + i, length - i);
}	

#include "H.h"
void main() {
	clock_t start, end;
	char Start_Program = 0;
	double seconds = 0;
	int size = 0, max = 0, min = 0;
	int * PtrArr;
	int * Copy_Array;

	do {
		//----------------------------------------------------------------------------------
		cout << "===> Beta version 0.0.1" << endl;
		cout << "===> All the errors send us on Viber" << endl;
		cout << "The program demonstrates the time of sorting and cloning the array!\n"
			<< "Enter the function parameters:\n"
			<< "1.Size\n"
			<< "2.MAX Element\n"
			<< "3.MIN Element\n" << endl;
		cin >> size >> max >> min;

			PtrArr = new int[size]();
			Copy_Array = new int[size](); // Array Backup
//----------------------------------------------------------------------------------
			Array_Rand(PtrArr, size, max, min);
			for (int i = 0; i < size; i++) { Copy_Array[i] = PtrArr[i]; } // Copy Array
			Print_Array(PtrArr, size);
			cout << endl;
			cout << "<<< Cloning >>>" << endl;
			Cloning_Array(PtrArr, size);
			Print_Array(PtrArr, size);
			cout << endl;
			Backup_Array(PtrArr, Copy_Array, size); // Retrieve the original array 
//----------------------------------------------------------------------------------
			cout << "<<< Selections sort >>>" << endl;
			Print_Array(PtrArr, size);
			cout << endl;
			start = clock();
			Selection_Sort_Array(PtrArr, size);
			end = clock();
			Print_Array(PtrArr, size);
			seconds = (double)(end - start) / CLOCKS_PER_SEC;
			cout << endl;
			cout << "***(Selections) Time = " << seconds << endl;
			Backup_Array(PtrArr, Copy_Array, size); // Retrieve the original array 
//----------------------------------------------------------------------------------
			seconds = 0;
			cout << "<<< Boobble sort >>>" << endl;
			Print_Array(PtrArr, size);
			cout << endl;
			Backup_Array(Copy_Array, PtrArr, size);
			start = clock();
			Sort_Boobble_Array(PtrArr, size);
			end = clock();
			Print_Array(PtrArr, size);
			seconds = (double)(end - start) / CLOCKS_PER_SEC;
			cout << endl;
			cout << "***(Boobble)Time = " << seconds << endl;
			Backup_Array(PtrArr, Copy_Array, size); // Retrieve the original array 
//----------------------------------------------------------------------------------
			seconds = 0;
			cout << "<<< Insert sort >>>" << endl;
			Print_Array(PtrArr, size);
			cout << endl;
			Backup_Array(Copy_Array, PtrArr, size);
			start = clock();
			Insert_Sort_Array(PtrArr, size);
			end = clock();
			Print_Array(PtrArr, size);
			seconds = (double)(end - start) / CLOCKS_PER_SEC;
			cout << endl;
			cout << "***(Insert)Time = " << seconds << endl;
			Backup_Array(PtrArr, Copy_Array, size); // Retrieve the original array 
//----------------------------------------------------------------------------------
			seconds = 0;
			cout << "<<< Quick sort >>>" << endl;
			Print_Array(PtrArr, size);
			cout << endl;
			Backup_Array(Copy_Array, PtrArr, size);
			start = clock();
			Quick_Sort_Array(PtrArr, size - 1);
			end = clock();
			Print_Array(PtrArr, size);
			seconds = (double)(end - start) / CLOCKS_PER_SEC;
			cout << endl;
			cout << "***(Quick sort)Time = " << seconds << endl;
			Backup_Array(PtrArr, Copy_Array, size); // Retrieve the original array 
//---------------------------------------------------------------------------------- 
			cout << endl << endl;
			cout << "Go (y)" << endl;
			cin >> Start_Program;
			delete[] PtrArr;
			delete[] Copy_Array;
		} while (Start_Program == 'y');
//----------------------------------------------------------------------------------
		STOP_Program // ***Windows Console = pause***
}