各种排序算法总结

转载：http://blog.csdn.net/warringah1/article/details/8951220

明天就要去参加阿里巴巴的实习生笔试了，虽然没想着能进去，但是态度还是要端正的，也没什么可以准备的，复习复习排序吧。

1 插入排序

void InsertSort(int a[], int n)

{

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

int key = a[i];

int j = i - 1;

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

a[j+1] = a[j];

--j;

}

a[j+1] = key;

}

插入排序是稳定的排序，平均和最坏时间复杂度是O(n^2)。最好的时间复杂度是O(n)，对应于全部排好序的情况。

2 冒泡排序

void BubbleSort(int a[], int n)

{

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

for(int j=0; j<n-i; ++j) {

if(a[j]>a[j+1]) {

inttemp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

}

冒泡排序是稳定的排序，平均和最坏时间复杂度是O(n^2)。

3 选择排序

每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。

void SelectSort(int a[], int n)

{

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

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

if(a[i]>a[j]) {

inttemp = a[i];

a[i] = a[j];

a[j] = temp;

}

选择排序是不稳定的，因为，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了平均和最坏时间复杂度是O(n^2)。

4 希尔排序（缩小增量排序）

该方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

void ShellSort(int a[], int n)

{

for (int gap=n/2; gap>0; gap/=2) {

for(int i=0; i<gap; ++i) {

for(int j=i+gap; j<n; j+=gap) {

if(a[j]<a[j-gap]) {

int temp = a[j];

int k = j-gap;

while (k>=0&&a[k]>temp) {

a[k+gap] = a[k];

k -= gap;

}

a[k+gap] = temp;

}

void ShellSortImproved(int a[], int n)

{

for (int gap=n/2; gap>0; gap/=2) {

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

if(a[j]<a[j-gap]) {

inttemp = a[j];

intk = j - gap;

while(k>=0 && a[k]>temp) {

a[k+gap] = a[k];

k -= gap;

}

a[k+gap] = temp;

}

希尔排序是不稳定的。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。使用希尔增量时，最坏运行时间是O(n^2)，使用Hibbard增量时，最坏运行时间是O(n^3/2)。

5. 堆排序

void MaxHeapify1(int a[], int n, int i)

{

int l = LEFT(i);

int r = RIGHT(i);

int largest;

if (l<n&& a[l]>a[i])

largest= l;

else

largest= i;

if (r<n&& a[r]>a[largest])

largest= r;

if (largest!=i) {

swap(a[i], a[largest]);

MaxHeapify1(a, n, largest);

} else

return;

}

void MaxHeapify2(int a[], int n, int i)

{

int c, largest;

while (1){

c= LEFT(i);

if (c>=n)

break;

if (a[i]<a[c])

largest= c;

else

largest= i;

if (c+1<n) {

if(a[largest]<a[c+1])

largest= c + 1;

}

if (largest!=i) {

swap(a[i], a[largest]);

i= largest;

} else

break;

}

void HeapSort(int a[], int n)

{

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

MaxHeapify1(a, n, i);

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

swap(a[i], a[0]);

MaxHeapify1(a, i, 0);

}

堆排序是原地排序，但是不是稳定排序。时间复杂度O(nlogn)。

6 归并排序

void Merge(int a[], int p, int q, int r)

{

int n1 = q - p + 1;

int n2 = r - (q+1) +1;

int *L = new int[n1+1];

int *R = new int[n2+1];

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

L[i] = a[p+i];

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

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

L[n1] = INT_MAX;//哨兵

R[n2] = INT_MAX;

int i = 0, j = 0;

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

if (L[i]<=R[j])

a[k] = L[i++];

else

a[k] = R[j++];

}

delete[] L;

delete[] R;

}

void MergeSort(int a[], int p, int r)

{

if (p<r) {;

int q = ((r-p)>>1) + p;

MergeSort(a, p, q);

MergeSort(a, q+1, r);

Merge(a, p, q, r);

}

合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。时间复杂度是O(nlogn)。可以在空间复杂度O(1)的条件下实现归并排序。

7. 快速排序

被快速排序所使用的空间，依照使用的版本而定。使用原地（in-place）分区的快速排序版本，在任何递归调用前，仅会使用固定的额外空间。然而，如果需要产生O(log n)嵌套递归调用，它需要在他们每一个存储一个固定数量的信息。因为最好的情况最多需要O(log n)次的嵌套递归调用，所以它需要O(log n)的空间。最坏情况下需要O(n)次嵌套递归调用，因此需要O(n)的空间。

void Median3(int a[], int p, int r)

{

int median = p + ((r-p)>>1);

if (a[p]>a[median])

swap(a[p], a[median]);

if (a[p]>a[r])

swap(a[p], a[r]);

if (a[median]>a[r])

swap(a[median], a[r]);