算法 - 7大比较类排序算法程序设计

典型的7大排序算法

典型的7大排序算法包括：

（1）冒泡排序

（2）选择排序

（3）插入排序

（4）希尔排序

（5）归并排序

（6）快速排序

（7）堆排序

7中排序算法中：快速排序、希尔排序、选择排序、堆排序是稳定的排序算法。

7大排序算法程序如下：

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        if(nums.size()<=1){
            return nums;
        }
        vector<int> res = nums;
        
        // BubbleSort(res);

        // SelectSort(res);

        // InsertSort(res);

        // ShellSort(res);

        // vector<int> tmp(res.size(), 0);
        // MergeSort(res, 0, res.size() - 1,tmp);

        // QuickSort(res,0,(int)nums.size()-1);
        
        HeapSort(res);
        return res;
    }
    //-------------冒泡排序：可能会超时-----------------//
    void BubbleSort(vector<int>& arry){
        int length = arry.size();
        for(int i=0;i<length;i++){
            for(int j=length-1;j>i;j--){
                if(arry[j-1]>arry[j]){
                    //交换
                    int temp = arry[j-1];
                    arry[j-1] = arry[j];
                    arry[j] = temp;
                }
            }
        }
    }

    //--------------------选择排序---------------------//
    void SelectSort(vector<int>& arry){
        int length = arry.size();
        for(int i=0;i<length;i++){
            int min = i;
            for(int j=i+1;j<length;j++){
                if(arry[j]<arry[min]){
                    min = j;
                }
            }
            if(min!=i){
                //交换
                int temp = arry[min];
                arry[min] = arry[i];
                arry[i] = temp;
            }
        }
    }

    //----------------------插入排序：----------------------//
    void InsertSort(vector<int>& arry){
        int length = arry.size();
        int j;
        for(int i=1;i<length;i++){
            if(arry[i]<arry[i-1]){
                int temp = arry[i];
                for(j = i-1;j>=0 && arry[j]>temp;j--){
                    arry[j+1] = arry[j];
                }
                arry[j+1] = temp;
            }
        }
    }

    //-----------------------希尔排序---------------------//
    void ShellSort(vector<int>& arry){
        int length = arry.size();
        int i,j,k;
        int increasment = length;
        do{
            //确定增量大小，利用增量将原数组分为了几组
            increasment = increasment/3+1;
            for(i=0;i<increasment;i++){
                //每组的排序思路与插入排序是一致的
                for(j=i+increasment;j<length;j+=increasment){
                    if(arry[j]<arry[j-increasment]){
                        int temp = arry[j];
                        for(k=j-increasment;k>=0&&arry[k]>temp;k-=increasment){
                            arry[k+increasment] = arry[k];
                        }
                        arry[k+increasment] = temp;
                    }
                }
            }
        }while(increasment>1);
    }

    //-------------------------------归并排序------------------------------//
    void MergeSort(vector<int>& arry,int start,int end,vector<int>& temp){
        if(start>=end)
            return;
        int mid = (start+end)/2;
        MergeSort(arry,start,mid,temp);
        MergeSort(arry,mid+1,end,temp);
        int i = start;
        int j = mid+1;
        int cnt = 0;
        while(i<=mid && j<=end){
            temp[cnt++] = arry[i]<=arry[j]?arry[i++]:arry[j++];
        }
        while(i<=mid){
            temp[cnt++] = arry[i++];
        }
        while(j<=end){
            temp[cnt++] = arry[j++];
        }
        for(i=0;i<end-start+1;i++){
            arry[start+i] = temp[i];
        }
    }

    //--------------------------------快速排序----------------------------//
    void QuickSort(vector<int>& arry,int start,int end)
    {
        if (start >= end) return;
        int i = start;
        int j = end;
        int temp = arry[start];//基准数，所有数都和他比较
        while (i<j)
        {
            //挖坑：从右向左找比基准数小的元素
            while (i < j && arry[j] >= temp)
            {
                j--;
            }
            //填坑
            if (i<j)
            {
                arry[i] = arry[j];
                i++;
            }
            //挖坑：从左向右找比基准数大的元素
            while (i < j&&arry[i] < temp)
            {
                i++;
            }
            //填坑
            if (i < j)
            {
                arry[j] = arry[i];
                j--;
            }
        }
        //此时i==j，基准数放在这个位置，左边都比基准数小，右边都比基准数大
        arry[i] = temp;
        //递归：
        //对左半部分快排
        QuickSort(arry, start, i - 1);
        //对右半部分快排
        QuickSort(arry, j+1, end);
    }

    //-------------------------------堆排序-------------------------------//
    void HeapSort(vector<int>& arry){
        int length = arry.size();
        //大顶堆初始化
        for(int i=length/2-1;i>=0;i--){
            heapAdjust(arry,i,length);
        }
        //交换堆顶与最后一个元素
        for(int i = length-1;i>=0;i--){
            swap(arry[i], arry[0]);
            heapAdjust(arry,0,i);
        }
    }
    void heapAdjust(vector<int>& arry,int index,int length){
        //当前结点下标：
        int max = index;
        //左右孩子：
        int lchild = 2*index+1;
        int rchild = 2*index+2;
        //找出父、左、右最大值
        if(lchild<length && arry[lchild]>arry[max]){
            max = lchild;
        }
        if(rchild<length && arry[rchild]>arry[max]){
            max = rchild;
        }
        if(max!=index){
            swap(arry[index], arry[max]);
            heapAdjust(arry,max,length);
        }
    }
};