Sortowania na tablicach + pomiar czasu

#include <iostream>

#include <utility>

#include <algorithm>

#include <random>

#include <chrono>

#include <ctime>

using namespace std;

using chrono::duration_cast;
using chrono::milliseconds;
using chrono::seconds;
using chrono::system_clock;
template < typename T >
T * copy(T array[], long length) {
    auto resoult = new T[length];
    for (long i = 0; i < length; i++) {
        resoult[i] = array[i];
    }

    return resoult;
}
template < typename T >
vector < T > copy(vector < T > array) {
    vector < T > resoult;
    for (const auto & item: array) {
        resoult.push_back(item);
    }
    return resoult;

}

template < typename T >
T * generate(long length) {
    default_random_engine engine;
    uniform_int_distribution < int > distribution(-10000, 10000);
    auto resoult = new T[length];
    for (long i = 0; i < length; i++) {
        resoult[i] = distribution(engine);
    }

    return resoult;
}
template < typename T >
vector < T > generate_vec(long length) {
    default_random_engine engine;
    uniform_int_distribution < int > distribution(-10000, 10000);
    auto resoult = vector < T > (length);
    for (long i = 0; i < length; i++) {
        resoult[i] = distribution(engine);
    }

    return resoult;
}

template < typename T >
void sout(T arr, long length) {
    for (long l = 0; l < length - 1; l++) {
        cout << arr[l] << " ";
    }
    cout << endl;

}

template < typename T >
void sout(vector < T > arr) {
    for (const auto & item: arr) {
        cout << item << " ";
    }
    cout << endl;
}

template < typename T >
long partition(T * A, long l, long r) {
    T x = A[l];
    long i = l, j = r + 1;

    for (;;) {
        do ++i; while (i <= r && A[i] < x);
        do --j; while (A[j] > x);
        if (i > j) {
            break;
        }
        swap(A[i], A[j]);
    }
    A[l] = A[j];
    A[j] = x;
    return j;
}
template < typename T >
long partition(vector < T > A, long l, long r) {
    T x = A[l];
    long i = l, j = r + 1;

    for (;;) {
        do ++i; while (i <= r && A[i] < x);
        do --j; while (A[j] > x);
        if (i > j) {
            break;
        }
        swap(A[i], A[j]);
    }
    A[l] = A[j];
    A[j] = x;
    return j;
}

template < typename T >
long partition2(T * A, long l, long r) {
    T x = A[r];
    long i = l - 1;
    for (; l < r; ++l) {
        if (A[l] <= x)
            swap(A[++i], A[l]);
    }
    swap(A[i + 1], A[r]);
    return i + 1;
}

template < typename T >
long partition2(vector < T > A, long l, long r) {
    T x = A[r];
    long i = l - 1;
    for (; l < r; ++l) {
        if (A[l] <= x)
            swap(A[++i], A[l]);
    }
    swap(A[i + 1], A[r]);
    return i + 1;
}

template < typename T >
long partiation3(T * A, long l, long r) {

}

template < typename T >
void quickSort(T arr[], long poczatek, long koniec) {
    if (poczatek < koniec) {
        long index = partition(arr, poczatek, koniec);
        quickSort(arr, poczatek, index - 1);
        quickSort(arr, index + 1, koniec);
    }
}
template < typename T >
void quickSort(vector < T > arr, long poczatek, long koniec) {
    if (poczatek < koniec) {
        long index = partition(arr, poczatek, koniec);
        quickSort(arr, poczatek, index - 1);
        quickSort(arr, index + 1, koniec);
    }
}

template < typename T >
void bubbleSort(T arr[], long poczatek, long koniec) {
    int i, j, n = koniec;
    for (i = poczatek; i < n; i++)
        for (j = poczatek; j < n - i; j++)
            if (arr[j] > arr[j + 1])
                swap(arr[j], arr[j + 1]);
}
template < typename T >
void hybridQuickSort(T arr[], long poczatek, long koniec) {
    if (poczatek - koniec <= 10) {

        bubbleSort(arr, poczatek, koniec);
    } else
    if (poczatek < koniec) {
        long index = partition(arr, poczatek, koniec);
        hybridQuickSort(arr, poczatek, index - 1);
        hybridQuickSort(arr, index + 1, koniec);
    }
}
template < typename T >
void hybridQuickSort(vector < T > arr, long poczatek, long koniec) {
    if (poczatek - koniec <= 10) {

        bubbleSort(arr, poczatek, koniec);
    } else
    if (poczatek < koniec) {
        long index = partition(arr, poczatek, koniec);
        hybridQuickSort(arr, poczatek, index - 1);
        hybridQuickSort(arr, index + 1, koniec);
    }
}

template < typename T >
void bubbleSort(vector < T > arr, long poczatek, long koniec) {
    int i, j, n = koniec;
    for (i = poczatek; i < n; i++)
        for (j = poczatek; j < n - i; j++)
            if (arr[j] > arr[j + 1])
                swap(arr[j], arr[j + 1]);
}
int main() {
    long * elementy10_1 = generate < long > (10);
    long * elementy10_2 = copy(elementy10_1, 10);
    long * elementy10_3 = copy(elementy10_1, 10);

    long * elementy1000_1 = generate < long > (1000);
    long * elementy1000_2 = copy(elementy10_1, 1000);
    long * elementy1000_3 = copy(elementy10_1, 1000);

    long * elementy100000_1 = generate < long > (100000);
    long * elementy100000_2 = copy(elementy10_1, 100000);
    long * elementy100000_3 = copy(elementy10_1, 100000);

    auto buble_time_10_start = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    bubbleSort(elementy10_1, 0, 10);
    auto buble_time_10_end = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    auto buble_time_1000_start = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    bubbleSort(elementy1000_1, 0, 1000);
    auto buble_time_1000_end = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    auto buble_time_100000_start = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    bubbleSort(elementy100000_1, 0, 100000);
    auto buble_time_100000_end = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    ////////////////////////////////////////
    auto hybrid_time_10_start = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    hybridQuickSort(elementy10_2, 0, 10);
    auto hybrid_time_10_end = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    auto hybrid_time_1000_start = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    hybridQuickSort(elementy1000_2, 0, 1000);
    auto hybrid_time_1000_end = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    auto hybrid_time_100000_start = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    hybridQuickSort(elementy100000_2, 0, 100000);
    auto hybrid_time_100000_end = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    ////////////////////////////////////////
    auto quick_time_10_start = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    quickSort(elementy10_3, 0, 10);
    auto quick_time_10_end = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    auto quick_time_1000_start = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    quickSort(elementy1000_3, 0, 1000);
    auto quick_time_1000_end = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    auto quick_time_100000_start = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();
    quickSort(elementy100000_3, 0, 100000);
    auto quick_time_100000_end = duration_cast < milliseconds > (system_clock::now().time_since_epoch()).count();

    cout << endl;
    cout << "Dla 10 elementow buble sortem " << buble_time_10_end - buble_time_10_start << endl;
    cout << "Dla 1000 elementow buble sortem " << buble_time_1000_end - buble_time_1000_start << endl;
    cout << "Dla 100000 elementow buble sortem " << buble_time_100000_end - buble_time_100000_start << endl;

    cout << "Dla 10 elementow hybrydowym sortowaniem " << hybrid_time_10_end - hybrid_time_10_start << endl;
    cout << "Dla 1000 elementow hybrydowym sortowaniem " << hybrid_time_1000_end - hybrid_time_1000_start << endl;
    cout << "Dla 100000 elementow hybrydowym sortowaniem " << hybrid_time_100000_end - hybrid_time_100000_start << endl;

    cout << "Dla 10 elementow quick sortem " << quick_time_10_end - quick_time_10_start << endl;
    cout << "Dla 1000 elementow quick sortem " << quick_time_1000_end - quick_time_1000_start << endl;
    cout << "Dla 100000 elementow quick sortem " << quick_time_100000_end - quick_time_100000_start << endl;

    std::cout << "Hello, World!" << std::endl;
    return 0;
}