第五章

定义

排序是将一些需要排序的数按指定的顺序摆放好，比如，从大到小，大小到大都是。

基本排序：

基本排序包括冒泡排序、选择排序、直接插入排序等。

冒泡排序：

泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较

两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行

直到没有相邻元素需要交换，也就是说该元素列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换

慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡

排序”。他是一个稳定的排序算法，时间复杂度不受数据的限制，时间复杂度为O( N ² )。

void pxfun1(int a[],int n)
{
 int i,j,t;
 for(int i=0;i<n-1;i++)
  for(int j=0;j<n-1-i;j++)
   if(a[j]>a[j+1])//升大降小 
   {
    t=a[j];
    a[j]=a[j+1];
    a[j+1]=t;
   }
}

选择排序：

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小

（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到

已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。时间复

杂度选择排序的交换操作介于 0 和 (n - 1） 次之间。选择排序的比较操作为 n (n - 1） / 2 次之间。选择排序的赋值

操作介于 0 和 3 (n - 1） 次之间。比较次数O(n^2），比较次数与关键字的初始状态无关，总的比较次数

N=(n-1）+(n-2）+…+1=n*(n-1）/2。交换次数O(n），最好情况是，已经有序，交换0次；最坏情况交换n-1次，逆

序交换n/2次。交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CPU时间多，n值较小时，选择排

序比冒泡排序快。

void pxfun2(int a[],int n)
{
 int i,j,t;
 for(int i=0;i<n-1;i++)
  for(int j=i+1;j<n;j++)
   if(a[i]>a[j])//升大降小 
   {
    t=a[j];
    a[j]=a[i];
    a[i]=t;
   }
}

直接插入排序：

插入排序（Insertion sort）是一种简单直观且稳定的排序算法。如果有一个已经有序的数据序列，要求在这个已经

排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入

排序法,算法适用于少量数据的排序，时间复杂度O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部

分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二

部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部

分中。是一种稳定的排序，时间复杂度稳定在O( N² )。

void pxfun3(int a[],int n)
{
 int i,j,t;
 for(int i=1;i<n;i++)
 {
  t=a[i];
  for(int j=i-1;j>=0&&a[j]>k;j--)a[j+1]=a[j];
  a[j+1]=t;
 }
}

希尔排序：

就是在直接插入排序的基础上以间隔为1以上的排序，然后再以间隔为1的排序，其时间复杂度在O( N^1.5~2 ）。

void pxfun4(int a[],int n,int d)//d为增量 
{
    int i,j,temp;
    for(i=d;i<n;i++)//分别向每组的有序区域插入
    {
        temp=a[i];
        for(j=i-d;(j>=i%d)&&a[j]>temp;j-=d)//比较与记录后移同时进行
            a[j+d]=a[j];//此处你可以将d用插入排序中的1来理解 
        if(j!=i-d)
            a[j+d]=temp;//插入
    }
}

桶排：

桶排序 (Bucket sort)或所谓的箱排序，是一个排序算法，工作的原理是将数组分到有限数量的桶子里。每个桶子再

个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳

结果。当要被排序的数组内的数值是均匀分配的时候，桶排序使用线性时间 O( n )。属于稳定排序，排序时间不受

数据影响。但是受数据大小的影响是否可以使用桶排序。数据大一点就不可以使用桶排序。

void pxfun6(int a[],int n)
{
    int p[1000000]={0},m=0;
    for(int i=0;i<n;i++)
    {
     p[a[i]]++;
     m=max(a[i],m);
 }
    for(int i=0;i<=m;i++)
    {
     while(p[i])printf("%d ",i);//有一个输出一个 
 }
}

快速排序：

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所

有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数

据变成有序序列。快速排序是不稳定的排序，最好为O( n log(n)) 最坏为O( n² )。

void sort(int a[], int left, int right)
{
    if(left >= right)
    {
        return ;
    }
    int i = left;
    int j = right;
    int key = a[left];
    while(i < j)                            
    {
        while(i < j && key <= a[j])
        {
            j--;
        }
        a[i] = a[j];
        while(i < j && key >= a[i])
        {
            i++;
        }    
        a[j] = a[i];
    }
    a[i] = key;
    sort(a, left, i - 1);
    sort(a, i + 1, right);
}

归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and

Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使

子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序是一种稳定的排序方法。其时间复

杂度为O( nlog(n) )。

#include<stdio.h>
void hbfun(int a[],int b[],int front,int mid,int last)
{ //合并函数 
 int i,j,k;
 for(i=front,j=mid+1,k=0;i<=mid&&j<=last;)
 {
  if(a[i]<=a[j])b[k++]=a[i++];
  else
  {
   b[k++]=a[j++];
  }
 }
 while(i<=mid)b[k++]=a[i++];
 while(j<=last)b[k++]=a[j++];
 for(i=front,j=0;j<k&&i<=last;)//原位放回去 
  a[i++]=b[j++];
}
void gbfun(int a[],int b[],int i,int j)
{ //递归函数 
 if(i>=j)return ;//只有一个的时候 
 else
 {
  int mid=(i+j)/2;//取中间点 
  gbfun(a,b,i,mid);//前半部分 
  gbfun(a,b,mid+1,j);//后半部分 
  hbfun(a,b,i,mid,j);//将前后部分合并 
 }
}
int main()
{
 int n;
 while(~scanf("%d",&n))
 {
  int a[100010];//存储输入的数 
  int b[100010];//用来合并需要所开的空间 
  int i,j,k;
  for(i=0;i<n;i++)scanf("%d",&a[i]);
  gbfun(a,b,0,n-1);
  for(i=0;i<n;i++)printf("%d",a[i]);
  printf("\n");
 }
}