二、排序（时间复杂度 O（nlogn））

一、归并排序

class MergeSort {
public:
   int* mergeSort(int* A, int n) {
        // write code here
        //对于一个int数组，请编写一个归并排序算法，对数组元素排序。
	//给定一个int数组A及数组的大小n，请返回排序后的数组。
        //采用递归的过程进行归并排序，并且使用一个与A大小相同的辅助数组空间
        //1. 递归调用归并排序过程将数组折半划分，直到划分成1
        //2. 对相邻已排序元素回溯递归过程
        int *B = (int*)malloc(sizeof(int) * n);
        
        
        QuickSort(A, B, 0, n-1);
        
        free(B);
        
        return A;
       
    }
   
     void merger(int *A, int *B, int start, int mid, int end){
    	int i = start;
        int j = mid+1;
        int k = start;
        
        while(i <=mid && j <=end){
            if(A[i] < A[j]){
                B[k++] = A[i++];
            }
            else{
                B[k++] = A[j++];
            }
        }
        
        while(i != mid+1){
            B[k++] = A[i++];
        }
        
        while(j != end+1){
            B[k++] = A[j++];
        }
        
        
        k=start;
        while(k <= end){
        	A[k++] = B[k];
            //k++;  = 为从右到左的运算  不能写成 A[k] = B[k++];
        }
    }

	  void QuickSort(int *A, int *B, int start, int end){
        if(start >= end)
            return;
        
        int mid = (start + end) /2;
        
        QuickSort(A, B, start, mid);
        QuickSort(A, B, mid+1, end);
        
        merger(A, B, start, mid, end);
 
    }
  
      
};

二、快速排序

class QuickSort {
public:
    int* quickSort(int* A, int n) {
        // write code here
        //对于一个int数组，请编写一个快速排序算法，对数组元素排序。
	//给定一个int数组A及数组的大小n，请返回排序后的数组。
        //1.选取一个轴值，将整个数组小于等于轴值得元素放到轴值得左边，其余的放到轴值得右边
        //2. 递归的调用步骤1，直到所有元素都有序
        quickProcess(A,0,n-1);
        
        return A;
    }
    
    void quickProcess(int *A, int start, int end){
        if(start >= end)  //== 为什么不可以
            return;
        
        int value = A[start];
       	int i= start;
        int j = end;
        
        while(i<j){
        	while(i<j && value<=A[j]){
        		j --;
        	}
        	if(i<j){
        		A[i++] = A[j];
        	}
        
        	while(i<j && value>A[i]){
            	i++;
        	}
        	if( i<j){
            	A[j--] = A[i];
        	}
        }
        
        A[i] = value;
    	quickProcess(A, start, i-1);
        quickProcess(A, i+1, end);
        
    }
};

三、堆排序

class HeapSort {
public:
    int* heapSort(int* A, int n) {
        // write code here
        //对于一个int数组，请编写一个堆排序算法，对数组元素排序。
	//给定一个int数组A及数组的大小n，请返回排序后的数组。
        //1. 将数组调整成大顶堆
        //2. 将大顶堆的对顶元素与最后位置的元素对调，每次有一个元素到最终位置
        //3. 将未排序的元素重复步骤1、2,共重复步骤1、 2 的次数为n-1次
        heapProcess(A, n-1);
        
        return A;
    }
    
    void heapProcess(int *A, int n){
        if(n <= 0)
            return;
        heapAdjust(A, n);
        
        int a;
        a = A[n];
        A[n] = A[0];
        A[0] = a;
        
        heapProcess(A, n-1);
    }
    
    //大顶堆调整，从第n/2+1至第一个元素依次调整
    void  heapAdjust(int* A, int n){
        int i = n/2;
        int a;
        
        while(i>=0){
            if(2*i <= n && A[i] < A[2*i]){
        		a = A[i];
                A[i] = A[2*i];
                A[2*i] = a;
            }
            
            if(2*i+1 <= n && A[i] < A[2*i+1]){
            	a = A[i];
                A[i] = A[2*i+1];
                A[2*i+1] = a; 
            }
            
            i--;
        }
    }
};

四、希尔排序

class ShellSort {
public:
    int* shellSort(int* A, int n) {
        // write code here
        //对于一个int数组，请编写一个希尔排序算法，对数组元素排序。
	//给定一个int数组A及数组的大小n，请返回排序后的数组。保证元素小于等于2000。
        //1. 步长的选择 步长有几个 循环进行几次调整
        //1.1 步长大于等于1
        //1.2 步长小于数组长度且小于20的素数
        //2.当步长为i时, 从第i个元素开始开始与前面坐标比其小i的元素比较，该元素小则对调，直到第n-1个元素
        
        for(int i=n/2; i>=1; i=i/2){
            for(int j=i; j<n; j++){
                int tmp = A[j];
                int k=j-i;
                for(; k>=0 && tmp<A[k]; k=k-i){	//插入排序，查找tmp的合适位置
                    A[k+i] = A[k];
                }
                A[k+i] = tmp;
            }
        }
        return A;
    }
};