排序算法（复杂度nlogn）

1:希尔排序

class Solution {
public:
    vector<int> sortArray(vector<int>& a) {
  
   int increment=a.size();
   int n=a.size();
 
   do
   {
       increment=increment/3+1;//设置一个间隔值
       for(int i=increment;i<n;i++)
       {
           int cur=a[i];
           int index=i-increment;
          while(index>=0&&cur<a[index])
          {
              a[index+increment]=a[index];
              index=index-increment;//进行交换
          }
          a[increment+index]=cur;
       }
   }
   while(increment>1);
   return a;
    }
};

2 堆排序

class Solution{
public:
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        if(n<=1)return nums;
        return heapSort(nums,n);
    }
    vector<int>heapSort(vector<int>& nums,int n)
    {
        for(int i=n/2-1;i>=0;--i)
        siftDown(nums,i,n-1);//将所有序列的元素定义为一个大顶堆
        for(int i=n-1;i>=1;--i)
        {
            swap(nums[0],nums[i]);//将顶堆的元素和最后一个元素交换（也就是将这个元素踢出排序序列）
            --n;
            siftDown(nums,0,n-1);//重新将剩下的调整成大顶堆
        }
        return nums;
    }
    void siftDown(vector<int>& nums,int start,int end)
    {
        int j=2*start+1;
        while(j<=end)
        {
            if(j<end && nums[j]<nums[j+1])++j;
            if(nums[start]>=nums[j])break;
            else
            {
                swap(nums[start],nums[j]);
                start=j;j=2*j+1;
            }
        }
    }
};

3归并排序

class Solution {
    vector<int> tmp;
    void mergeSort(vector<int>& nums, int l, int r) {
        if (l >= r) return;
        int mid = (l + r) >> 1;
        mergeSort(nums, l, mid);
        mergeSort(nums, mid + 1, r);
        int i = l, j = mid + 1;
        int cnt = 0;
        while (i <= mid && j <= r) {
            if (nums[i] <= nums[j]) {
                tmp[cnt++] = nums[i++];
            }
            else {
                tmp[cnt++] = nums[j++];
            }
        }
        while (i <= mid) {
            tmp[cnt++] = nums[i++];
        }
        while (j <= r) {
            tmp[cnt++] = nums[j++];
        }
        for (int i = 0; i < r - l + 1; ++i) {
            nums[i + l] = tmp[i];
        }
    }
public:
    vector<int> sortArray(vector<int>& nums) {
        tmp.resize((int)nums.size(), 0);
        mergeSort(nums, 0, (int)nums.size() - 1);
        return nums;
    }
};

4 快速排序

class Solution {
public:
    void quicksort(vector<int>& nums,int l,int r)
    {
        int i,j,t,tmp;
        if(l>r)
        {
            return ;
        }
        tmp=nums[r];
        i=l;
        j=r;
        while(i!=j)
        {
            while(nums[i]<=tmp && i<j) 
               {i++;} 
  
            while(nums[j]>=tmp && i<j) 
               {j--;}
               if(i<j)
               {
                   swap(nums[i],nums[j]);
               }
        }
        nums[r]=nums[i];
        nums[i]=tmp;
        quicksort(nums,l,i-1);
        quicksort(nums,i+1,r);
    }
    vector<int> sortArray(vector<int>& nums) {
        quicksort(nums,0,nums.size()-1);
        return nums;

    }
};