排序算法
一、 简单排序
1. 冒泡排序
（1）
（2）
a、相邻位置两两交换，直到最大数排好序。
b、对剩下元素重复此步骤。
code：
int temp;
for(int i = arr.length - 1; i > 0; i--)
for( int j = 0; j < i; i++) // 对 i 个元素，比较i - 1 次
if(arr[i] > arr[i + 1]){
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
2. 选择排序
（1）
（2）
a、从队列中选择最小元素与队首元素交换，队首元素现已有序
b、重复步骤a
code：
for(int i = 0; i < arr.length - 1; i++){
int min = i;
for(int j = i+1; j < arr.length; j++){
if(arr[min] > arr[j])
min = j;
}
swap(i, index);
}
3. 插入排序
（1）
（2）
a、部分有序的数列，取出被标记元素，比该元素大的数依次右移。空处插入标记元素。
b、重复上步骤
code：
int i, j, temp;
for( i = 1; i < arr.length; i++){
temp = a[i];
for( j = i; j > 0 && temp < arr[j-1]; j--)
arr[j] = arr[j-1];
arr[j] = temp;
}
二、 高级排序
1.归并排序
（1） （2） （3）
a、两个有序数组合并是简单的。
b、调用递归，将数组分成一半一半。
code：
public void merge(int[] workspace, int lowPtr, int highPtr, int upperBound){
int j = 0;
int lowerBound = lowPtr;
int mid = highPtr - 1;
int n = upperBound - lowPtr + 1;
while(lowPtr <= mid && highPtr <= upperBound)
if(arr[lowPtr] < arr[highPtr])
workspace[j++] = arr[lowPtr++];
else
workspace[j++] = arr[highPtr++];
while(lowPtr <= mid)
workspace[j++] = arr[lowPtr++];
while(highPtr <= upperBound)
workspace[j++] = arr[highPtr++];
for(j = 0; j < n; j++)
arr[lowerBound + j] = workspace[j];
}
public void recMergeSort(int[] workspace, int lowerBound, int upperBound){
if(lowerBound >= upperBound)
return;
int mid = (lowerBound + upperBound) / 2;
recMergeSort(workspace, lowerBound, mid);
recMergeSort(workspace, mid + 1, upperBound);
merge(workspace, lowerBound, mid + 1, upperBound);
}
2. 希尔排序
（1） （2）
a、对增量为N=（3*n + 1）的元素进行排序，N逐步减小直至为1.
b、当N为1时，该算法退化为插入排序。
code：
int inner, outer;
int temp;
int h = 1;
while(h <= length/3)
h = h*3 + 1;
while(h>0){
for(outer = h; outer < length; outer++){
temp = arr[outer];
inner = outer;
while(inner > h-1 && arr[inner-h] >= temp){
arr[inner] = arr[inner-h];
inner -= h;
}
arr[inner] = temp;
}
h = (h-1) / 3;
}
3. 快速排序
a、以数组左右端元素为pivot划分数组
b、递归调用左右子数组
code：
public int partitionIt(int left, int right, int pivot){
int leftPtr = left - 1;
int rightPtr = right;
while(true){
while(leftPtr < right && arr[++leftPtr] < pivot)
;
while(rightPtr > left && arr[--rightPtr] > pivot)
;
if(leftPtr >= rightPtr)
break;
else
swap(leftPtr, rightPtr);
}
swap(leftPtr, right);
return leftPtr;
}
public void quickSort(int left, int right){
if(right <= left)
return;
else{
int pivot = arr[right];
int partion = partitionIt(left, right, pivot);
quickSort(left, partion - 1);
quickSort(partion + 1, right);
}
}
}
4. 堆排序
堆排序分为建堆和堆调整两个过程。
首先描述堆调整过程，这是堆排序的核心。从最后一个非叶子节点开始。判断该节点与其最大子节点值的大小。若该节点值较小，则交换该节点与最大孩子节点。往下一直重复此操作，直至孩子节点<长度len为止。
对上一个非叶子节点重复操作，直至到达根节点为止。
public static void adjustHeap(int[] arr, int pos, int len){
int child;
while(2*pos + 1 <= len){ // 判断是否到达最下层
child = 2*pos + 1;
if(child < len && arr[child] < arr[child+1]) // 寻找最大子节点
child++;
if(arr[pos] < arr[child])
swap(arr, pos, child); // 若父节点较小，交换
else
break;
pos = child; // 重置标志，往下重复到最下层
}
}
public static void heapSort(int[] arr){
int len = arr.length;
for(int i = len/2 - 1; i >= 0; i--) // 从最后一个非叶子节点开始，把堆调整为大根堆
adjustHeap(arr, i, len-1); //adjustHeap只调整一趟
for(int i = len-1; i >= 0; i--){
swap(arr, 0, i);
adjustHeap(arr, 0, i-1);
}
}
