常见的排序算法

#include <iostream>
void dataSwap(int* a, int* b);
void Bubble_Sort(int* arr, int len);
void Insert_Sort(int* arr, int len);
void Selection_Sort(int* arr, int len);
void MergeS(int* arr, int low, int mid, int high, int* temp);
void Merge_Sort(int* arr, int low, int high, int* temp);
int Partition(int* arr, int iBegin, int iEnd);
void QuickSort(int* arr, int iBegin, int iEnd);
using namespace std;

int main()
{
    int arr[10] = {34, 1, 4, 6, 32, 0, 78, 3, 9, 100};
    cout << "排序前： ";
    for (int i = 0; i < 10; i++)
        cout << arr[i] << " ";
    cout << endl;
    // Bubble_Sort(arr, 10);
    // Insert_Sort(arr, 10);
    // Selection_Sort(arr, 10);
    int* temp = new int[sizeof(arr)/sizeof(arr[0])];
    Merge_Sort(arr, 0, 9, temp);
    delete [] temp;
    temp = NULL;
    // QuickSort(arr, iBegin, iEnd);
    cout << "排序后： ";
    for (int i = 0; i < 10; i++)
        cout << arr[i] << " ";
    cout << endl;
    return 0;
}

void dataSwap(int* a, int* b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

// 冒泡排序，将最大的放大最后
// 时间复杂度: O(n^2)
// 空间复杂度: O(1)
// 稳定排序
void Bubble_Sort(int* arr, int len)
{
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = 0 ; j < len - 1 - i; j++)
        {
            if (arr[j] > arr[j+1])
            dataSwap(&arr[j], &arr[j+1]);
        }
    }
}

// 插入排序
// 时间复杂度与逆序对相关，最优时间复杂度为O(n)，最差时间复杂度为O(n^2) (1+2+...+n-1=n(n-1)/2)
// 空间复杂度：O(1)
// 稳定排序
void Insert_Sort(int* arr, int len)
{
    int i,j;
    for (i = 1; i < len; i++)
    {
        int key = arr[i];
        for (j = i - 1; j >= 0; j--)
        {
            if (arr[j] > key)
                arr[j+1] = arr[j];
            else
                break;
        }
        arr[j+1] = key;  // 这儿犯过错，把j+1写为j++，造成数组中的元素被其他元素覆盖
    }
}

// 选择排序，选出最小的放在最前面
// 时间复杂度：O(n^2)
// 空间复杂度：O(1)
// 不稳定的排序算法：例如 5,5,3，会将第一个5放在第二个5的后面
void Selection_Sort(int* arr, int len)
{
    int i,j;
    for (i = 0; i < len-1; i++)   // 注意只到倒数第二个
    {
        int index = i;
        int min_val = arr[i];
        for (j = i+1; j < len; j++)
        {
            if (arr[j] < min_val)
            {
                index = j;
                min_val = arr[j];
            }

        }
        if (i != index)
            dataSwap(&arr[i], &arr[index]);
    }
}

// 归并排序
// 时间复杂度：O(nlogn)
// 综上所述：快速排序最差的情况下时间复杂度为：O( n^2 )
// 空间复杂度：O(n) 递归调用返回值使用栈
// 稳定排序
void Merge_Sort(int* arr, int low, int high, int* temp)
{
    if (low < high)
    {
        int mid = (low+high)/2;
        Merge_Sort(arr, low, mid, temp);
        Merge_Sort(arr, mid+1, high, temp);
        MergeS(arr, low, mid, high, temp);
    }
}
void MergeS(int* arr, int low, int mid, int high, int* temp)
{
    int i = low;
    int j = mid+1;
    int k = 0;
    while(i <= mid && j <= high)
    {
        if (arr[i] <= arr[j])
            temp[k++] = arr[i++];
        else
            temp[k++] = arr[j++];
    }
    while (i <= mid)
        temp[k++] = arr[i++];
    while (j <= high)
        temp[k++] = arr[j++];
    for (i = 0 ; i < k; i++)
        arr[low+i] = temp[i];
}

// 快速排序
// 平均时间复杂度：O(nlogn)
// 最差的情况：所有元素有序时，每一次取到的元素就是数组中最小/最大的，这种情况其实就是冒泡排序了(每一次都排好一个元素的顺序)
// 这种情况时间复杂度就好计算了，就是冒泡排序的时间复杂度：T[n] = n * (n-1) = n^2 + n;
// 综上所述：快速排序最差的情况下时间复杂度为：O( n^2 )
// 最优空间复杂度：O(logn) 递归调用返回值使用栈
// 最差空间复杂度：O(n)
// 不稳定排序
int Partition(int* arr, int iBegin, int iEnd)
{
    int key = arr[iBegin];
    while (iBegin < iEnd)
    {
        while (iBegin < iEnd && arr[iEnd] >= key)  // 从尾部找比第一个数小的数
            iEnd--;
        if (iBegin != iEnd)
        {
            arr[iBegin] = arr[iEnd];
            iBegin++;
            while (iBegin < iEnd && arr[iBegin] <= key) // 从第一个数后面开始找比第一个数大的数
                iBegin++;
            if (iBegin != iEnd)
            {
                arr[iEnd] = arr[iBegin];
                iEnd--;
            }
        }
    }
    arr[iEnd] = key;
    return iEnd;
}
void QuickSort(int* arr, int iBegin, int iEnd)
{
    if (iBegin < iEnd)
    {
        int pos = Partition(arr, iBegin, iEnd);
        QuickSort(arr, iBegin, pos-1);
        QuickSort(arr, pos+1, iEnd);
    }
}

// 堆排序

小数据量时使用插入排序性能最好，大数据量时使用快速排序（可设置阈值，在划分为某一个小数据量时，使用插入排序，可大大提升性能）。