时间复杂度为O(N*logN)的排序算法——归并排序、快速排序、堆排序

1、归并排序

void mergeSort(vector<int>& nums,int start,int end){
        if(start<end){
             int q = (start+end)/2;
             mergeSort(nums,start,q);
             mergeSort(nums,q+1,end);
             merge(nums,start,q,end);
        }
    }
void merge(vector<int>& nums,int start,int q,int end){
        vector<int> L1(q-start+1,0);
        vector<int> L2(end-q,0);
        L1.assign(nums.begin()+start,nums.begin()+q+1);
        L2.assign(nums.begin()+q+1,nums.begin()+end+1);
        int i=0,j=0;
        for(int k = start;k<=end;k++){
            if(L1[i] <= L2[j]){
                nums[k] = L1[i];
                i++;
            }else{
                nums[k] = L2[j];
                j++;
            }
            if(i>L1.size()-1){
                for(int s = k+1;s<=end;s++){
                    nums[s] = L2[j];
                    j++;
                }
                break;
            }
            if(j>L2.size()-1){
                for(int s = k+1;s<=end;s++){
                    nums[s] = L1[i];
                    i++;
                }
                break;
            }
        }
    }

使用分治法，先将元素拆分成最小的形式，然后两两合并。每次合并是将两个已经排好序的子数组进行合并。

但在进行数组合并时，需要将其拷贝到新申请的数组中，拷贝过程花费时间和额外的内存开销。

2、快速排序

 void quickSort(vector<int>& nums,int start,int end){
         int pivot;
         if(start<end){
             pivot = randPartition(nums,start,end);
             quickSort(nums,start,pivot-1);
             quickSort(nums,pivot+1,end);
         }
     }
  int randPartition(vector<int>& nums,int start ,int end){
         int randi = start;
         std::swap(nums[randi],nums[start]);
         int pivot = nums[start];
         int i = start;
         for(int j = start+1;j<=end;j++){
                if(nums[j]<pivot){
                    i++;
                    swap(nums[i],nums[j]);
                }
            }
            swap(nums[start],nums[i]);
            return i;
        }

随机快速排序不需要额外申请内存空间，随机选取pivot对数组进行划分，使左边元素小于pivot,右边元素大于pivot。然后分别对左右子数组调用快速排序算法重新划分。最坏情况下可能出现O（N*N）的情况，但出现可能性很小。

3、堆排序