排序算法

给出含有n个元素的数组array[n]，对其进行排序(排列成从小到大)。

对于每一个算法，需要给出 代码、算法复杂度、空间复杂度、是否稳定。

1.插入排序

void insert_sort(int *array, int n){

for(int j=1;j<n;j++){

int i=j-1;

int key=a[j];

while(i>=0 && a[i]>key){

a[i+1]=a[i];

i--;

}

a[i+1]=key;

}

}

复杂度、稳定性 自己从代码看吧

空间复杂度为O(1),因为程序只需要额外的几个变量就可以了。

2.归并排序

void merge(int *A, int p, int q, int r){

int n1=q-p+1;

int n2=r-q;

int *array1 = (int *)malloc( n1*sizeof(int)); 

int *array2 = (int *)malloc( n2*sizeof(int));

for(int i=0;i<n1;i++)

array1[i] = A[p+i];

for(int i=0;i<n2;i++)

array2[i] = A[q+i+1];

int i=0,j=0;

for(int k=p;k<=r;k++){

if( i<n1 && array1[i]>array2[j]){

A[k] = array1[i];

i++;

}else if( j<n2){

A[k] = array2[j];

j++;

}

}

}

void merge_sort(int *array, int p, int r){

if(p<r){

q=(p+r)/2;

merge_sort(array, p, q);

merge_sort(array, q+1, r);

merge(array, p, q, r);

}

}

排序的时候只需调用merge_sort(array, 0, n-1)即可。

使用了递归，看起来很复杂，不过算法时间复杂度降为O(nlgn), 稳定倒还是稳定的.

同时时间复杂度增加，需要空间为O(n)。

在本程序中每次调用merge都重新申请，对效率会有影响，改为程序全局申请一个长度为n数组会更好些。

3.堆排序

引入了二叉堆这个数据结构，二叉堆跟完全二叉树很像。

int heap_size; //全局变量

void max_heapify(int *array, int i){

int left = 2*i +1;

int right = 2*i +2;

int largest;

if(left < heap_size && array[left] > array[i])

largest = left;

else

largest = i;

if(right < heap_size && array[right] > array[largest])

largest = right;

if(largest != i){

int temp = array[i];

array[i] = array[largest];

array[largest] = temp;

max_heapify(array,largest);

}

}

void build_max_heap(int *array, int n){ //要把数据从小到大排序，就要构建大顶堆，

heap_size = n;

for(int i=n/2; i>=0; i--)

max_heapify(array, i);

}

void heap_sort(int *array, int n){

build_max_heap(array, n);

for(int i=n-1; i>0; i--){

int temp = array[i];

array[i] = array[0];

array[0] = temp;

heap_size--;

max_heapify(array, 0);

}

}

堆排序中，max_heapify时间复杂度O(lgn), build_max_heap时间复杂度O(n),

heap_sort时间复杂度为O(nlogn).

空间复杂度：不需要额外的数组，故空间复杂度为O(1)。

稳定性：不稳定。原因呢？两个相等的元素A、B，原来的时候A在B前面，可在max_heapify过程中比较largest时，A在自己的分支中较小而没有动，B在自己分支中较大就上去了，这时B就排在A前面了。

顺便说一句，堆排序虽然性能不错，但还是比不上下面要讲的快排，但这里讲的堆结构还是有很多应用的，比如用于实现优先队列。max priority queue 和 min priority queue。

4.快速排序

快排在最坏情况下时间复杂度为O(n^2)，平均时间复杂度为O(nlgn), 但实际应用中，该算法往往效率很高。

void quick_sort(int *array, int p, int r){

if(p<r){

int q = partition(array, p, r);

quick_sort(array, p, q-1);

quick_sort(array, q+1, r);

}

}

int partition(int *array, int p, int r){

int x = array[r];

int i = p-1;

for(int j=p; j<r; j++){

if(array[j] <= x){

i++;

int temp= a[i];

a[i] = a[j];

a[j] = temp;

}

}

int temp = array[i+1];

array[i+1] = x;

array[r] = temp;

return (i+1);

}

空间复杂度：需要程序员搞定的空间还是常数O(1). 但是由于使用了递归，递归栈上会使用一些空间，递归栈上的空间复杂度 最坏O(n)，平均O(lgn)。 快速排序是不稳定的。

以下为线性时间排序，这些排序都对数据有一定的限制，因为只要是使用比较来进行排序的算法，都不可能打破O(nlgn)的下限。

5.counting sort 计数排序

计数排序要求输入的含有n个元素的数组中，每个元素的大小都在0~k之间，而且k=O(n)。

void count_sort(int *array, int n, int k){

int *B = (int *)malloc(n*sizeof(int));

int *C = (int *)malloc( (k+1)*sizeof(int));

for(int i=0; i<=k; i++)

C[i] = 0;

for(int i=0; i<n; i++)

C[array[i]]++;

for(int i=1; i<=k; i++)

C[i] = C[i] + C[i-1]; 

for(int i=n-1; i>=0; i--){

B[ C[A[i]] - 1 ] = A[i];

C[A[i]]--;

}

}

这个计数排序需要O(n+k)的额外空间，并且它是稳定的。

若是不要求稳定性，我们可以改写上述算法，改为原地排序，即不需要上面程序中的B数组了。

6.radix sort 基数排序

卡片排序机使用的就是基数排序。基数排序一般用于含有多个域的数据排序。比如一个日期含有年、月、日三个域，对日期进行排序。

radix sort要调用其他的一个稳定排序算法。

void radix_sort(int *array, int d) { //d表示的是数据所划分的域的个数

for(int i=0; i<d; i++)

use a stable sort to sort arrya on digit i。

}

给出一个有n个元素的数组，数组中全是d位的数，每个数的每一位都可用k个可能的值（对于十进制整数就是0-9），针对d位中每一位的排序使用计数排序，那么基数排序的时间复杂度为O(d(n+k))。

7.bucket sort 桶排序

还有一些排序方法 在算法导论中没有提到：

冒泡排序 O(n^2),稳定

希尔排序 O(n^2) 不稳定 

选择排序 O(n^2) 不稳定