Виды сортировки

#include <iostream>
 
using namespace std;
 
void bubble(int* x, int n)
{
    bool exchanges;
 
    do
    {
        exchanges = false;
        for (int i = 0; i < n - 1; i++)
        {
            if (x[i] > x[i + 1])
            {
                // Exchange elements
                int temp = x[i];
                x[i] = x[i + 1];
                x[i + 1] = temp;
                exchanges = true;
            }
        }
    } while (exchanges);
}
void Insertion(int* x, int n)
{
 
    int i, j, temp;
 
    for (i = 0; i < n; ++i)
    {
        temp = x[i];
        for (j = i - 1; j >= 0; --j)
        {
            if (temp < x[j]) x[j + 1] = x[j];
            else break;
        }
        x[j + 1] = temp;
    }
}
 
void merge(int *, int, int, int);
void merge_sort(int *arr, int low, int high)
{
    int mid;
    if (low < high) {
        //divide the array at mid and sort independently using merge sort
        mid = (low + high) / 2;
        merge_sort(arr, low, mid);
        merge_sort(arr, mid + 1, high);
        //merge or conquer sorted arrays
        merge(arr, low, high, mid);
    }
}
// Merge sort 
void merge(int *arr, int low, int high, int mid)
{
    int i, j, k, c[50];
    i = low;
    k = low;
    j = mid + 1;
    while (i <= mid && j <= high) {
        if (arr[i] < arr[j]) {
            c[k] = arr[i];
            k++;
            i++;
        }
        else {
            c[k] = arr[j];
            k++;
            j++;
        }
    }
    while (i <= mid) {
        c[k] = arr[i];
        k++;
        i++;
    }
    while (j <= high) {
        c[k] = arr[j];
        k++;
        j++;
    }
    for (i = low; i < k; i++) {
        arr[i] = c[i];
    }
}
 
void swap(int* a, int* b)
{
    int t = *a;
    *a = *b;
    *b = t;
}
 
// partition the array using last element as pivot
int partition(int arr[], int low, int high)
{
    int pivot = arr[high];    // pivot 
    int i = (low - 1);
 
    for (int j = low; j <= high - 1; j++)
    {
        //if current element is smaller than pivot, increment the low element
        //swap elements at i and j
        if (arr[j] <= pivot)
        {
            i++;    // increment index of smaller element 
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}
 
//quicksort algorithm
void quickSort(int arr[], int low, int high)
{
    if (low < high)
    {
        //partition the array 
        int pivot = partition(arr, low, high);
 
        //sort the sub arrays independently 
        quickSort(arr, low, pivot - 1);
        quickSort(arr, pivot + 1, high);
    }
}
void qs(int* x, int left, int right)
{
    int i, j;
    int pivot, temp;
 
    i = left;
    j = right;
    pivot = x[(left + right) / 2];
 
    do
    {
        while ((x[i] < pivot) && (i < right)) i++;
        while ((pivot < x[j]) && (j > left)) j--;
 
        if (i <= j)
        {
            temp = x[i];
            x[i] = x[j];
            x[j] = temp;
            i++; j--;
        }
    } while (i <= j);
 
    if (left < j) qs(x, left, j);
    if (i < right) qs(x, i, right);
}
 
void print(int* x, int n)
{
    for (int i = 0; i<n; ++i)
        cout << x[i] << " ";
    cout << endl;
}
 
int main()
{
    int N = 10;
    int*x = new int[N];
    int*y = new int[N];
    for (int i = 0; i < N; ++i)
        y[i] = rand();
 
    print(y, N);
    x = y;
    bubble(x,N); // Пузырьковая
    print(x, N);
 
    x = y;
    Insertion(x, N); // Сортировка вставками
    print(x, N);
 
    x = y;
    merge_sort(x, 0, N - 1); //  Сортировка слиянием
    print(x, N);
 
    x = y;
    quickSort(x, 0, N-1); //  Быстрая сортировка
    print(x, N);
 
    return 0;
 
}