常见排序算法及其实现

以下总结常见排序算法及其实现。对面试尤为有用。

 

中文英文时间复杂度（最坏和平均）稳定性空间复杂度备注冒泡排序Bubble SortO(n²)/O(n²)YESO(1)即使在O(n²)算法中也是效率低下的。关键，每次冒泡
之后，最后一个元素是已经排序好的，所以不用再排了。
如果一轮排序后已经没有swap,则不用再排了。插入排序Insertion SortO(n²)/O(n²)YESO(1)有一些优势：在O(n²)算法中，效率较高，如果数据集
基本有序，则效率较高。从数据结构上来说，使用链表
会使效率较高。

 

在数组上实现的方法：第n步排前n个元素，第n+1步插
入第n+1个元素，保留比a[n+1]小的元素的位置，比
a[n+1]大的后移一位，覆盖a[n+1]。

选择排序Selection SortO(n²)/O(n²)NOO(1)比插入稍差。实现简单。基本思想是第n步找a[n:]
之中最小的那个，与a[n]交换。快速排序Quick SortO(n²)/O(nlogn)NoO(logn)比其他的O(nlogn)算法在实际上都要快一些，所以用的
最多。

 

基本思路，找到一个pivot value，利用这个pivot
value将整个数组分成两部分，第一部分都小于pivot
value，第二部分都大于，然后递归调用。

在数组上实现的方法：写一个partition函数，首先，把
pivot value与最后一个元素替换，而后寻找pivot
value应该在的位置，方法是每次将比pivot value
小的元素与pivot value预期所处的位置替换。即可。

堆排序Heap SortO(nlogn)/O(nlogn)NOO(n)/C与Quick Sort相比，Heap Sort有较低的Worst Case
Complexity。但是在实际情况下运行得较慢。在实时
系统中，为保证速度稳定性，常用堆排序。

 

与归并排序相比，最大的问题是依赖于随机存储。不适用
同时与外部排序，在目前的电脑上，由于Cache原因运行
较慢。同时Merge Sort是稳定的。

Merge Sort比较适用于并行计算。

归并排序Merge SortO(nlogn)/O(nlogn)YESO(n)见上。                                    

代码 (in Java)

---

1. 冒泡排序

 

public int[] sort(int[] r) {for(int i = 0; i<r.length;i++){for(int j = 0; j< r.length-i-1;j++){if(r[j]>r[j+1]){swap(r,j,j+1);}}}return r;}

2. 插入排序

public int[] sort(int[] r) {for(int i = 1 ; i<r.length ; i++){int value = r[i];for(int j = 0; j< i; j++){if(r[j] > value){for(int l = j ; l < i; l++){r[l+1] = r[l];}r[j] = value;break;}}}return r;}

3. 选择排序

public int[] sort(int[] r) {for(int i = 0; i<r.length;i++){int min = Integer.MAX_VALUE;int minpos = -1;for(int j=i; j<r.length;j++){if(r[j]<min){min = r[j];minpos = j;}}swap(r,i,minpos);}return r;}

4. 快速排序

    int partition(int[] r, int left, int right, int pivotIndex){        swap(r,pivotIndex, right);        int storeIndex = left;        int pivotValue = r[right];        for(int i = left; i< right ; i++){            if(r[i]<=pivotValue){                swap(r,i,storeIndex);                storeIndex = storeIndex+1;            }        }        swap(r,storeIndex,right);        return storeIndex;    }

    void qsort(int[] r , int left, int right){        if(left == right){            return;        }else{            if(right-left==1){                if(r[left]>r[right]){                    swap(r,left,right);                    return;                }                return;            }        }        int pivotIndex = (left + right) / 2;        int nPivotIndex = partition(r,left,right,pivotIndex);        if(nPivotIndex>left)            qsort(r,left,nPivotIndex-1);        if(nPivotIndex<right)            qsort(r,nPivotIndex+1,right);    }

5. 归并排序

public void merge(int[] r, int left, int right, int center, int[] cache){int pos = left;int cur1 = left, cur2 = center +1;for(;cur1<=center && cur2 <=right; pos++){if(r[cur1]<r[cur2]){cache[pos] = r[cur1];cur1++;}else{cache[pos] = r[cur2];cur2++;}}for(;cur1<=center;cur1++,pos++){cache[pos] = r[cur1];}for(;cur2<=right;cur2++,pos++){cache[pos] = r[cur2];}for(pos = left ; pos <= right; pos++){r[pos] = cache[pos];}}public void merge_sort(int[] r, int left, int right, int[] cache){int len = right - left +1;if(len <= 1){return;}else{int center = (left + right)/2;merge_sort(r,left,center,cache);merge_sort(r,center+1,right,cache);merge(r,left,right,center,cache);}}

6.