排序算法初步总结

       排序算法按照不同的原则可以分为不同的类。如根据排序的稳定性可以分为稳定排序和不稳定排序；根据排序过程所涉及到的存储器分为内部排序和外部排序等等。这里将根据排序采用的策略进行分类，可分为：插入排序、交换排序、选择排序、归并排序和基数排序等。

插入排序

  插入排序中最简单和基础的是直接插入排序和希尔排序。

1.直接插入排序

  基本思想：依次取出原始序列中元素，然后将其有序插入有序的序列中。

  特征：设置监视哨，其作用一方面是在循环中监视下标是否越界，省略了设置循环判断条件；另一方面在进入循环之前可以作为缓冲区域，这样可以保证记录的后移不会失去原值。

  code：时间复杂度O(n^2),空间复杂度O(1),稳定排序。

void InsertSort(NOde list[],int n){    int i,j;    for(i=1;i<n;i++){        list[0]=list[i]; //设置监视哨</span><span style="font-family:SimSun;font-size:14px;">list[0]</span><span style="font-size:18px;">        j=i-1;        while(list[0]<list[j]){//当前值小于前面的值，则记录后移，直到正确位置            list[j+1]=list[j];            j--;        }        list[j+1] = list[0];//找到正确位置后将list[0]的原记录值插入    }}

2.希尔排序

基本思想：又称为缩小增量排序，是对直接插入排序的一种改进排序。其先将整个待排序列分割成若干子序列，分别对子序列进行直接插入排序，等到整个序列中的记录基本有序时，再对整个序列进行一次直接插入排序。

特征：其对增量序列的选择没有严格要求，一般而言，对于n个序列，可以选择分组数依次为d1=n/2,d2=d1/2,d3=d2/2,...,di=1。

code：时间复杂度O(nlog2(n))-O(n^2),不稳定排序。

<span style="font-size:14px;">void ShellSort(NOde list[],int n){    int i,j,d;    for(d=n/2;d>0;d=d/2){//初始增量为n/2，每次缩小增量为d/2        for(i=d+1;i<=n;i++){            list[0]=list[i]; //设置监视哨            j=i-d;   //前后记录增量为d,而不是1            while(j>=0 && list[0]<list[j]){//当前值小于前面的值，则记录后移，直到正确位置                list[j+d]=list[j];                j-=d;            }            list[j+1] = list[0];//找到正确位置后将list[0]的原记录值插入        }    }}</span>

交换排序

  交换排序中最典型的两个是冒泡排序和快速排序。

1.冒泡排序

  基本思想：冒泡排序是最直观的一种排序方法，其排序过程中，相邻的两个元素进行比较，若前面的值大于后边的值则进行交换，否则则不交换。或者是较大值的前移。

  特征：设置中间变量，进行数据存储。

  code：时间复杂度O(n^2),稳定排序。

<span style="font-size:14px;">void Bubble_sort(NOde list[],int n){    int i,j,temp;    for(i=0;i<n;i++){        temp=0;  //交换标志变量，初始化为未交换        for(j=0;j<n;j++){            if(list[j]>list[j+1]){//前者大于后者则交换                list[0]=list[j+1];                list[j+1]=list[j];                list[j]=list[0];                temp=1;            }        }        if(temp==0) break; //未交换，排序结束    }}</span>

2.快速排序

基本思想：快速排序是对冒泡的一种改进，不同之处在于冒泡每次的比较和交换都是在相邻的单元进行的，只能左移或右移一个单元。而快排比较和交换式从两端向中间进行，大大减少了比较和移动的次数。

特征：任取序列中的某个数据作为基准线，通过一次的排序，将原始序列分为两个子序列，左子序列小于或等于该基准线，右子序列大于或等于该基准线，然后一次循环，直到最后排成有序序列。

code：时间复杂度O(nlog2(n)),不稳定排序。

int Partition(NOde list[],int low,int high){    list[0]=list[low];    while(low<high){        while(low<high && list[high]>=list[0])//在high端寻找一个比list[low]小的记录放入low            --high;        list[low]=list[high];        while(low<high && list[high]<=list[0])//在low端寻找一个比list[low]大的记录放入high            ++low;        list[high]=list[low];    }    list[low]=list[0];    return low;//返回基准线位置}void Quick_sort(NOde list[],int low,int high){    int loc;    if(low<high){        loc=Partition(list,low,high);//进行快排        Quick_sort(list,low,loc-1);//对前半区域进行划分        Quick_sort(list,loc+1,high);//对后半区域进行划分    }}

选择排序

  选择排序中分为简单选择排序和堆排序。

1.简单选择排序

  基本思想：顾名思义，即首先选择最小的数据放在第一个位置，再选取次小的数据放在第二个位置，以此类推，直至选出n-1个为止。

  特征：选取每次的最小值min。

  code：时间复杂度O(n^2),不稳定排序。

<span style="font-size:14px;">void Select_sort(NOde list[],int n){    int i,j,min;    for(i=0;i<n;i++){        min=i;        for(j=i+1;j<=n;j++){//在i-n的范围内寻找            if(list[min]>list[j])                min=j;            if(min!=j){                list[0]=list[min];                list[min]=list[i];                list[i]=list[0];            }        }    }}</span>

2.堆排序

基本思想：堆排序是利用堆特性进行排序的，根据其性质可知，堆的根为整个序列的最大值或最小值，因此将原始序列进行建堆，再对输出堆顶原始后进行维护，可以实现堆排序。

特征：建堆以及堆维护。

code：时间复杂度O(nlog2(n)),不稳定排序。

void Createtheap(NOde list[],int m,int n){    int i,j,flag;    i=m;j=2*i;    list[0]=list[i];    flag=0;    while(j<=n && flag!=1){//沿值较小的分支向下筛选        if(j<n && list[j]>list[j+1])//选取孩子中值较小的分支            j++;        if(list[0]<list[j])            flag=1;        else{//继续向下筛选            list[i]=list[j];            i=j;            j=2*i;            list[i]=list[0]        }    }}void Heap_sort(NOde list[],int n){    for(int i=n/2;i>=1;i--)//初始化堆        Createtheap(list,i,n);    for(int i=n;i>=1;i--){//list[1]为堆顶元素，可以设置循环输出        list[1]=list[i];//将堆尾元素移至堆顶        Createtheap(list,1,i);//整理堆    }}

归并排序

  归并排序可分为多路归并排序和二路归并排序。这里只对二路归并排序进行总结。

1.二路归并排序

  基本思想：将原始序列分为若干子序列，先将每个子序列进行排序，再将已排序的子序列进行合并，得到完整排序序列。

  特征：先将排序长度设置为1，然后两两归并为n/2个子序表，依次下去，直到长度为n的有序表。

  code：时间复杂度O(nlog2(n)),空间复杂度O(n),稳定排序。

<span style="font-size:14px;">void Merge(NOde a[],NOde b[],int i,int m,int n){    int la,lb,lc;    la=i;lb=m+1;lc=i;   //序列la,lb,lc的始点    while(la<=m && lb<=n){        if(a[la]<a[lb])   //有序合并            b[lc++] = a[la++];        else b[lc++] = a[lb++];    }    while(la<=m)   //复制第一个序列中剩下的元素        b[lc++] = a[la++];    while(lb<=n)  //复制第二个序列中剩下的元素        b[lc++] = a[lb++];}void MergPass(NOde list[],NOde A[],int n,int c){    int i=0,j;    while(i+2*c-1<=n-1){  //长度均为c的两个子序列合并为一个序列        Merge(list,A,i,i+c-1,i+2*c-1);        i+=2*c;    }    if(i+c-1<n)  //长度不相等的两个子序列合并为一个序列        Merge(list,A,i,i+c-1,n-1);    else  //只剩一个序列时直接复制到A中        for(j=i;j<=n-1;j++)            A[j]=list[j];}void Merge_sort(NOde list[],int n){    int c=1;  //初始归并长度为1    NOde A[MAXN];  //需要一个辅助空间    while(c<n){        MergPass(list,A,n,C);  //一次合并，结果写入A中        c*=2;   //序列长度扩大一倍        MergPass(A,list,n,C);  //再次合并，结果写入list中        c*=2;    }}</span>

其它排序

更新ing...