各种排序算法实现

 

#include <iostream>
#include <random>
#include <ctime>
#include <string>

using namespace std;

namespace TestHelper
{
    template <typename T>
    T* generateRandArray(T l, T r, int n)
    {
        T *arr = new T[n];
        srand(time(NULL));

        for (int i = 0; i < n; i++)
        {
            arr[i] = l + rand() % (r - l);
        }

        return (arr);
    }


    template <typename T>
    T* copyRandArray(const T *arr, int n)
    {
        T *ret = new T[n];

        for (int i = 0; i < n; i++)
        {
            ret[i] = arr[i];
        }

        return (ret);
    }


    template <typename T>
    bool isSorted(T *arr, int n)
    {
        for (int i = 0; i < n - 1; i++)
        {
            if (arr[i] > arr[i+1])
            {
                return false;
            }
        }

        return true;
    }


    template <typename T>
    void testRuntime(string funcname, void (*func)(T*, int), T *arr, int n)
    {
        int Start = clock();
        func(arr, n);
        int End = clock();

        if (isSorted(arr, n))
        {
            cout << funcname << " -> clocks:" << End - Start << ", sec:" << ((double)(End - Start)) / CLOCKS_PER_SEC << "s" << endl;
        }
        else
        {
            cout << funcname << " sort failed." << endl;
        }
    }


    template <typename T>
    void printArray(const T arr, int n)
    {
        for (int i = 0; i < n; i++)
        {
            cout << arr[i] << " ";
        }
        cout << endl;
        cout << endl;
    }
}

// 冒泡排序
template <typename T>
void bubbleSort(T arr[], int len)
{
    for (int i = 0; i < len-1; i++)
    {
        for (int j = i+1; j < len; j++)
        {
            if (arr[j] < arr[i])
            {
                swap(arr[i], arr[j]);
            }
        }
    }
}

// 选择排序
template <typename T>
void selectionSort(T arr[], int len)
{
    for (int i = 0; i < len-1; i++)
    {
        int idx = i;
        for (int j = i+1; j < len; j++)
        {
            if (arr[j] < arr[idx])
            {
                idx = j;
            }
        }

        swap(arr[i], arr[idx]);
    }
}

// 插入排序
template <typename T>
void insertionSort(T arr[], int len)
{
    for (int i = 1; i < len; i++)
    {
        for (int j = i; (j > 0 && arr[j] < arr[j-1]); j--)
        {
            swap(arr[j], arr[j-1]);
        }
    }
}

// 插入排序->优化
template <typename T>
void insertionSortOptimized(T arr[], int len)
{
    for (int i = 1; i < len; i++)
    {
        T tmp = arr[i];
        int j;
        for (j = i; (j > 0 && tmp < arr[j-1]); j--)
        {
            arr[j] = arr[j-1];
        }
        arr[j] = tmp;
        //TestHelper::printArray(arr, len);
    }
}

int main()
{
    int n = 50000;
    int *arr1 = TestHelper::generateRandArray(0, 1000, n);
    int *arr2 = TestHelper::copyRandArray(arr1, n);
    int *arr3 = TestHelper::copyRandArray(arr1, n);
    int *arr4 = TestHelper::copyRandArray(arr1, n);

    //TestHelper::printArray(arr1, n);

    TestHelper::testRuntime("bubbleSort", bubbleSort, arr1, n);
    //TestHelper::printArray(arr1, n);
    TestHelper::testRuntime("selectionSort", selectionSort, arr2, n);
    //TestHelper::printArray(arr2, n);
    TestHelper::testRuntime("insertionSort", insertionSort, arr3, n);
    //TestHelper::printArray(arr3, n);
    TestHelper::testRuntime("insertionSortOptimized", insertionSortOptimized, arr4, n);
    //TestHelper::printArray(arr4, n);

    return 0;
}