算法——快速排序、希爾排序、堆排序
上一篇文章 簡單算法——直接插入、冒泡、直接選擇介紹了簡單排序法，本文在上一篇的基礎上，介紹各簡單排序法對應的高級算法。
首先依然是作一個公共的元素置換函數html
/** * 交換數組元素 * 交換思想很簡單 數字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）是對冒泡排序的一種改進。
基本思想：第一趟將數據分割成兩部分，其中一部分的全部數據都比另一部分都要小，而後再按此方法對這兩部分數據分別進行快速排序，整個排序過程能夠遞歸進行，直到整個數據變成有序序列。
基本操做：
一、設置兩個變量i、j，排序開始的時候：i=0，j=n-1；
二、以第一個數組元素做爲關鍵數據，賦值給key，即key=A[0]；
三、從j開始向前搜索，即由後開始向前搜索(j–)，找到第一個小於key的值A[j]，將A[j]和A[i]互換；
四、從i開始向後搜索，即由前開始向後搜索(i++)，找到第一個大於key的A[i]，將A[i]和A[j]互換；
五、重複第三、4步，直到i=j；
如：
原始數組[5, 3, 6, 4, 8, 7, 9]
第一輪快速排序：
根據基本操做一、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小的都在左邊！java
而後，對key兩邊的數據，再分別進行上述的過程，直到不能再分組爲止。
代碼實現：web
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);
//基本操做一、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，確保後續增量爲奇數)。windows
原始數組 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 9api
代碼實現數組
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;//>>表示向右移動一位
}