排序算法C++

1.插入排序：

vector<int> sortArray(vector<int>& nums) {    
        if(nums.size()==1)return nums;
        int len=nums.size();
        for(int i=1;i<len;++i){
            int temp=nums[i];
            int compare=i-1;
            while(compare>=0&&temp<nums[compare]){
                nums[compare+1]=nums[compare];
                compare--;
            }
            nums[compare+1]=temp;
        }
        return nums;
    }

2. 冒泡排序

vector<int> sortArray(vector<int>& nums) {  
        if(nums.size()==1)return nums;
        int len=nums.size();
        for(int i=0;i<len-1;++i){
            for(int j=len-1;j>i;--j){
                if(nums[j-1]>nums[j]){
                    int temp=nums[j-1];
                    nums[j-1]=nums[j];
                    nums[j]=temp;
                }
            }
        }
        return nums;
    }

3. 归并排序

 vector<int> sortArray(vector<int>& nums) {//归并排序
        mergesort(nums,0,nums.size()-1);
       return nums;
    }
   void mergesort(vector<int>&nums,int l,int r){
       if(l<r){
            int m=l+(r-l)/2;
            mergesort(nums,l,m);
            mergesort(nums,m+1,r);
            merge(nums,l,m,m+1,r);
       }
   }
    void merge(vector<int>&nums, int L1,int R1,int L2,int R2){
        int temp[R2-L1+1];
        int i=L1;
        int j=L2;
        int k=0;
        while(i<=R1&&j<=R2){
            if(nums[i]<nums[j])
                temp[k++]=nums[i++];
            else 
                temp[k++]=nums[j++];
        }
        while(i<=R1) temp[k++]=nums[i++];
        while(j<=R2) temp[k++]=nums[j++];
        for(int i=0;i<k;i++)
            nums[L1+i]=temp[i];
    }

4. 快速排序

int partition(vector<int>&nums,int low,int high){
        int temp=nums[high];
        while(low<high){
            
            while(low<high&&nums[low]<=temp)low++;
            nums[high]=nums[low];
            while(low<high&&nums[high]>=temp)high--;
            nums[low]=nums[high];
        }
        nums[high]=temp;
        return high;
    }
    void quicksort(vector<int>&nums,int low,int high){
        if(low<high){
            int pos=partition(nums,low,high);
            quicksort(nums,low,pos-1);
            quicksort(nums,pos+1,high);
        }
    }
   vector<int> sortArray(vector<int>& nums) {
         quicksort(nums,0,nums.size()-1);
       return nums;
    }

5. 希尔排序

void shellsort(vector<int>& nums,int n){
        for(int dk=n/2;dk>0;dk/=2){
            for(int i=dk;i<n;++i){
                 for (int j = i; j - dk >= 0 && nums[j - dk] > nums[j]; j -= dk) {
                    swap(nums[j - dk], nums[j]);
                     }
                    
                }
            }
        }
    
    vector<int> sortArray(vector<int>& nums) {
         shellsort( nums,nums.size());
        return nums;
    }

6. 桶排序

vector<int> bucketsort(vector<int>& nums) {
         if (nums.size()==0)return {};
        int low=*min_element(nums.begin(),nums.end());
        int high=*max_element(nums.begin(),nums.end());
        int len=high-low+1;
        vector<int>bucket(len);
        for(auto temp:nums)bucket[temp-low]++;
        vector<int>res;
        for(int i=0;i<len;++i){
            for(int j=0;j<bucket[i];j++){
                res.push_back(i+low);
            }
        }
        return res;
    }

7. 堆排序

 void adjust(vector<int>&nums,int len,int index){//维护稳定堆
        int left=2*index+1;
        int right=2*index+2;
        int max=index;
        if(left<len&&nums[left]>nums[max])max=left;
        if(right<len&&nums[right]>nums[max])max=right;
        if(max!=index){
            swap(nums[max],nums[index]);
            adjust(nums,len,max);
        }
    }
void HeapSort(vector<int> &nums, int size){//顶端和末端值交换
	  for(int i=size/2 - 1; i >= 0; i--){
	       adjust(nums, size, i);
	   }
	    for(int i = size - 1; i >= 1; i--){
	           swap(nums[0], nums[i]);        
	           adjust(nums, i, 0);              
	       }
	   }
vector<int> sortArray(vector<int>& nums) {
      HeapSort(nums, nums.size());
      return nums;
  		}