考研复习之c++各种排序算法代码汇总

最近刚刚复习完数据结构，准备把上面的各种算法用c++写一遍加深自己的印象，首先就从比较简单的排序算法开始吧！

//
// Created by owenjiang on 2022/3/22.
//
#include<iostream>
using namespace std ;
class SortUtils{
private:

    /**
     * 交换元素
     * @param num1 待交换元素1
     * @param num2 待交换元素2
     */
    static void swapValue(int &num1,int &num2){
        int temp = num1 ;
        num1 = num2 ;
        num2 = temp ;
    }
    /**
     * 快速排序
     * @param array 待排序数组
     * @param low 低位指针
     * @param high 高位指针
     * @param reverse 是否逆序，默认为false
     * @return 返回该元素最终的确定位置
     */
    static int partition(int array[],int low,int high,bool reverse=false){
        if (!reverse){
            int pivot = array[low] ;
            while(low<high){
                while(low<high&&array[high]>pivot) high-- ;
                array[low] = array[high] ;
                while(low<high&&array[low]<=pivot)  low++ ;
                array[high] = array[low] ;
            }
            array[low] = pivot ;
        }
        else{
            int pivot = array[low] ;
            while(low<high){
                while(low<high&&array[high]<pivot) high-- ;
                array[low] = array[high] ;
                while(low<high&&array[low]>=pivot)  low++ ;
                array[high] = array[low] ;
            }
            array[low] = pivot ;
        }
        return low ;
    }
    static void quickSortMain(int array[],int low,int height,int reverse=false){
        if (low<height){
            int mid = partition(array,low,height,reverse) ;
            quickSortMain(array,low,mid-1,reverse) ;
            quickSortMain(array,mid+1,height,reverse) ;
        }
    }
    /**
     * 冒泡排序
     * @param array 待排序数组
     * @param length 数组长度
     * @param reverse 是否逆序，默认为false
     */
    static void bubbleSortMain(int array[],int length,int reverse=false){
        if (!reverse){
            for (int i=length-1;i>=0;i--){
                bool flag = false ;
                for (int j=1;j<=i;j++){
                    if (array[j]<array[j-1]){
                        swapValue(array[j],array[j-1]) ;
                        flag = true ;
                    }
                }
                if (!flag){
                    break ;
                }
            }
        }else{
            for (int i=length-1;i>=0;i--){
                bool flag = false ;
                for (int j=1;j<=i;j++){
                    if (array[j]>array[j-1]){
                        swapValue(array[j],array[j-1]) ;
                        flag = true ;
                    }
                }
                if (!flag){
                    break ;
                }
            }
        }
    }
    /**
     * 插入排序
     * @param array 待排序数组
     * @param length 数组长度
     * @param reverse 是否逆序
     */
    static void insertSortMain(int array[],int length,int reverse=false){
        if (!reverse){
            int len = 1;
            for (int i=1;i<length;i++){
                int value = array[i] ;
                int j ;
                for (j=i;j>=1;j--){
                    if (array[j-1]>value){
                        array[j] = array[j-1] ;
                    }else{
                        break ;
                    }
                }
                array[j] = value ;
            }
        }
        else{
            int len = 1;
            for (int i=1;i<length;i++){
                int value = array[i] ;
                int j ;
                for (j=i;j>=1;j--){
                    if (array[j-1]<value){
                        array[j] = array[j-1] ;
                    }else{
                        break ;
                    }
                }
                array[j] = value ;
            }
        }
    }
    /**
     * 简单选择排序
     * @param array 待排序数组
     * @param length 数组长度
     * @param reverse 是否倒序
     */
    static void selectSortMain(int array[],int length,int reverse=false){
        int len = 1 ;
        if (!reverse){
            while(len!=length){
                int min = array[len-1] ;
                int minIndex = len - 1 ;
                for (int i=len-1;i<length;i++){
                    if (array[i]<min){
                        min = array[i] ;
                        minIndex = i ;
                    }
                }
                swapValue(array[len-1],array[minIndex]) ;
                len ++ ;
            }
        }
        else{
            while(len!=length){
                int max = array[len-1] ;
                int maxIndex = len - 1 ;
                for (int i=len-1;i<length;i++){
                    if (array[i]>max){
                        max = array[i] ;
                        maxIndex = i ;
                    }
                }
                swapValue(array[len-1],array[maxIndex]) ;
                len ++ ;
            }
        }
    }
    /**
     * 希尔排序
     * @param array 待排序数组
     * @param length 数组长度
     * @param reverse 是否逆序
     */
    static void shellSortMain(int array[],int length,int reverse=false){
        int increment = length ;
        if (!reverse){
            increment /= 2 ;
            while(increment){
                for (int i=0;i<length;i++){
                    int value = array[i] ;
                    int j ;
                    for (j=i-increment;j>=0;j-=increment){
                        if (value<array[j]){
                            array[j+increment] = array[j] ;
                        }
                        else{
                            break ;
                        }
                    }
                    array[j+increment] = value ;
                }
                increment /= 2 ;
            }
        }
        else{
            increment /= 2 ;
            while(increment){
                for (int i=0;i<length;i++){
                    int value = array[i] ;
                    int j ;
                    for (j=i-increment;j>=0;j-=increment){
                        if (value>array[j]){
                            array[j+increment] = array[j] ;
                        }else{
                            break ;
                        }
                    }
                    array[j+increment] = value ;
                }
                increment /= 2 ;
            }
        }
    }
    
    /**
     * 2-路归并排序-合并函数
     * @param array 待排序数组
     * @param low 合并区间1起始点
     * @param mid 合并区间1终点，mid合并区间2起点
     * @param high 合并区间2终点
     * @param reverse 是否逆序
     */
    static void merge(int array[],int low,int mid,int high,int reverse=false){
        for (int i=low;i<=high;i++){
            mergeArray[i] = array[i] ;
        }
        int i = low, j = mid + 1 ;
        int len = low ;
        if (!reverse){
            while(i<=mid&&j<=high){
                if (mergeArray[i]>mergeArray[j]){
                    array[len++] = mergeArray[j] ;
                    j ++ ;
                }else{
                    array[len++] = mergeArray[i] ;
                    i ++ ;
                }
            }
        }
        else{
            while(i<mid&&j<=high){
                if (mergeArray[i]<mergeArray[j]){
                    array[len++] = mergeArray[j] ;
                    j ++ ;
                }else{
                    array[len++] = mergeArray[i] ;
                    i ++ ;
                }
            }
        }
        while(i<=mid) array[len++] = mergeArray[i++] ;
        while(j<=high) array[len++] = mergeArray[j++] ;
    }
    static void mergeSortMain(int array[],int low,int high,int reverse=false){
        if (low>=high)
            return ;
        int mid = (low+high)/2 ;
        mergeSortMain(array,low,mid,reverse) ;
        mergeSortMain(array,mid+1,high,reverse) ;
        merge(array,low,mid,high,reverse) ;
    }
    /**
     * 归并排序需要用到的辅助数组空间
     */
    static int *mergeArray ;

    /**
     * 堆排序
     * @param array 待建堆
     * @param length 数组长度
     * @param parent 需要建堆的根结点
     * @param reverse 是否逆序
     */
    static void buildHeap(int array[],int length,int parent,int reverse=false){
        if (!reverse){
            for (int i=2*parent;i<=length;i*=2){
                if (i<length&&array[i-1]<array[i]){
                    i ++ ;
                }
                if (array[parent-1]<array[i-1]){
                    swapValue(array[i-1],array[parent-1]) ;
                    parent = i ;
                }else{
                    break ;
                }
            }
        }
        else{
            for (int i=2*parent;i<=length;i*=2){
                if (i<length&&array[i-1]>array[i]){
                    i ++ ;
                }
                if (array[parent-1]>array[i-1]){
                    swapValue(array[i-1],array[parent-1]) ;
                    parent = i ;
                }else{
                    break ;
                }
            }
        }
    }
    static void heapSortMain(int array[],int length,int reverse=false){
        // 初建堆
        for (int n=length/2;n>=1;n--){
            buildHeap(array,length,n,reverse) ;
        }
        int number = length ;
        while(number!=1){
            swap(array[0],array[number-1]) ;
            buildHeap(array,number-1,1,reverse) ;
            number -- ;
        }
    }
    /**
     * 折半插入排序
     * @param array 待排序数组
     * @param length 数组长度
     * @param reverse 是否逆序
     */
    static void halfInsertSortMain(int array[],int length,int reverse=false){
        for (int i=1;i<length;i++){
            int value = array[i] ;
            int low = 0 ,high = i - 1 ;
            while(low<=high){
                int mid = (low + high) / 2 ;
                if (!reverse){
                    if (array[mid]>value){
                        high = mid - 1 ;
                    }else{
                        low = mid + 1 ;
                    }
                }
                else{
                    if (array[mid]<value){
                        high = mid - 1 ;
                    }else{
                        low = mid + 1 ;
                    }
                }
            }
            for (int j=i-1;j>=low;j--){
                array[j+1] = array[j] ;
            }
            array[low] = value ;
        }
    }
public:
    static void halfInsertSort(int array[],int length,int reverse=false){
        halfInsertSortMain(array,length,reverse) ;
    }
    static void heapSort(int array[],int length,int reverse=false){
        heapSortMain(array,length,reverse) ;
    }
    static void mergeSort(int array[],int length,int reverse=false){
        mergeArray = new int[length] ;
        mergeSortMain(array,0,length-1,reverse) ;
        delete[] mergeArray ;
    }
    static void shellSort(int array[],int length,int reverse=false){
        shellSortMain(array,length,reverse) ;
    }
    static void insertSort(int array[],int length,int reverse=false){
        insertSortMain(array,length,reverse) ;
    }
    static void bubbleSort(int array[],int length,int reverse=false){
        bubbleSortMain(array,length,reverse) ;
    }
    static void quickSort(int array[],int length,int reverse=false){
        quickSortMain(array,0,length-1,reverse) ;
    }
    static void selectSort(int array[],int length,int reverse=false){
        selectSortMain(array,length,reverse) ;
    }
    static void display(int array[],int length){
        for (int i=0;i<length;i++){
            cout << array[i] << " " ;
        }
        cout << endl ;
    }
};
int *SortUtils::mergeArray = nullptr ;
void coutString(string content){
    cout << content << endl ;
}
int main(){
    int array[] = {551,1,4,32,11,31,5,1,32,631,12,55,132} ;
    coutString("排序前") ;
    SortUtils::display(array,13) ;
    SortUtils::bubbleSort(array,13) ;
    coutString("升序排序后") ;
    SortUtils::display(array,13) ;
    coutString("降序排序后") ;
    SortUtils::bubbleSort(array,13, true) ;
    SortUtils::display(array,13) ;
    return 0 ;
}

上述代码可以供给考研复习使用，也可以直接拿走充当一个排序工具类。欢迎大家指教，之后将会贴上数据结构中的其他算法。