上一篇文章 简单算法——直接插入、冒泡、直接选择介绍了简单排序法，本文在上一篇的基础上，介绍各简单排序法对应的高级算法。
首先依然是做一个公共的元素置换函数
/**
* 交换数组元素
* 交换思想很简单 数字x y => x=x+y;y=x-y;x=x-y;
* 这种方法不使用临时变量，能有效降低算法空间复杂度，但也有缺点，比如可能存在越界风险
* @param arr
* @param a
* @param b
*/
public void swap(int []arr,int a,int b){
arr[a] = arr[a]+arr[b];
arr[b] = arr[a]-arr[b];
arr[a] = arr[a]-arr[b];
}快速排序
快速排序（Quicksort）是对冒泡排序的一种改进。
基本思想：第一趟将要数据分割成两部分，其中一部分的所有数据都比另外一部分都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，直到整个数据变成有序序列。
基本操作：
1、设置两个变量i、j，排序开始的时候：i=0，j=n-1；
2、以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3、从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
4、从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
5、重复第3、4步，直到i=j；
如：
原始数组[5, 3, 6, 4, 8, 7, 9]
第一轮快速排序：
根据基本操作1、2 ：设置变量 key=5,i=0,j=7
根据基本操作3,操作 j 得到：4 3 6 5 8 7 9（i=0,j=3,a[j]=5,a[i]=4）
根据基本操作4，操作 i 得到：4 3 5 6 8 7 9（i=2,j=3,a[i]=5,a[j]=6）
根据基本操作3,操作 j，当j等于2时，发现i==j，此时第一趟快速排序结束，此时得到： 4 3 5 6 8 7 9发现所有比key(6)值大的都在右边，比key小的都在左边！
然后，对key两边的数据，再分别进行上述的过程，直到不能再分组为止。
代码实现：
int arr[] = {5, 3, 6, 4, 8, 7, 9};
quickSort(arr,0,arr.length-1);
public void quickSort(int[] arr, int low, int high){
if(low >= high) {
return;
}
System.out.print(" k = " + ++k);
//基本操作1、2
int i = low;
int j = high;
int key = arr[low];
while (i<j){
//基本操作3
while (i < j && arr[j] >= key){
j--;
}
if(i < j) {
swap(arr, i++, j);
}
//基本操作4
while (i < j && arr[i] < key){
i++;
}
if(i < j) {
swap(arr, i, j--);
}
}
//对key两边的数据，再分别进行上述的过程
quickSort(arr,low,i-1);
quickSort(arr,i+1,high);
}快速排序有很多变种，如三平均分区法、随机化快排等，这里不多做介绍！
希尔排序
希尔排序(Shell’s Sort)是直接插入排序算法的一种更高效的改进版本。
基本思想：先取一个正整数 d1 < n 作为第一个增量，把数组中所有相隔d1的数据对归为一组，组内进行直接插入排序；然后取 d2 < d1 ,重复上述操作，直至di = 1,即所有记录放在同一组中进行直接插入排序为止。(一般d1=n/2，以后每次减半，若结果为偶数，则加1，确保后续增量为奇数)。
原始数组 5,3,6,4,8,7,9
第一步：d1取3 ，将相隔为3的数据分为一组，组内进行直接插入排序
[5,4,9] [3,8] [6,7] —> 4 3 6 5 8 7 9
第二步：d2=1，将相隔为1的数据分为一组，组内进行直接插入排序
[5,3,6,4,8,7,9] —> 3 4 5 6 7 8 9
代码实现
int arr[] = {5, 3, 6, 4, 8, 7, 9};
public void sort(int[] arr) {
//增量gap，并逐步缩小增量
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
//从第gap个元素，逐个对其所在组进行直接插入排序操作
directSort(arr, gap);
}
}
//这里就是简单插入排序了，详细可查看上一篇文章
public void directSort(int[] arr, int gap) {
for (int i = 0; i < arr.length; i++) {
int j = i;
while (j + gap <=arr.length-1 && arr[j] > arr[j + gap]){
swap(arr, j, j + gap);
j += gap;
}
}
}堆排序
堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。
小根堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2];大根堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2] 。本文以大根堆（升序）为例！
基本操作：
①建堆：建堆是不断调整堆的过程，从len/2处开始调整，一直到第一个节点；
②调整堆：调整堆就是比较节点i和其子节点left(i),right(i)，选出三者最大(或者最小)者，如果最大值不是节点i而是它的一个子节点，就进行交换，然后重复这个过程。
③堆排序：堆排序是利用上面的两个过程来进行的。先取出根节点，然后前面len-1个节点继续进行堆调整的过程，接着再将根节点取出直到所有节点都取出。
这种排序需要对“树”有一定的了解：
原始数组 [5,3,6,4,8,7,9] 可以转换成下图二叉树结构
程序实现
int arr[] = {5, 3, 6, 4, 8, 7, 9};
//构建大顶堆
buildMaxHeapify(arr);
//堆排序
heapSort(arr);
/**
*排序，最大值放在末尾，arr虽然是最大堆，在排序后就成了递增的
*
*@paramarr
*/
private static void heapSort(int[] arr){
//末尾与头交换，交换后调整最大堆
for(int i=arr.length-1;i>0;i--){
swap(arr, 0, i);
maxHeapify(arr,i,0);
}
}
/**
* 建堆
* @param arr
*/
private static void buildMaxHeapify(int[] arr){
//从最后一个的父节点开始
int startIndex=getParentIndex(arr.length-1);
//从下至上，从右至左调整
for(int i=startIndex;i>=0;i--){
maxHeapify(arr,arr.length,i);
}
}
/**
*调整堆
*/
private static void maxHeapify(int[] arr,int size,int index){
//获取左子节点下标 等价于index*2+1
int left = (index<<1) + 1;
//获取右子节点下标 等价于index*2+2
int right = (index<<1) + 2;
//当前点与左右子节点比较
int largest=index;
if(left<size && arr[index]<arr[left]){
largest=left;
}
if(right<size && arr[largest]<arr[right]){
largest=right;
}
//得到最大值后可能需要交换，如果交换了，其子节点可能就不是最大堆了，需要重新调整
if(largest!=index){
swap(arr, index, largest);
maxHeapify(arr,size,largest);
}
}
/**
*父节点位置
*@return 等价于(current-1)/2 如：(4-1)/2等于1 等价于二进制0011向右移动一位0001
*/
private static int getParentIndex(int current){
return(current-1)>>1;//>>表示向右移动一位
}