对排序部分的要求：至少知道两种n*log(n)的排序算法，比如快速排序和归并排序，merge sort 很重要，比如K-way merge sorts。

三种平均时间复杂度为Nlog(N) 的排序算法：
归并排序

int* mergeSort(int* A, int n) {
  sort(A,0,n-1);
  return A;
}

void sort(int* A,int begin, int end){
  if(begin < end){
    int middle = (end + begin)/2;
    sort(A, begin, middle);  // 将左半边排序
    sort(A, middle+1, end);  // 将右半边排序
    merge(A,begin, middle, end); // 归并结果
  }    
}

void merge(int * A, int begin, int middle, int end){
  int * tmp = new int[end - begin + 1] ;    
  int i = begin;
  int j = middle + 1;
  int index = 0;
  while(i <= middle && j <= end){  // 归并两个有序数组，将其复制到tmp数组
    if(A[i] < A[j]){
        tmp[index++] = A[i++];
    }
    else{
        tmp[index++] = A[j++];
    }
  }
  while (j <= end) { // 左半边用尽
    tmp[index++] = A[j++];
  }    
  while (i <= middle) {  // 右半边用尽
    tmp[index++] = A[i++];
  }   
  //将结果复制到原数组 
  int temp=0;
  while((temp + begin) <= end){
    A[temp + begin]=tmp[temp];
    temp++;
  }
}

堆排序

int* heapSort(int* A, int n) {     
    for(int i = (n-1)/2; i >= 0; --i){
        heapAdjust(A,i,n-1);  // 构建堆    
    }     
    for(int i = n-1;i > 0;i--){
        swap(A[0],A[i]);  // 交换堆顶到数组末尾
        heapAdjust(A,0,i-1);  // 对剩下的i-1个元素调整，构建堆
    }     
    return A;
 }

void heapAdjust(int * A,int s,int n){
    int temp,j;
    temp = A[s];
   
  for(j = 2*s; j < n;j *= 2){
    if(j < n && A[j] < A[j+1])  // 标记较大的子节点
        ++j;
    if(A[s] >= A[j]) // 如果根结点大于较大的子结点，跳出
        break;         
    swap(A[j],A[s]);
    s = j; // 将根结点指向交换后的子结点，对子树进行调整    
  }   
  A[s] = temp; // 将 A[s] 赋回原值
}

快速排序

int* quickSort(int* A, int n) {
  if(A == NULL || n <= 0)
    return NULL;
  QuickSorted(A,0,n-1);       
  return A;
}
 
void QuickSorted(int* A,int start, int end){
  if(start > end)
    return;
   
  int index = Partition(A,start,end);
  if(index > start)
    QuickSorted(A,start,index - 1); // 左半边快排
  if(index < end)
    QuickSorted(A,index + 1,end);  // 右半边快排
}
 
int Partition(int* A,int start,int end){   
  int small = start - 1;     
  int index = RandomInRange(start,end);  // 随机数
 
  Swap(A[index],A[end]); //将切分值与与数组末尾交换     
  for(int i = start;i < end;++i){
      if(A[i] < A[end]){
          ++small;
          if(small != i)
              Swap(A[small],A[i]);
      }
  }
  ++ small;
  swap(A[end],A[small]); // 交换     
  return small;
}


void swap(int& a,int& b){
  int temp = a;
  a = b;
  b = temp;
}

int RandomInRange(int start, int end){ 
  srand(time(NULL)); 
  return start + rand()%(end-start+1); 
}

希尔排序

int* shellSort(int* A, int n) {
    // write code here
    for(int gap = n/2; gap > 0; gap /= 2){   // 增量间隔
        for(int i = gap; i < n ;++i){   // 交换起始位置
            for(int j = i - gap;j >= 0;j -= gap){  // 控制交换
                if(A[j] > A[j + gap]){
                    swap(A[j],A[j+gap]);
                }
            }
        }
    }
    return A;
}