排序算法-比较排序

代码如下：

#include <iostream>
using namespace std;

const int N = 10;

void ShowArray(int n, int *arr){
    for(int i=0; i<n; i++){
        cout << arr[i] << " ";
    }
    cout << endl;
}

void SwapInt(int &x, int &y){
    int temp = x;
    x = y;
    y = temp;
}

//冒泡排序
void BubbleSort(int n, int *arr){
    for (int i=0; i<n; i++){
        for (int j=1; j<n; j++){
            //从大到小，相邻的两个数，如果前面的值小于后面，两个数互换位置
            if(arr[j-1] < arr[j]){
                SwapInt(arr[j-1], arr[j]);
            }
        }
    }
}

//冒泡排序优化版
void BubbleSortOptimize(int n, int *arr){
    for (int i=0; i<n; i++){
        for (int j=i+1; j<n; j++){
            //从小到大，比较指定位置的数和后面所有的数，如果前面的值大于后面，两个数互换位置
            if(arr[i] > arr[j]){
                SwapInt(arr[i], arr[j]);
            }
        }
    }
}

//选择排序
void SelectSort(int n, int *arr){
    for (int i=0; i<n; i++){
        int position = i;
        int maxInt = arr[i];
        for (int j=i+1; j<n; j++){
            //从大到小，找出剩余数中最大值的位置，与arr[i]交换位置
            if (maxInt < arr[j]){
                maxInt = arr[j];
                position = j;
            }
        }
        if(i < position){
            SwapInt(arr[i], arr[position]);
        }
    }
}

//插入排序
void InsertSort(int n, int *arr){
    for (int i=1; i<n; i++){
        for (int j=i; j>0 && arr[j] < arr[j-1]; j--){ //需要判断数组是否越界
            SwapInt(arr[j], arr[j-1]);
        }
    }
}

//插入排序优化版，让需要排序的数组从1位置开始，0位置做哨兵
void InsertSortOptimize(int n, int *arr){
    int a[n+1]={0};
    for (int i=0; i<n; i++){
        a[i+1] = arr[i];
    }

    for (int i=2; i<n+1; i++){
        a[0] = a[i]; //哨兵
        for (int j=i; a[j] > a[j-1]; j--){//可以不用判断数组是否越界，不会有数大于或小于他自己
            SwapInt(a[j], a[j-1]);
        }
    }

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

//希尔排序,高级插入排序,当输入串相对有序时，可以减少插入排序的移位操作
void ShellSort(int n, int *arr){
    int rate=2;
    for (int step=n/rate; step>0; step/=rate){
        for (int i=0; i<step; i++){
            for(int j=i+step; j<n; j+=step){
                for (int k=j; k>i && arr[k] > arr[k-step]; k-=step){
                    SwapInt(arr[k],arr[k-step]);
                }
            }
        }
    }
}

//归并排序，递归深度一定log2n,算法复杂度稳定为O(nlog2n)
int ms[N] ={-1};
void MergeSort(int s, int n, int *arr){
    if (1 == (n-s)){
        return;
    }
    int i=s,j=(n+s)/2;
    MergeSort(s, j, arr);
    MergeSort(j, n, arr);
    for(int k=s; k<n; k++){
        if (j < n && arr[i] > arr[j]){
            ms[k] = arr[j++];
        }else{
            ms[k] = arr[i++];
        }
    }

    for(int k=s; k<n; k++){
        arr[k]=ms[k];
    }
}

//快速排序，递归深度会出现随机变换，算法复杂度最差为O(n2)，单考虑到输入串比较随机，平均复杂度和归并排序一样
void QuickSort(int s, int n, int *arr){
    if(1 >= n-s){
        return;
    }

    int temp = arr[s];
    int position = s;
    int i=s, j=n-1;
    while (i != j){
        while(arr[j] < temp && j > i){
            j--;
        }
        arr[position] = arr[j];
        position = j;

        while(arr[i] >= temp && i < j){
            i++;
        }
        arr[position] = arr[i];
        position = i;
    }
    arr[position] = temp;

    QuickSort(s, position+1, arr);
    QuickSort(position+1, n, arr);
}

//堆排序:递归实现
void maintain(int parent, int n,int *hs){
    int maxPosition = parent*2;
    if (maxPosition > n){return ;}
    if(maxPosition < n && hs[maxPosition] > hs[maxPosition+1]){
        maxPosition++;
    }
    if(hs[parent] > hs[maxPosition]){
        SwapInt(hs[parent], hs[maxPosition]);
        maintain(maxPosition, n, hs);
    }
}

void HeapSort(int n, int *arr){
    int hs[n+1] = {0};
    for (int i=0; i<n; i++) {
        hs[i+1] = arr[i];
    }
    //建堆
    for (int parent=n/2; parent>0; parent--){
        maintain(parent, n, hs);
    }
    //排序
    for (int i=0; i<n; i++){
        arr[i] = hs[1];
        //hs[1] = hs[n-i];
        SwapInt(hs[1],hs[n-i] ); //可以用一个数组实现
        maintain(1, n-i-1, hs);
    }
}



int main()
{
    int arr[N] = {5,3,1,7,9,2,4,0,8,6};
    BubbleSort(N, arr);
    ShowArray(N, arr);
    BubbleSortOptimize(N, arr);
    ShowArray(N, arr);
    SelectSort(N, arr);
    ShowArray(N, arr);
    InsertSort(N, arr);
    ShowArray(N, arr);
    InsertSortOptimize(N, arr);
    ShowArray(N, arr);
    MergeSort(0, N, arr);
    ShowArray(N, arr);
    QuickSort(0,N,arr);
    ShowArray(N, arr);
    HeapSort(N,arr);
    ShowArray(N, arr);
    ShellSort(N, arr);
    ShowArray(N, arr);
    return 0;
}

如题！