希尔排序算法代码

template<typename T>
void shellSort(T arr[], int n) {

    // 计算 increment sequence: 1, 4, 13, 40, 121, 364, 1093...
    int h = 1;
    while (h < n / 3)
        h = 3 * h + 1;

    while (h >= 1) {

        // h-sort the array
        for (int i = h; i < n; i++) {

            // 对 arr[i], arr[i-h], arr[i-2*h], arr[i-3*h]... 使用插入排序
            T e = arr[i];
            int j;
            for (j = i; j >= h && e < arr[j - h]; j -= h)
                arr[j] = arr[j - h];
            arr[j] = e;
        }

        h /= 3;
    }
}

冒泡排序算法代码

template<typename T>
void BubbleSort(T arr[], int n)
{
    for (int i = 0; i < n-1; i++)
    {
        for (int j = i + 1; j < n; j++)
        {
            if (arr[i] > arr[j])swap(arr[i], arr[j]);
        }
    }
}
template<typename T>
void bubbleSort(T arr[], int n)
{
    bool swapped;
    do {
        swapped = false;
        for (int i = 1; i < n; i++)
        {
            if (arr[i - 1] > arr[i])
            {
                swap(arr[i - 1], arr[i]);
                swapped = true;
            }
        }
        // 优化, 每一趟Bubble Sort都将最大的元素放在了最后的位置
        // 所以下一次排序, 最后的元素可以不再考虑
        n--;
    } while (swapped);
}

template<typename T>
void bubbleSort2(T arr[], int n)
{
    int newn;//使用new进行优化
    do {
        newn = 0;
        for (int i = 1; i < n; i++)
        {
            if (arr[i - 1] > arr[i])
            {
                swap(arr[i - 1], arr[i]);
                newn = i;
            }
        }
        n = newn;
    } while (newn > 0);
}

选择排序

template<typename T>
void selectionSort(T arr[], int n)
{
    for (int i = 0; i < n; i++)
    {
        //寻找[i, n)区间里的最小值
        int minIndex = i;
        for (int j = i + 1; j < n; j++)
        {
            if (arr[j] < arr[minIndex])
                minIndex = j;
        }
        swap(arr[i], arr[minIndex]);
    }
}
template<typename T>
void selectionSort2(T arr[], int n) {

    int left = 0, right = n - 1;
    while (left < right) {
        int minIndex = left;
        int maxIndex = right;

        // 在每一轮查找时, 要保证arr[minIndex] <= arr[maxIndex]
        if (arr[minIndex] > arr[maxIndex])
            swap(arr[minIndex], arr[maxIndex]);

        for (int i = left + 1; i < right; i++)
            if (arr[i] < arr[minIndex])
                minIndex = i;
            else if (arr[i] > arr[maxIndex])
                maxIndex = i;

        swap(arr[left], arr[minIndex]);
        swap(arr[right], arr[maxIndex]);

        left++;
        right--;
    }

    return;
}

插入排序

template<typename T>
void insertionSort(T arr[], int n)
{
    for (int i = 1; i < n; i++)
    {
        //寻找元素arr[i]合适的插入位置
        T e = arr[i];
        int j;//j保存元素e应该插入的位置
        for (j = i; (j > 0) && (e < arr[j - 1]); j--)
        {
            arr[j] = arr[j-1];
        }
        arr[j] = e;
    }
}

运算性能对比结果

随机乱数
insertionSort  : 0.053 s
selectionSort  : 0.11 s
BubbleSort  : 1.414 s
bubbleSort  : 1.766 s
bubbleSort2  : 1.775 s
selectionSort2  : 0.058 s
shellSort  : 0.001 s
适当有序
insertionSort  : 0.004 s
selectionSort  : 0.106 s
BubbleSort  : 0.231 s
bubbleSort  : 0.244 s
bubbleSort2  : 0.242 s
selectionSort2  : 0.057 s
shellSort  : 0.001 s
请按任意键继续. . .