第八章 排序技术

第八章  排序技术

1.排序的基本概念

（1）排序：给定一组记录的集合{r1, r2, ……, rn}，其相应的关键码分别为{k1, k2, ……, kn}，排序是将这些记录排列成顺序为{rs1, rs2, ……, rsn}的一个序列，使得相应的关键码满足ks1≤ks2≤……≤ksn（称为升序）或ks1≥ks2≥……≥ksn（称为降序）。

正序：待排序序列中的记录已按关键码排好序。

逆序（反序）：待排序序列中记录的排列顺序与排好序的顺序正好相反。

（2）排序算法的稳定性：

假定在待排序的记录集中，存在多个具有相同键值的记录，

若经过排序，这些记录的相对次序仍然保持不变，

即在原序列中，ki=kj且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。

（3）排序的分类-根据排序过程中所进行的基本操作分：

4.

（1） 基于比较：基本操作——关键码的比较和记录的移动，其最差时间下限已经被证明为O（nlog2n）。

（2）不基于比较：根据关键码的分布特征。比如，桶式排序，基数排序（多关键字排序）

基于比较的内排序：1. 插入排序2. 交换排序3. 选择排序4. 归并排序

不基于比较的内排序：1. 分配排序       2.桶式排序3.基数排序

5.

（1）.直接插入排序

基本思想：在插入第 i（i＞1）个记录时，前面的 i-1个记录已经排好序。

void  insertSort (int  r[ ], int n){

   for (i=2; i<=n; i++)   {

       r[0]=r[i]; j=i-1;

       while (r[0]<r[j])       { 

           r[j+1]=r[j];        

          j=j-1;     

        }

       r[j+1]=r[0];       

    }

}

（2）.希尔排序

改进的依据：

（1）若待排序记录按关键码基本有序时，直接插入排序的效率可以大大提高；

（2）由于直接插入排序算法简单，则在待排序记录数量n较小时效率也很高。

基本思想：

将整个待排序记录分割成若干个子序列，

在子序列内分别进行直接插入排序，

待整个序列中的记录基本有序时，对全体记录进行直接插入排序。

void Shellsort(int r[],int n){

  for (d=n/2; d>=1; d=d/2){

     for (i=d+1; i<=n; i++) {

              r[0]=r[i];           

              j=i-d;               

              while (j>0 && r[0]<r[j])

              {

                       r[j+d]=r[j];

                   j=j-d;         

               }

               r[j+d]=r[0];

         }

  }

}

（3）.起泡排序

基本思想：两两比较相邻记录的关键码，如果反序则交换，直到没有反序的记录为止。

void BubbleSort(int r[ ], int n)

{      

    exchange=n;

    while (exchange)

    {

        bound=exchange;

        exchange=0； 

        for (j=1; j<bound; j++)

            if (r[j]>r[j+1]) {

                r[j]←→r[j+1]；

               exchange=j；

            }

     }

 }

（4）.快速排序

首先选一个轴值

通过一趟排序将待排序记录分割成独立的两部分，

前一部分记录的关键码均小于或等于轴值，

后一部分记录的关键码均大于或等于轴值，

然后分别对这两部分重复上述方法，直到整个序列有序。

int Partition(int r[ ], int first, int end)

{      

    i=first; j=end;         //初始化

    r[0]=r[i];

     while (i<j)     

    { 

      while (i<j && r[0]<= r[j]) j--；  //右侧扫描

       if (i<j) {

          r[i]=r[j];   i++;  //将较小记录交换到前面

       }

       while (i<j && r[i]<= r[0]) i++；  //左侧扫描

       if (i<j) {

          r[j]=r[i];   j--;  //将较大记录交换到后面

       }

    }

    r[i]=r[0];

    retutn i;    //i为轴值记录的最终位置

}

void QuickSort (int  r[ ], int first, int end )

{

    pivotpos = Partition (r, first, end );  //一次划分 

   //对前一个子序列进行快速排序

    QuickSort (r, first, pivotpos-1);     

   //对后一个子序列进行快速排序

   QuickSort (r, pivotpos+1, end );

}

（5）.简单选择排序

基本思想：第i 趟在n-i+1（i=1,2,…,n-1）个记录中选取关键码最小的记录作为有序序列中的第i个记录。

void  selectSort ( int  r[ ], int n)

{  

    for ( i=1; i<n; i++)

    { 

        index=i;         

        for (j=i+1; j<=n; j++)

           if  (r[j]<r[index])  index=j;

        if (index!=i)   r[i]<==>r[index];  

    }

}

（6）.堆排序

基本思想：

1.首先将待排序的记录序列构造成一个堆(大顶堆)，

2.此时，选出了堆中所有记录的最大者，然后将它从堆中移走，

3.将剩余的记录再调整成堆，

4.这样又找出了次大的记录，以此类推，直到堆中只有一个记录。

void sift ( int r[ ], int k, int m )

{//要筛选结点的编号为k，堆中最后一个结点的编号为m

    i=k;  j=2*i;  temp=r[i];  //将筛选记录暂存

    while (j<=m )           //筛选还没有进行到叶子

    {

        if (j<m && r[j]<r[j+1]) j++;  //左右孩子中取较大者

        if (temp>r[j]) break;

        else {

             r[i]=r[j];   i=j;   j=2*i;

        }

     }

     r[i]=temp;   //将筛选记录移到正确位置

}

void  HeapSort ( int  r[], int n)

{

    for (i=n/2; i>=1; i--)      //初建堆

       sift(r, i, n) ;    

    for (i=1; i<n; i++ )

    {

       r[1]←→r[n-i+1];        //移走堆顶

       sift(r, 1, n-i);               //重建堆

    }

}

（7）二路归并排序

基本思想：

将一个具有n个待排序记录的序列看成是n个长度为1的有序序列，

然后进行两两归并，

得到n/2个长度为2的有序序列，

再进行两两归并，得到n/4个长度为4的有序序列，

……，

直至得到一个长度为n的有序序列为止。

void Merge (int r[ ], int r1[ ], int s, int m, int t )

{

    i=s;   j=m+1;   k=s;

    while (i<=m && j<=t)

    {  

        if (r[i]<=r[j])  r1[k++]=r[i++];

        else  r1[k++]=r[j++];

     }

     if (i<=m)  while (i<=m)              //收尾处理

                           r1[k++]=r[i++];    //前一个子序列

     else  while (j<=t)

                  r1[k++]=r[j++];             //后一个子序列

}

void  MergePass (int  r[ ], int  r1[ ], int  n, int  h)

{

     i=1;                 //第一个子序列的第一个元素

     while (i≤n-2h+1)                //情况1

     {

           Merge (r, r1, i, i+h-1, i+2*h-1);

           i+=2*h;

      }

      if (i＜n-h+1) Merge (r, r1, i, i+h-1, n);   //情况2

      else for (k=i; k<=n; k++)    //情况3

                 r1[k]=r[k];

}

（8）.基数排序

基数排序是典型的LSD排序方法，利用“分配”和“收集”两种运算对单关键码进行排序。

分配算法

void distribute(Node *first, int n, head *list,int d){

         Node *p,*q;    p=first;     int data, s,t;

         while(p)   {

                  data=p->data;

                  s=pow(10,d);t=s/10;data=data%s;data=data/t;

                  q=p->next;

                  if(     list[data].first)

                  {list[data].rear->next=p;        list[data].rear=p;}

                  else

                          list[data].first=list[data].rear=p;

                  list[data].rear->next=NULL;

                  p=q;

         }

}

收集算法

void collect( head *list, Node *&first,int m){

         int i=0,j;

         while(list[i].first==NULL)       i++;

         if(i>m) return;

         first=list[i].first;

         while(i<=m)     {

                  j=i+1;

                  while(list[j].first==NULL)        j++;

                  if(j>m) return;

                  list[i].rear->next=list[j].first;

                  i=j;

         }

}