浅谈排序
排序的现实意义每个人都知道，今日突然对各种排序算法产生了兴趣，于是谈下我所接触到的一些排序算法：
选择，插入，冒泡，快排，堆排，归并，基数，计数，bogo。
代码除个别都由本人所写，若有 bug 请您指正。
个人建议，一定要看看计数排序，别的快排和归并排想法也很好。选择和插入很基本，也是最容易理解的，最逆天的就是 bogo 了，一定要看哦！！
注：将input函数和output函数还有主函数写在了冒泡里，以后就直接写排序函数的代码了，其他部分的代码的输入输出函数、主函数和冒泡排序基本一致。
1.冒泡排序
描述：依次比较相邻的两个数，将小数放在前面，大数放在后面。这样每次都能将最大的数放在最后，多次迭代，一个有序的序列就出来了～～
其实冒泡排序就是选择排序，而且还比选择多比较了很多次。
实现：
View Code
View Code
#include <stdio.h>
#include <stdlib.h>
int a[10000];
int n;/* 共有 n 个需要排序的数 */
void input(){
int i;
scanf("%d", &n);
for(i = 0;i < n;++i){
scanf("%d", &a[i]);
}
return ;
}
void output(){
/* 将排序好的结果输出，以验证 */
int i;
for(i = 0;i < n; ++i){
fprintf(stdout,"%d ",a[i]);
}
printf("\n");
return ;
}
void bubble_sort(){
int i, j;
for(i = 0;i < n;++i){/* 执行n此迭代 */
for(j = 0;j < n-i-1; ++j){/* 比较相邻两个数，判断是否互换 */
if(a[j] > a[j+1]){
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}
int main(){
input();
bubble_sort();
output();
exit(0);
}
时间复杂度为n方，基本不需要额外空间。
2. 插入排序：
描述：想法非常简单，就像抓牌一样，来一张牌，把它放在前面 <= 它、后面 > 它的地方。当所有牌都抓完之后，自然就是一手有序的牌了。
实现：
View Code
/* 插入排序 */
void insertion_sort(){
int i;
for(i = 0;i < n; ++i){
int temp;
scanf("%d", &temp);
a[i] = temp;
int j;
/* 每次输入一个数字，都进行比较 */
for(j = 0; j < i; ++j){
if(temp < a[j]){/* 找到前面 <= 它，后面 > 它的位置 */
int k = i;
/* 因为是数组，所以需要每位后移，个人猜想用链表实现，会优化许多 */
for(;k > j; --k){
a[k] = a[k-1];
}
a[j] = temp;
break;
}
}
}
return ;
}
时间复杂度，毫无疑问的 n 方的。
空间上基本上都是没有什么大的消耗了。
用链表实现的话，在最优情况时间复杂度可以达到O(n)的，不过我写的太弱了。
3. 选择排序
描述：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好的数列的最后，直到全部待排序的数据元素排完。
实现：
View Code
#define MAX 0xfffffff
void selection_sort(){
int aim[10000];
int i;
int min = MAX;/* 每次选出的最小值 */
for(i = 0;i < n;++i){
int j;
int temp;/* 记录最小值的下标，以便修改其值*/
for(j = 0;j < n;++j){ /* 选出数组中的最小值 */
if(a[j] < min){
min = a[j];
temp = j;
}
}
a[temp] = MAX;
aim[i] = min;
min = MAX;
}
/* 将排序好的结果输出，以验证 */
for(i = 0;i < n; ++i){
fprintf(stdout,"%d ",aim[i]);
}
printf("\n");
return ;
}
时间复杂度 n方，空间需要多开一个数组，来存放目标数据。
4. 快速排序
描述：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的数据要小，然后再按此方法对这两部分分别递归进行快速排序，然后使整个数组变成有序序列。
实现：
View Code
/* 此代码来自《代码之美》，个人以为，确实是非常美 */
void quick_sort(int l, int u){/* l是较低的下标，u是较高的下标 */
int i, m;
if(l >= u) return;
swap(l, randint(l, u));/* swap(i,j)是交换a[i],a[j]，i,j不变 */
m = l;/* 从与第一个值比较，小的放左边，大的放右边 */
for(i = l+1; i <= u; ++i)
if(a[i] < a[l])
swap(++m, i);
swap(l, m);/* 将第一个值放在它该在的地方 */
quick_sort(l, m-1);/* 递归 */
quick_sort(m+1, u);
}
时间复杂度：期望时间 O(n log n) , 最坏情况O(n2) ; 对于大的、乱数列表一般公认是最快的已知排序
之所以会是log n，是由于二分了。。。
5. 堆排序
描述：堆排序就像是选择排序一样，每次都是选出最大或最小的值。不过选出最大或最小的值的方法不是线性的去找出来，而是用一种特殊的数据结构——堆，来管理算法执行中的信息。
堆是一个近似完全二叉树的结构，并同时满足堆的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。小于的就是小顶堆，大的就是大顶堆。于是就要建堆，调整出一个顶堆，然后把顶点的值取出来，再调整，再取，直到所有的元素都被取出来，一个有序的序列就出来了。
调整就是为了满足堆的性质。我们假定左右两颗子树都是大顶堆。但这时，顶点的值可能小于其孩子，于是就违反了大顶堆的性质，所以就和孩子中大的那个换一下位置，然后再递归判断两个子树的，然后再递归。最后就调整出一个大顶堆啦～～
实现：
View Code
void adjust(int ind, int len){
/* 置i为要筛选的节点 */
int i = ind;
/* c中保存i节点的左孩子 */
/* +1的目的就是为了解决节点从0开始而他的左孩子一直为0的问题 */
int c = i * 2 + 1;
while(c < len){/* 未筛选到叶子节点 */
/* 如果要筛选的节点既有左孩子又有右孩子并且左孩子值小于右孩子 */
/* 从二者中选出较大的并记录 */
if(c + 1 < len && a[c] < a[c + 1])
c++;
/* 如果要筛选的节点中的值大于左右孩子的较大者则退出 */
if(a[i] > a[c]) break;
else{
/* 交换 */
int temp = a[c];
a[c] = a[i];
a[i] = temp;
/* 重置要筛选的节点和要筛选的左孩子 */
i = c;
c = 2 * i + 1;
}
}
return;
}
void heap_sort(int n){
/* 初始化建堆, i从最后一个非叶子节点开始 */
for(int i = n / 2; i >= 0; i--)
adjust(i, n);
for(int j = 0; j < n; j++){
/* 交换 */
int t = a[0];
a[0] = a[n - j - 1];
a[n - j - 1] = t;
/* 筛选编号为0 */
adjust(0, n - j - 1);
}
}
时间复杂度nlog(n)。
6. 归并排序
描述：有两个有序序列，把它们合并成一个，很简单是吧。只要把比较两个序列第一个数的大小，然后取小的放到新的序列里，原来的序列中删除这个数，再比，直到一个序列的所有元素都空了，把另一个序列剩余的全都放过去。一个新的有序序列就成了～～，归并排序基于的就是这个原理，用分治法的思想，递归的排序出来。
实现：
View Code
void merge(int first, int mid, int last){/* 两个有序数组分别是a[first...mid]和a[mid+1...last] */
int temp[last - first + 1];/* 新的有序数组 */
int i, j, k=0;
for(i = first, j = mid + 1; i <= mid && j <=last ;){
if(a[i] < a[j]){
temp[k++] = a[i++];
}else{
temp[k++] = a[j++];
}
if(i == mid + 1){
while(j <= last)
temp[k++] = a[j++];
break;
}else if(j == last + 1){
while(i <=mid)
temp[k++] = a[i++];
break;
}
}
for(i = 0; i < k; i++)/* 把排好序的数组，放回这些数据该在的地方 */
a[first + i] = temp[i];
}
void merge_sort(int first, int last){
if(first < last){
int mid = (first + last) / 2;
/*传说中的分治法*/
merge_sort(first, mid);
merge_sort(mid + 1, last);
merge(first, mid, last);/* 合并 */
}
}
时间复杂度 O(n log n)，需要 O(n)的额外空间。
7. 基数排序
描述：原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。我理解的还是不够深。。。
实现：
View Code
/* 此代码来此维基百科，我没能写出来。。。 */
#include <iostream>
using namespace std;
const int base=10;
struct wx
{
int num;
wx *next;
wx()
{
next=NULL;
}
};
wx *headn,*curn,*box[base],*curbox[base];
void basesort(int t)
{
int i,k=1,r,bn;
for(i=1;i<=t;i++)
{
k*=base;
}
r=k*base;
for(i=0;i<base;i++)
{
curbox[i]=box[i];
}
for(curn=headn->next;curn!=NULL;curn=curn->next)
{
bn=(curn->num%r)/k;
curbox[bn]->next=curn;
curbox[bn]=curbox[bn]->next;
}
curn=headn;
for(i=0;i<base;i++)
{
if(curbox[i]!=box[i])
{
curn->next=box[i]->next;
curn=curbox[i];
}
}
curn->next=NULL;
}
void printwx()
{
for(curn=headn->next;curn!=NULL;curn=curn->next)
{
cout<<curn->num<<' ';
}
cout<<endl;
}
int main()
{
int i,n,z=0,maxn=0;
curn=headn=new wx;
cin>>n;
for(i=0;i<base;i++)
{
curbox[i]=box[i]=new wx;
}
for(i=1;i<=n;i++)
{
curn=curn->next=new wx;
cin>>curn->num;
maxn=max(maxn,curn->num);
}
while(maxn/base>0)
{
maxn/=base;
z++;
}
for(i=0;i<=z;i++)
{
basesort(i);
}
printwx();
return 0;
}
时间复杂度是 O(k*n)的，k是数字位数。
8. 计数排序
描述：这是我最喜欢的排序算法了，典型的用空间换时间的。一看代码就知道了。
实现：
void counting_sort(){ int i; int b[100001];/* 只能排序100000以下的数字 */ memset(b, 0 ,sizeof(b));/* 临时存储区 */ int max = -1; /* 记录需要排序的最大数 */ int min = 0xffffffff;/* 记录需要排序的最小数 */ for(i = 0; i < n; ++i){ b[a[i]]++;/* 核心的就这一句 */ max = a[i] > max ? a[i] : max; min = a[i] < min ? a[i] : min; } int k = 0; for(i = min ; i <= max; ++i){/* 按顺序将排序的数还原出来 */ while(b[i]--) a[k++]=i; } }
在k以内的数，时间复杂库为O(n)，O(n)有木有啊，还容易实现，我最喜欢了，就是太需要空间了。
9. bogo 排序
描述：这个排序是真的超神了，想象一下，把一副扑克向天上一扔，掉桌子上后收拾收拾，看看是不是顺序的，不是的话再扔。。。。
实现：真心不会。。。。
时间复杂度维基百科上说是其平均时间复杂度是 O(n × n!)，在最坏情况所需时间是无限。
据说在量子计算机里，这个算法是O(1)的，表示不明原理。
附上维基百科上排序的链接：https://zh.wikipedia.org/wiki/%E6%8E%92%E5%BA%8F
还有很多我没有听说过，根本不会的。。。继续努力吧
声明：
本文为 iddmx 对自己所学的排序算法的整理和实现。
本文档欢迎自由转载，但请务必保持本文档完整或注明来之本文档。本文档未经 iddmx 同意，不得用于商业用途。最后，如果您能从这个简单文档里获得些许帮助，iddmx 将对自己的一点努力感到非常高兴；iddmx 水平有限，如果本文档中包含的错误给您造成了不便，iddmx 在此提前说声抱歉。
祝身体健康，工作顺利。☺