文章目录
第三梯队
1.1 冒泡排序
冒泡排序很形象，即让较大元素想泡泡一样不断往上冒，代码如下。
void bubblesort1(int *array,int n)
{
for(int i = 0;i<n;i++)
for(int j = 0;j<n-i-1;j++)
{
if(array[j]>array[j+1])
swap(array[j],array[j+1]);
}
}
优化一：如图，在进行两轮冒泡后，排序已经完成，所以不需要再进行下去，即当一个循环内无元素的交换，代表序列已经有序了，此时可以跳出，减少循环次数。
void bubblesort2(int *array, int n)//简单优化
{
for(int i = 0;i<n;i++)
{
bool flag = true;
for(int j = 0;j<n-i-1;j++)
{
if(array[j]>array[j+1])
swap(array[j],array[j+1]);
flag = false;
}
if(flag)
break;
}
}
优化二：同上，每次直接记录最后交换元素的位置，其往后的元素已经有序，故下一次循环只需要比较到此位置即可。
void bubblesort3(int *array,int n)
{
int lastchange = 0;
int sortborder = n-1;
for(int i = 0;i<n;i++)
{
bool flag = true;
for(int j = 0;j<sortborder;j++)
{
if(array[j]>array[j+1])
{
swap(array[j],array[j+1]);
flag = false;
lastchange = j;
}
}
sortborder = lastchange;
if(flag)
break;
}
}
1.2 选择排序
顾名思义，选择排序即每次选择范围内最小的元素，把其放到最前的位置。选择排序和冒泡排序的不同在于，前者没有进行频繁的元素交换，而是在范围内遍历完后，再进行替换。
void choisesort(int *list,int n)
{
for(int i = 0;i<n;i++)
{
bool flag = true;
int m = i;
for(int j = i+1;j<n;j++)
{
if(list[j]<=list[m])
{
m = j;
flag = false;
}
}
if(flag)
break;
swap(list[i],list[m]);
}
}
选择排序被称为不稳定的排序，因为对于相同的元素，通过选择排序过后，可能会改变相同元素间的想对位置。如下图，这是选择排序的一个缺陷。
1.3 插入排序
插入排序，即假设前面的序列有序，然后用后面的元素不断与前面的有序序列比较，直到其能“插入”到一个合适的地方，即元素需要不断往后退，腾出空间给元素插入。
void insertsort(int *list,int n)
{
int tmp,i,j;
for(i = 1;i<n;i++)
{
tmp = list[i];
for(j = i-1;j>=0&&list[j]>tmp;j--)
list[j+1] = list[j];
list[j+1] = tmp;
}
}
1.4 鸡尾酒排序
鸡尾酒排序是冒泡排序的一种变式，适用于大部分有序序列的排序，如下图
如果使用冒泡排序，那么整个过程是这样的
这时我们就会发现，原本1和9中间的元素是有序的，只需要1和9变化即可完成，可是使用冒泡排序却要进行如此多次变化。
这时候鸡尾酒排序就有发挥的作用了，很容易想到，当9排到最后时，只需要对1进行往前的冒泡排序，就可以在一个循环内完成排序了。
即像一个钟摆那样，来回方向进行冒泡排序。
优化方式同前面的冒泡。
void cocktailsort(int *array,int n){
for(int i = 0;i<n/2;i++){
for(int j = i;j<n-1-i;j++){
if(array[j]>array[j+1])
swap(array[j],array[j+1]);
}
for(int j = n-2-i;j>i;j--){
if(array[j]<array[j-1])
swap(array[j],array[j-1]);
}
}
}
第一梯队的排序方法的平均时间复杂度均为O（n^2），空间复杂度O（1）。
上述各种算法没有说哪种最优，只是不同的算法使用与不同的情况。
（1）如插入排序和冒泡排序，两种排序都通过对元素频繁的交换来进行排序，交换的次数，即排序方法的性能取决于序列的有序程度。
插入排序的元素交换是连续的，而冒泡是两两相关，彼此独立的。显然，插入排序可以省去很多无用的比较，基于这个因素，插入排序的性能略高于冒泡排序。
（2）我们再来看选择排序，选择排序与上述两种方法有些不同，选择排序的比较次数是确定的，每次都选取范围内最小元素排到前面，至于序列的有序程度如何，对选择排序的比较次数是无影响的。
所以，对于大部分有序的序列，插入排序优；对于大部分无序的序列，选择排序优。
冒泡和插入是稳定算法，因为值相同的元素排序前后相对位置不会改变。而选择排序可能会改变相同元素的相对位置，所以选择排序不是稳定的排序。
第二梯队
2.1 希尔排序
希尔排序其实就是一种分组的插入排序。回想一下如何去优化插入排序的性能，或者什么样的序列用插入排序会更为高效。
1）更短的序列
2）更为有序的序列
如果满足以上的特点，那么将会大大减低插入排序的工作量。而希尔排序就是利用这两点，利用增量（即分组的跨度）来讲序列分成多个小组，组内进行插入排序。
至于增量的选取则有很多，例如Hibbard增量和Sedgewick增量，这里不讨论。
void hellsort(int *list,int n)//n为增量
{
int d = n;
while(d>1)
{
d = d/2;
for(int i = 0;i<d;i++){
for(int j = i+d;j<n;j = j+d)
{
int tmp = list[j];
int y;
for(y = j-1;y>=0&&list[y]>tmp;y--)
list[y+1] = list[y];
list[y+1] = tmp;
}
}
}
}
2.2 快速排序
快速排序运用一种分治的思想，即选择一个数，排序完成后，该数左边的数都小于该数，该数右边的数都大于该数。然后再分为两个子数组继续递归下去。流程大致如下。
首先定义两个指针left，right，以序列第一个数作为划分序列的边界，从右边向左找到第一个比其小的数，将该值覆盖到L的位置。
然后从L开始，从左往右遍历，找到第一个比9大的数。覆盖掉R所指元素。
重复上述步骤，最后循环跳出，得以下结果。
最后将tmp覆盖掉该位置，可看到9左边的元素都小于9,9右边的元素都大于9。
此时序列还没有完成排序，需要以9为界，把序列分成左右子部分，重复上述操作。
int fast_sort(int *list,int left,int right)
{
int tmp = list[left];
while(left<right)
{
while(list[right]>=tmp&&left<right)
right--;
list[left] = list[right];
while(list[left]<=tmp&&left<right)
left++;
list[right] = list[left];
}
list[left] = tmp;
return left;
}
void fastsort(int *list,int left,int right)
{
if(list==NULL||left>right)
return ;
int tmp = fast_sort(list,left,right);
fastsort(list,left,tmp-1);
fastsort(list,tmp+1,right);
}
2.3 归并排序
归并排序，即先拆后并，不断两两分组，把序列拆分成小序列，内部排序后再依次合并继续排序。
流程大致如下，取中间为界不断将序列分割。
分割后再每小组进行排序，一层一层地排下去。
整个流程其实很明了，层数logn层，每层都共有n个元素需要排序，所以时间复杂度为O（nlogn），而空间复杂度为O（n），因为每次拆分排序后，每一层的临时数组都是n，一层过后临时数组都会被释放，所以不需要叠加计算。
void func(int *list,int *tmp,int start,int end)
{
if(start>=end)
return ;
int mid = (start+end)/2;
int start2 = mid+1;
int start1 = start;
int end1 = mid;
int end2 = end;
func(list,tmp,start1,end1);
func(list,tmp,start2,end2);
int k = start;
while(start1<=end1 && start2<=end2)
{
tmp[k++] = list[start1]>list[start2]?list[start2++]:list[start1++];
}
while(start1<=end1)
tmp[k++] = list[start1++];
while(start2<=end2)
tmp[k++] = list[start2++];
for(int i = start;i<=end;i++)
list[i] = tmp[i];
}
void merge(int *list,int n)
{
int tmp[n];
func(list,tmp,0,n-1);
}
2.4 堆排序
堆排序利用了二叉堆这一个数据结构，二叉堆分为两种，有大顶堆和小顶堆。其利用了完全二叉树的特性，以数组作为底层结构，父节点下标为i，则其左节点为2i+1，右节点为2i-1。子节点的父节点为（i-1）/ 2。
在STL中，堆heap有两种基本操作，即上溯和下溯。在堆尾部插入元素，通过上溯使堆更新。下溯即把堆顶往下比较，sort_heap和make_heap都利用了下溯。
堆排序流程：
（1）先把序列构造成大顶堆
（2）然后将非叶子节点进行下溯操作
void _pop_heap(int *array,int parent,int len){
int tmp = array[parent];
int child = parent*2+1;
while(child<len){
if(child+1<len&&array[child]<array[child+1])
child++;
if(array[child]<=tmp)
break;
array[parent] = array[child];
parent = child;
child = parent*2+1;
}
array[parent] = tmp;
}
void _make_heap(int *array,int len){
for(int i = (len-2)/2;i>=0;i--){
_pop_heap(array,i,len);
}
}
void _sort_heap(int *array,int len){
_make_heap(array,len);
for(int i = 0;i<len;i++){
swap(array[0],array[len-1-i]);
_pop_heap(array,0,len-i-1);
}
}
构造堆需要进行n/2次下溯，排序时需要n次下溯，每次下溯logn，故综合起来时间复杂度为O（nlogn），无需额外空间，空间复杂度为O（1）。
第二梯队算法的平均时间复杂度均为O（nlogn），其中希尔排序最快可达O（n^1.3）。
快排最坏情况下复杂度会退化至O（n^2），例如序列 [9,1,2,3,4,5,6,7]，需要n次分组。
而堆排序相对于归并和快排性能又略低一些，因为二叉堆中父子节点并非是在连续空间上，对于底层的缓存机制来说，不命中率会高一些。
所以堆排序和快速排序都不是稳定的，而归并排序是稳定的，因为无论序列如何，也不会影响其排序的步骤。
不过归并排序需要额外O（n）的空间，而快排和堆排序都为原地算法。
第一梯队
3.1 计数排序
计数排序很好理解，即额外开拓标记数组记录每个数出现的次数，然后再按次序依次排列出来。比如一个序列只有4种数，[1,2,3,4,2,3,1,2,3,2]，通过遍历数组可知1出现了两次，2出现了四次，3出现了三次，4出现了一次。
以这种方式（数组大小为序列最大值）开辟数组很容易发现一个问题，如以下序列[90,91,92,97,99,98]，若以最大值开辟数组，那么中间大部分的空间都会被浪费。
因此采用一种优化的方法，取最大最小值之差加1来开辟数组，然后元素减去最小值所得的值作为下标。
就目前看来，计数排序算不上是一种排序，它只是记录数据出现次数，然后按序重构序列，对于相同数的相对位置等信息，单纯的计数排序无法保存。下面将介绍如何改良。
如要对下图跳远成绩进行排序。
按上述方法先申请标记数组（15-7+1）
在这里要进行特殊处理，即数组元素的值应为前面元素及自身的累加，如下图。
这样做的目的，其实记录出元素在最终结果数组中出现的位置。此时我们再从后往前遍历序列，将上述数组对应下标元素的值减1，即为其在最终结果数组中的位置。执行完后，要在数组相应位置减1。
void sort(int* array,int n,int *res){
int max = array[0];
int min = array[0];
for(int i = 1;i<n;i++){ //取最大最小值
max = max(array[i],max);
min = min(array[i],min);
}
int d = max-min+1;
int arr[d] = {0};
for(int i = 0;i<n;i++)//先正常标记
arr[array[i]-min]++;
for(int i = 1;i<n;i++)//特殊处理数组
arr[i] += arr[i-1];
for(int i = n-1;i>=0;i--){//插入元素
res[arr[array[i]-min]-1] = array[i];
arr[array[i]-min]--;
}
}
算法时间复杂度很好分析，为O（m+n）其中m为最大值和最小值之差。空间复杂度O（m）
计数排序缺点明显，显示中接触不多，对于排序序列非整数，最大最小值差距较大时，计数排序就没什么使用的必要了。
3.2 基数排序
基数排序是基于计数排序的一种排序，即如果需要对一系列字符串进行排序，只需要由低位到高位开始依次对每一位元素进行计数排序。
3.3 桶排序
桶排序大致是按序列元素情况，申请一定数量的桶，所谓桶，即大小在该区间内的数都会被放到该桶里面，在每个桶里面再各自做排序，最后有序将桶内元素倒出来即可。
以上三种算法均属于线性时间复杂度的排序算法，均稳定。其中
计数排序的时间复杂度是O（n+m）。
桶排序的时间复杂度是O（n），这是在分桶数量是n的前提下。
基数排序的时间复杂度是O（k（n+m）），其中k是元素的最大位数。
扫一扫
854
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
