排序效率（慢 -> 快）：冒泡排序 < 选择排序 < 插入排序 < 快速排序
一、快速排序
1. 简单介绍
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来，且在大部分真实世界的数据，可以决定设计的选择，减少所需时间的二次方项之可能性。
2.缺点
对内存和CPU消耗非常大
3. 操作步骤
a> 从数列中挑出一个元素，称为 “基准”（pivot）。
b> 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
c> 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
4. 排序效果图
4. C语言实现
-
-
-
-
-
-
-
- #include <stdio.h>
- #include <stdlib.h>
-
- #define BUF_SIZE 10
-
-
-
-
-
-
-
- void display(int array[], int maxlen)
- {
- int i;
-
- for(i = 0; i < maxlen; i++)
- {
- printf("%-3d", array[i]);
- }
- printf("\n");
-
- return ;
- }
-
-
-
-
-
-
-
- void swap(int *a, int *b)
- {
- int temp;
-
- temp = *a;
- *a = *b;
- *b = temp;
-
- return ;
- }
-
-
-
-
-
-
-
- void quicksort(int array[], int begin, int end)
- {
- int i, j;
-
- if(begin < end)
- {
- i = begin + 1;
- j = end;
-
- while(i < j)
- {
- if(array[i] > array[begin])
- {
- swap(&array[i], &array[j]);
- j--;
- }
- else
- {
- i++;
- }
- }
-
-
-
-
-
-
-
-
- if(array[i] >= array[begin])
- {
- i--;
- }
-
- swap(&array[begin], &array[i]);
-
- quicksort(array, begin, i);
- quicksort(array, j, end);
- }
- }
-
-
- int main()
- {
- int n;
- int array[BUF_SIZE] = {12,85,25,16,34,23,49,95,17,61};
- int maxlen = BUF_SIZE;
-
- printf("排序前的数组\n");
- display(array, maxlen);
-
- quicksort(array, 0, maxlen-1);
-
- printf("排序后的数组\n");
- display(array, maxlen);
-
- return 0;
- }
二、归并算法
1. 简单介绍
归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
2. 操作步骤
a> 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列。
b> 设定两个指针，最初位置分别为两个已经排序序列的起始位置。
c> 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置。
d> 重复步骤3直到某一指针达到序列尾。
e> 将另一序列剩下的所有元素直接复制到合并序列尾。
3. 排序效果图
4. 归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并，也就是下面用到的方法。
归并排序使用递归实现，递归的终止条件为当一个序列只有一个元素的时候，为已排序序列，即返回，然后返回的两个序列都为已排序序列，使用归并进行合并排序。
其实现C代码如下：
//两个序列在同一个数组中，而且在位置上是相邻的，根据形参将两个序列标记出来，将两个序列归并结果到临时数组中，然后在复制到数组中。
//实现过程中，很多地雷，尤其数组下标，一不小心就越界了。core dump
void merge(int *array,int *tmp_array,int lpos,int rpos,int end)
{
int left_end = rpos - 1;
int right_end = end;
int left_pos = lpos;
int right_pos = rpos;
int i;
int tmp = 0;
while((left_pos <= left_end)&&(right_pos <= right_end))
{
if(array[left_pos] < array[right_pos])
{
tmp_array[tmp] = array[left_pos];
++left_pos;
}
else
{
tmp_array[tmp] = array[right_pos];
++right_pos;
}
++tmp;
}
while(left_pos <= left_end)
{
tmp_array[tmp] = array[left_pos];
left_pos++;
++tmp;
}
while(right_pos <= right_end)
{
tmp_array[tmp] = array[right_pos];
right_pos++;
++tmp;
}
for(i = 0;i < tmp;i++)
{
array[lpos + i] = tmp_array[i];
}
}
//递归的实现，终止条件为只有一个数，返回
//递归返回之后，该序列部分为已经排好序
//将两次的返回序列，进行归并排序
void m_sort(int *array,int *tmp_array,int left,int right)
{
int centre = (left + right)/2;
if(left < right)
{
m_sort(array,tmp_array,left,centre);
m_sort(array,tmp_array,centre+1,right);//centre记住只能+，不能是-，坑死老爹了，要是-的话，如left = 0，right = 1的时候，centre就是 -1呀，都越界到天边去了。调了好久。
merge(array,tmp_array,left,centre+1,right);
}
}
//这个也可以不要其实就可以了，但是为了保持与前面排序算法的实现保的函数形参保持一致，还是加上了。
void recursion_merge_sort(int *array,int num)
{
int *tmp_array;
tmp_array = malloc(num*sizeof(int));
assert(tmp_array != NULL);
m_sort(array,tmp_array,0,num-1);
free(tmp_array);
}
该实现，并没有在每次递归中使用临时数组，而是公用了一个指针传递过来的数组，这样大大的减少了算法过程中，不会导致内存线性的消耗。
归并排序的算法复杂度为O（NlogN），但是一般不用于主存的内部排序，因为可能增加排序的时候附加的内存，主要用在外部排序，对于内部排序，主要还是快排。
三、堆排序
1. 简单介绍
堆积排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
2. 排序效果图
3.
堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法。
将待排序的的序列构建成堆，大根堆，即父节点比子节点的数值要大，小根堆，父节点比子节点要小。
然后将堆的根（最大值或者最小值）取下，剩余的数据再构建成堆，再取下根值，如此迭代，直到只剩最后一个值。
出于效率的原因，堆在数组中实现，其中数组的下表对应着堆积树的节点序列，取下的根节点，将堆中的最后一个元素进行交换，那么一直到最后，该数组就是为一个排列好的数组。
其实现如下：
void heap_sort(int *array,int num)
{
/*
初次建立大根堆，注意数组下表与堆元素序列的对应问题，数组的下表是从0开始的
o(n)
*/
int k;
for(k = num/2;k >= 0;k--)
{
int flag;
int tmp;
int i = k ;
while(2*i+1 < num)
{
if(2*i+1 == num-1)
{
flag = 2*i + 1;
}
else
{
if(array[2*i+1] > array[2*i+2])
{
flag = 2*i + 1;
}
else
{
flag = 2*i + 2;
}
}
if(array[i] > array[flag]) break;
else
{
tmp = array[flag];
array[flag] = array[i];
array[i] = tmp;
i = flag;
}
}
}
/*取下根，与堆的最后一个元素交换，再重新建堆，如此迭代往复*/
int max;
int end;
int i;
for(i = 0;i < num;i ++)
{
//put the max num to the end
end = num -1 -i;
max = array[0];
array[0] = array[end];
array[end] = max;
//rebuild the heap,the length of array is end - 1
int flag;
int tmp;
int i = 0;
while(2*i+1 < end)
{
if(2*i+1 == end-1)
{
flag = 2*i + 1;
}
else
{
if(array[2*i+1] > array[2*i+2])
{
flag = 2*i + 1;
}
else
{
flag = 2*i + 2;
}
}
if(array[i] > array[flag]) break;
else
{
tmp = array[flag];
array[flag] = array[i];
array[i] = tmp;
i = flag;
}
}
}
}
在实现过程的时候，第一阶段堆的构建最多用到2N次比较，在取掉最大值，重新建堆的一次过程中，最多用到2logi。
因此在最坏的情况下，总数最多为2NlogN-O（N）次比较。
在实践中慢于sedgewick增量排序，是
不稳定
的排序方法
四、选择排序
1. 简单介绍
选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素，存放到第1个位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到第二个位置。以此类推，直到所有元素均排序完毕。
2. 排序效果图
3.C语言代码实现
void SelectSort(int *array,int length)
{
int i,j;
for(i=0; i<(length - 1); i++)
{
for(j=(i+1); j
array[j])
{
//交换 array[i] 与 array[j]
array[i] = array[i] ^ array[j];
array[j] = array[i] ^ array[j];
array[i] = array[i] ^ array[j];
}
}
}
}
五、冒泡排序
1. 简单介绍
冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
2. 操作步骤
a> 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
b> 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
c> 针对所有的元素重复以上的步骤，除了最后一个。
d> 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
3. 排序效果图
4. C语言的一般实现如下：
void bubble_sort(int *array,int num)
{
int i = 0;
int j = 0;
int temp;
for(;j < num;++j)
{
for(i= num;i >j ;--i)
{
if(array[i] < array[i-1])
{
temp =array[i];
array[i] = array[i-1];
array[i-1] = temp;
}
}
}
}
冒泡算法实现和原理都很简单，而且是稳定的排序算法，但是该算法不论什么情况下，算法的比较交换的次数都是恒定的，都为1+2+3+4+... ...+n-1
算法的复杂度为O（n^2）
六、插入排序
1. 简单介绍
插入排序（Insertion Sorting）的基本思想是：把n个待排序的元素看成1个有序表和1个无序表，开始是有序表中只有1个元素，无虚标中包含n-1个元素，排序过程中每次从无虚标中取出第1个元素，从后向前与有序表中元素进行比较，如果小于有序表中与之比较的元素则交换，使之不断的向前移动直至找到他的位置，使之成为新的有序表。
该排序算法的C语言的一般实现如下：
void insertion_sort(int *array,int num)
{
int i,j;
int temp;
i = 0;
j = 0;
for(;i < num;i++)
{
for(j=i;(j > 0)&&(array[j] < array[j-1]);j--)
{
temp = array[j-1];
array[j-1] = array[j];
array[j] = temp;
}
}
}
该算法的最坏情况，如逆序，那么复杂度为O(N^2)
最好的情况，如已经预先排好序或者基本排好，那么复杂度为O（N）
上面实现的算法中，排序数量比较大的时候，在比较插入操作时，直接比较操作的代价和交换操作很大，是呈线性增长。
因此该算法适用于少量数据的排序。
七、希尔排序
1. 简单介绍
希尔排序，也称递减增量排序算法，是插入排序的一种高速而稳定的改进版本。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
A、插入排序在对几乎已经排好序的数据操作时， 效率高， 即可以达到线性排序的效率。
B、但插入排序一般来说是低效的， 因为插入排序每次只能将数据移动一位。
2. 排序效果图
3. 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
希尔排序是特殊的插入排序
上述的增量会逐渐减少，直至减少到1，该过程中，增量会形成一个序列，称为增量序列。
希尔排序的算法的时间复杂度跟增量序列密切相关。
具体实现如下：
1:按希尔增量序列进行排序，即增量序列为（N/2,N/4.........1）
C语言的实现如下
void shell_sort(int *array,int num)//
{
int increment = 0;
int temp = 0;
int j = 0;
int k = 0;
int m = 0;
for(increment = num/2;increment > 0;increment /= 2)
{
printf("increment:%d \n ",increment);
for(j = 0;j < increment;j++)
{
for(k = j;k < num;k = k+increment)
{
printf("k:%d \n ",k);
for(m = k;(m >j)&&(array[m] < array[m-increment]);m = m -increment)
{
temp = array[m];
array[m] = array[m-increment];
array[m-increment] = temp;
}
}
}
}
}
使用希尔增量时希尔排序的最坏时间复杂度为O（N^2）
2:按照Hibbard增量序列进行排序，即增量序列为（2^k-1.........7,3,1） 其中(2^k-1)<n
此种增量的希尔排序的最坏运行时间为O(N^3/2)
3：按照sedgwick增量序列进行排序，增量序列为（1,5,19,41,109......）
此种增量的希尔排序的的最坏运行时间为O（N^7/6）
以上两种的实现，跟前面的希尔增量序列实现的代码差不多1，除了最外层的循环迭代由于增量与序列的不同，稍微有点变化之外。
扫一扫
304
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
