细数那些我们熟悉的 排序！

第一个 ，不得不说的 是 <冒泡排序>

作为 一个非常经典，又差劲的算法 。

计算过程如下：

　　　　->每次遍历数组，通过对比，使最大的冒上去,

->这样通过N次的轮循 ，可以使 排序的数组有序。

优点：简单，适用性强。

　　缺点：慢。

　　适用性：数组，链表.

　　性质：稳定性排序【打乱元素的稳定性，也就是　你不知道　这个元素　一开始是　３,3,3,排序后的　这个三是哪个三】。

　　复杂度：平均 n^2，在有序的情况下，可以 O(N) ,

代码：　不写

　二：归并排序：

　　　前言：归并排序，是利用分治的思想，

也就是说 将一个大问题化为一些小问题，这样在解决小问题的情况下，

在通过，合并操作，使以解决的小问题称以解决的大问题。

计算过程如下：

　　　　->将一个数组递归的分解成俩断->四段->八段->直到分解称只有一个元素

->在一个元素的情况下，这断可以认为是有序的,进而满足解决了这个小问题

　　　　->对于合并，对于俩段有序的数组，只要在每个数组上打一个index每次取最小的那个元素不，知道元素取完毕就好。

优点：稳定，效率一般（不断的SWAP）

　　缺点：需要额外的内存。

　　适用性：数组，链表（需要预先处理出分段，麻烦，一般可以认为不支持）.

　　性质：稳定性排序

　　复杂度：平均 n*log(n)。

　　代码：

void mergeSort(int v[], int l, int r, int tmpArray[]) {
if (l == r) {
return;
}
int mid = l + (r - l) / 2;
mergeSort(v , l, mid, tmpArray);
mergeSort(v , mid + 1, r, tmpArray);
for (int i = l, j = mid + 1, idx = l ; i <= mid || j <= r; ) {
if (i <= mid) {
if(j <= r) {
tmpArray[idx++] = v[i] <= v[j] ? v[i++] : v[j++];
} else {
tmpArray[idx++] = v[i++];
}
}  else {
tmpArray[idx++] = v[j++];
}
}
for(int i = l; i <= r ; i ++) {
v[i] = tmpArray[i];
}
}

三：堆排序：

　　堆排序，人如其名，利用堆来排序，原理有些类似于冒泡排序，都是每次找出最大值。

　　盗图->

void sort(int * v, int l ,int r){
if (l >= r) return;
int key = v[l];
int low = l, high = r;
while(low < high) {
while(low < high && v[high] >= key) high --;
v[low] = v[high];
while(low < high && v[low]  <= key) low ++;
v[high] = v[low];
}
v[low] = key;
sort(v, l, low - 1);
sort(v, low + 1, r);
}

View Code

　　

优点:内存无额外消耗，平均而言了认为是最好的排序算法。

性质，非稳定性排序。

复杂度n* logn,最坏情况下会退化到n^2

适用性，数组，链表。

,这个算法的关键在于寻找那个ＫＥＹ，能让左右平衡一些（有三分写法），这个算法，扫描多余交换．

有些代码我没写（想要写给你，夜深了）