常见的排序算法

#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);    }}// 堆排序