10大排序算法（不包括希尔排序和计数排序）

排序算法

ps：个人认为都是最好的版本。
其中不包括希尔排序和计数排序。

选择排序

//选择排序
vector<int> sortArray(vector<int>& nums) {
        
        for(int i = 0;i < nums.size()-1;i++){
            int p = i;
            for(int j = i+1;j < nums.size();j++){
                if(nums[j]<nums[p]){
                    p = j;
                }
            }
            int t= nums[i];
            nums[i] = nums[p];
            nums[p] = t;
        }
        return nums;
    }

堆排序

//堆排序
vector<int> sortArray(vector<int>& nums) {
        heapity(nums);
    	//排序
        for(int i = nums.size()-1;i > 0;i--){
            swap(nums[i],nums[0]);//将堆顶元素（最大）与最后一个元素（最小）交换
            headAdjust(nums,0,i);//将堆顶元素（下标为0，此时为最小元素）下沉到最底部
        }
        return nums;
    }
	//构建堆
    void heapity(vector<int>& nums){
        int len = nums.size();
        for(int i = len/2 - 1;i >= 0;i--){
            headAdjust(nums,i,len);
        }
    }
	//将第k个结点下沉到长度为len的堆的最底端
	//len：数组长度，判断结点是否在二叉树上
    void headAdjust(vector<int>& nums,int k,int len){
        int temp = nums[k];
        for(int i = 2 * k + 1;i < len;i = i * 2 + 1){//左2i+1 右2i+2
            if(i+1 < len && nums[i] < nums[i+1])i++;//取左右儿子较大的下标i

            if(nums[0] >= nums[i])break;
            else{                   //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                nums[k] = nums[i];
                k = i;
            }
        }
        nums[k] = temp;//将temp值放到最终的位置
    }

插入排序

//插入排序
vector<int> sortArray(vector<int>& nums) {
        for(int i = 1;i< nums.size();i++){
            int value = nums[i];
            int j = i;
            for(;j > 0 && nums[j-1] > value;j--){
                nums[j] = nums[j-1];
            }
            nums[j] = value;
        }
        return nums;
    }

冒泡排序

//冒泡排序
vector<int> sortArray(vector<int>& nums) {
        for(int i = 0;i < nums.size();i++){
            for(int j = 0;j < nums.size()-i-1;j++){
                if(nums[j]>nums[j+1]){
                    int t = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = t;
                }
            }
        }
        return nums;
    }

快速排序

//快速排序
int a[50000],tmp[50000];
    vector<int> sortArray(vector<int>& nums) {
        //guibing
        quickSort(nums,0,nums.size()-1);
        return nums;
        
    }
    
    void quickSort(vector<int>& nums,int l,int r) { // [)
        if(l > r)return;
        
        int q = rand() % (r - l + 1) + l; // 随机选一个作为我们的主元
        swap(nums[l], nums[q]);
        
        int p = nums[l];
        int i = l,j = r;
        while(i < j){
            while(i < j && nums[j] >= p)j--;  //确保当i==j时，nums[i]为小于哨兵的数
            while(i < j && nums[i] <= p)i++;
            if(i < j){
                int t = nums[i];
                nums[i] = nums[j]; 
                nums[j] = t;
            }
        }
        nums[l] = nums[i];
        nums[i] = p;
        quickSort(nums,l,i-1);
        quickSort(nums,i+1,r);
        return ;
    }

归并排序

//归并排序
int a[50000],tmp[50000];
    vector<int> sortArray(vector<int>& nums) {
        //guibing
        sortG(nums,0,nums.size()-1);
        return nums;
        
    }
    void sortG(vector<int>& nums,int l,int r) { // [)
        if(l >= r)return ;
        int mid = (l + r) / 2;
        sortG(nums,l,mid);
        sortG(nums,mid+1,r);
        int k = 0,i = l,j = mid+1;
        while(i <= mid && j <= r){
            if(nums[i] < nums[j]){
                tmp[k++] = nums[i++];
            }else{
                tmp[k++] = nums[j++];
            }
        }
        while(i < j &&i <= mid)tmp[k++] = nums[i++];
        while(j <= r)tmp[k++] = nums[j++];
        for(int i = l,j = 0;i <= r;i++,j++){
            nums[i] = tmp[j];
        }
        return ;
    }

桶排序

//桶排序
vector<int> sortArray(vector<int>& nums) {
        int maxn = *max_element(nums.begin(),nums.end());
        int minn = *min_element(nums.begin(),nums.end());
        int count = (maxn - minn)/nums.size()+1;
        vector<vector<int>> buk(count);
        for(int i = 0;i < nums.size();i++){
            buk[(nums[i] - minn)/nums.size()].push_back(nums[i]);
        }
        int p = 0;
        for(int i = 0;i < buk.size();i++){
            if(!buk[i].empty()){
                sort(buk[i].begin(),buk[i].end());
                for(int j = 0;j < buk[i].size();){
                    nums[p++] = buk[i][j++];
                }
            }
        }
        return nums;
    }

基数排序

//基数排序
vector<int> sortArray(vector<int>& nums) {
        int maxn = *max_element(nums.begin(),nums.end());
        int minn = *min_element(nums.begin(),nums.end());
        maxn = (maxn > -minn)?maxn:-minn;
        int count = 0;
        while(maxn > 0){
            maxn/=10;
            count++;
        }
        vector<vector<int>> buk(19);
        int mod = 1;
        for(int i = 0;i < count;i++,mod*=10){

            for(int j = 0;j < nums.size();j++){
                buk[nums[j]/mod%10+9].push_back(nums[j]); 
            }
            int p = 0;
            for(int k = 0;k < buk.size();k++){
                for(int l = 0;l < buk[k].size();l++){
                    nums[p++] = buk[k][l];
                }
                buk[k].clear();
            }            
        }
        return nums;
    }

小Tips

#include<functional>
//less greater

sort(myv.begin(), myv.end(), std::less<int>())//递增
sort(myv.begin(), myv.end(), std::greater<int>())//递减
//相反
priority_queue <int,vector<int>,greater<int> > q;//升序队列，小顶堆（递增）
priority_queue <int,vector<int>,less<int> >q;//降序队列，大顶堆