排序算法（初级版）之快排、归并、堆排序

排序算法是算法中的基础，也是面试常问常考的算法之一，今天先简单整理一下最常考的三个排序算法。以后有空（希望有空）了再统一优化一下。

七大排序算法的复杂度分析

排序算法	最坏时间辅助度	平均时间复杂度	空间复杂度	稳定性	备注
冒泡排序	O(n^2)	O(n^2)	O(1)	YES
交换排序	O(n^2)	O(n^2)	O(1)	YES
选择排序	O(n^2)	O(n^2)	O(1)	不稳定
插入排序	O(n^2)	O(n^2)	O(1)	YES
希尔排序	O(n^s)1<s<2	O(NlogN)	O(1)	不稳定
快速排序	O(n^2)	O(NlogN)	O(1)	不稳定
归并排序	O(NlogN)	O(NlogN)	O(n)	YES
堆排序	O(NlogN)	O(NlogN)	O(1)	不稳定

快速排序：最坏时间复杂度为O(n^2)，平均为O(NlogN)。当原数组已是排好序的，时间效率最差。总而言之，原数组越乱，效率越高。

之前整理过一篇，做过详细的分析，但是代码可读性不太好，今天重新写一遍代码。

public void quickSort(int[] num,int begin,int end){
if(num == null || begin >= end) return;
int tem = num[end];
int i = 0, j = end;
while(i < j){//时刻检查i < j
while(i < j && num[i] < tem){i++;}
if(i < j)num[j--] = num[i];
while(i < j && num[j] > tem){ j--;}
if(i < j)num[i++] = num[j];
}
num[j] = tem;
quickSort(num, begin, i - 1);
quickSort(num, i + 1, end);
}

归并排序：最坏时间复杂度达到了O(NlogN)。空间复杂度只有O(n)，非常棒。但是大数据的话，好像没有快排效率高。

mergeSort是我最喜欢的算法。同快排一样，分治法的实现，写起来，朗朗上口。

本算法我偷懒，开辟了额外的空间，这样写起来不需要来回的检查边界，比较方便，道理都是一样的，可以看之前的总结，算法过程总结的比较详细。

public class HeapSort {
public void heapSort(int[] array){
if(array == null || array.length <= 1) return;
buildHeap(array);//build the heap
int length = array.length;
while(length > 1){
swap(array, 0, length - 1);
adjust(array, --length, 0);
}
}
private void buildHeap(int[] heap){
for(int i = heap.length / 2; i >= 0; i--){
adjust(heap,heap.length, i);
}
}

private void adjust(int[] a,int length,int k){
int left = 2 * k + 1;
int right = 2 * k + 2;
if(left < length || right < length){
int min  = k;
if(left < length && a[left] < a[min]){
min = left;
}
if(right < length && a[right] < a[min]){
min = right;
}
if(min != k){
swap(a, min, k);
adjust(a,length, min);
}
}
}
private void swap(int[] a,int i ,int j){
if(i != j){
a[i] += a[j];
a[j] = a[i] - a[j];
a[i] -= a[j];
}
}
public static void main(String[] args) {
int[] a = {1,3,5,7,9,0,2,4,6,8};
HeapSort test = new HeapSort();
test.heapSort(a);
System.out.println(Arrays.toString(a));
}
}

View Code

//output:[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

哪些是不稳定的呢？

快，些（希尔），选，堆