数据结构：排序

数据结构：排序

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

 

在排序问题中，通常将数据元素称为记录

 

  

排序的基本概念

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

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

    趟：在排序过程中，将待排序的记录序列扫描一遍称为一趟。

    通常，一次排序过程需要进行多趟扫描才能完成

 

排序算法的性能

1.时间复杂性：基本操作。

内排序在排序过程中的基本操作：

(1)比较：关键码之间的比较；

(2)移动：记录从一个位置移动到另一个位置。

2.空间复杂性： 辅助存储空间。

辅助存储空间是指在数据规模一定的条件下，除了存放待排序记录占用的存储空间

之外，执行算法所需要的其他存储空间。

 

排序算法的存储结构

    从操作角度看，排序是线性结构的一种操作，待排序记录可以用顺序存储结构

    或链接存储结构存储。

   

插入类排序

    插入排序的主要操作是插入，

    其基本思想是：

    每次将一个待排序的记录按其关键码的大小插入到一个已经排好序的有序序列

    中，直到全部记录排好序为止。

插入类排序方法有以下两种：

    直接插入排序

    希尔排序

    

直接插入排序

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

需解决的关键问题:

（1）如何构造初始的有序序列？

解决方法：

将第1个记录看成是初始有序表，然后从第2个记录起依次插入到这个有序表中，直

到将第n个记录插入。

算法描述：

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

{

    插入第i个记录，即第i趟直接插入排序；

}

（2）如何查找待插入记录的插入位置?

解决方法：

在i-1个记录的有序区r[1] ~ r[i-1]中插入记录r[i]，首先顺序查找r[i]的正确插

入位置，然后将r[i]插入到相应位置。

算法描述：

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

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

{

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

   j--;

}

r[0]有两个作用：

1. 进入循环之前暂存了r[i]的值，使得不致于因记录的后移而丢失r[i]的内容；

2. 在查找插入位置的循环中充当哨兵。

直接插入排序算法:

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];    

    }

}

性能分析

   时间复杂度为O(n²)。

   

希尔排序

基本思想：

将整个待排序记录分割成若干个子序列，在子序列内分别进行直接插入排序，待整

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

需解决的关键问题:

（1）应如何分割待排序记录，才能保证整个序列逐步向基本有序发展？

解决方法：

将相隔某个“增量”的记录组成一个子序列。

增量应如何取？

希尔最早提出的方法是d1=n/2，di+1=di/2。

算法描述：

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

{

    以d为增量，进行组内直接插入排序；

}

（2）子序列内如何进行直接插入排序？

解决方法：

在插入记录r[i]时，自r[i-d]起往前跳跃式（跳跃幅度为d）搜索待插入位置，并且

r[0]只是暂存单元，不是哨兵。当搜索位置＜0，表示插入位置已找到。

在搜索过程中，记录后移也是跳跃d个位置。

在整个序列中，前d个记录分别是d个子序列中的第一个记录，所以从第d+1个记录开

始进行插入。

算法描述：

for (i=d+1; i<=n; i++)  //将r[i]插入到所属的子序列中

{

     r[0]=r[i];                     //暂存待插入记录

     j=i-d;                   

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

     {

          r[j+d]=r[j];       //记录后移d个位置

          j=j-d;            //比较同一子序列的前一个记录

      }

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

}

 

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];

    }

  }

}

 

交换排序

交换排序的主要操作是交换，其主要思想是：在待排序列中选两个记录，将它们的

关键码相比较，如果反序（即排列顺序与排序后的次序正好相反），则交换它们的

存储位置。

交换类排序的两种方法

    冒泡排序

    快速排序

    

冒泡排序   

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

止。

需解决的关键问题:

⑴ 在一趟起泡排序中，若有多个记录位于最终位置，应如何记载？

解决方法：

设变量exchange记载记录交换的位置，则一趟排序后，exchange记载的一定是这一

趟排序中记录的最后一次交换的位置，且从此位置以后的所有记录均已经有序。

算法描述：

 if （r[j]>r[j+1]）{

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

     exchange=j；

 }

⑵ 如何确定起泡排序的范围，使得已经位于最终位置的记录不参与下一趟排序？

解决方法：

设bound位置的记录是无序区的最后一个记录，则每趟起泡排序的范围是r[1]~r[bound]。

在一趟排序后，从exchange位置之后的记录一定是有序的，所以bound=exchange。

算法描述：

bound=exchange;

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

{

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

    {

         r[j]<==>r[j+1]；

         exchange=j；

    }

}   

⑶ 如何判别起泡排序的结束？

解决方法：

在每一趟起泡排序之前，令exchange的初值为0，在以后的排序过程中，只要有记录

交换，exchange的值就会大于0。这样，在一趟比较完毕，就可以通过exchange的值

是否为0来判别是否有记录交换，从而判别整个起泡排序的结束。

算法描述：

while (exchange)

{

    执行一趟起泡排序；

}

 

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；

            }

        }    

     }

 }

时间复杂度为O(n²)。

 

快速排序

基本思想:

首先选一个轴值（即比较的基准），

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

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

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

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

需解决的关键问题:

⑴如何选择轴值？

选择轴值的方法：

1.使用第一个记录的关键码；

2.选取序列中间记录的关键码；

3.比较序列中第一个记录、最后一个记录和中间记录的关键码，取关键码居中的作

为轴值并调换到第一个记录的位置；

4.随机选取轴值。

选取不同轴值的后果：

决定两个子序列的长度，子序列的长度最好相等。

⑵如何实现分割（称一次划分）？

    解决方法：

    设待划分的序列是r[s] ~ r[t]，设参数i，j分别指向子序列左、右两端的下标

    s和t，

    令r[s]为轴值，将轴值放入r[0]中。

    （1）j从后向前扫描，直到r[j]<r[0]，将r[j]移动到r[i]的位置，使关键码小

    （同轴值相比）的记录移动到前面去；

    （2）i从前向后扫描，直到r[i]＞r[0]，将r[i]移动到r[j]的位置，使关键码大

    （同轴值比较）的记录移动到后面去；

    （3）重复上述过程，直到i==j。

算法描述：

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 );

}

⑷如何判别快速排序的结束？

解决方法：

若待排序列中只有一个记录，显然已有序,排序结束；

否则进行一次划分后，再分别对分割所得的两个子序列进行快速排序（即递归处理）。

因此：递归的出口为first==end;

算法描述：

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

{//在序列 first~end中递归地进行快速排序

    if (first < end) {                    

          pivotpos = Partition (r, first, end );    

          QuickSort (r, first, pivotpos-1);

          QuickSort (r, pivotpos+1, end );

   }

}

  

选择排序

    选择排序的主要操作是选择，其主要思想是：每趟排序在当前待排序序列中选出

    关键码最小的记录，添加到有序序列中。

    1.简单选择排序

    2.堆排序

    

简单选择排序

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

序序列中的第i个记录。

需解决的关键问题:

⑴如何在待排序序列中选出关键码最小的记录？

解决方法：

设置一个整型变量index，用于记录在一趟比较的过程中关键码最小的记录位置。

算法描述：

index=i;          

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

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

⑵如何确定待排序序列中关键码最小的记录在有序序列中的位置？   

解决方法：

第i趟简单选择排序的待排序区间是r[i] ~ r[n]，则r[i]是无序区第一个记录，所

以，将index所记载的关键码最小的记录与r[i]交换。   

算法描述：

    if(index!=i)

        r[i]←→r[index];   

 

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];      

    }

}

 

堆排序

堆的定义：

堆是具有下列性质的完全二叉树：每个结点的值都小于或等于其左右孩子结点的值

（称为小根堆），或每个结点的值都大于或等于其左右孩子结点的值（称为大根堆）。

基本思想：

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;   //将筛选记录移到正确位置

}

需解决的关键问题：

⑴如何由一个无序序列建成一个堆（即初始建堆）？

算法描述：

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

    sift(r, i, n) ;  

⑵如何处理堆顶记录？

解决方法：

第1 次处理堆顶是将堆顶记录r[1]与序列中第？个记录

第2 次处理堆顶是将堆顶记录r[1]与序列中第？个记录

第 i 次处理堆顶是将堆顶记录r[1]与序列中第n-i+1个记录r[n-i+1]交换。

算法描述：

r[1]←→r[n-i+1];

⑶如何调整剩余记录，成为一个新堆（即重建堆）？

解决方法：

第 1 次调整剩余记录，此时，剩余记录有？个，调整范围？

第 i 次调整剩余记录，此时，剩余记录有n-i个，调整根结点至第n-i个记录。

算法描述：

sift(r, 1, n-i);

 

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);

    }

}

 

归并排序

归并：将两个或两个以上的有序序列合并成一个有序序列的过程。

主要思想是：将若干有序序列逐步归并，最终得到一个有序序列。

基本思想：

将一个具有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++];             //后一个子序列

}

⑵怎样完成一趟归并？

设参数i指向待归并序列的第一个记录，归并的步长是2h，

在归并过程中，有以下三种情况：

①相邻两个有序表的长度均为h (此时，i+2h-1<=n) ，执行一次归并，

此时，i≤n-2h+1，

完成后i加2h，准备进行下一次归并；

算法描述：

while (i≤n-2h+1)

{

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

     i+=2*h;

}

②仍有两个相邻有序表，一个长度为h，另一个长度小于h（i+h-1<n），

此时，i＜n-h+1

则执行两个有序表的归并，完成后退出一趟归并。

算法描述：

if (i＜n-h+1) Merge (r, r1, i, i+h-1, n);

③只剩下一个有序表(i+h-1>=n)，

i≥n-h+1

直接将该有序表送到r1的相应位置，完成后退出一趟归并。

算法描述：

if (i>=n-h+1)

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

        r1[k]=r[k];

一趟归并排序算法

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];

}

⑶如何控制二路归并的结束？

解决方法：

开始时，有序序列的长度h=1，

结束时，有序序列的长度h=n，

用有序序列的长度来控制排序的结束。

算法描述：

void  MergeSort (int r[ ], int r1[ ], int n )

{

    h=1;

    while (h<n)

    {

         MergePass (r, r1, n, h);

         h=2*h;

         MergePass (r1, r, n, h);

         h=2*h;

    }

}

 

归并排序的递归实现

void msort(int a[], int r[], int s, int t){

    if(s==t)

         return;              //如果只有一个数字则返回，无须排序

    int mid=(s+t)/2;

    msort(s,mid);                //分解左序列

    msort(mid+1,t);            //分解右序列

    int i=s, j=mid+1, k=s;   //接下来合并

    while(i<=mid && j<=t)  {

          if(a[i]<=a[j]) {

                r[k]=a[i];     k++; i++;

           }

          else {

               r[k]=a[j];  k++; j++;

          }

    }  

    while(i<=mid) {     //复制左边子序列剩余

           r[k]=a[i]; k++; i++;

       }

       while(j<=t)  {  //复制右边子序列剩余  

        

            r[k]=a[j]; k++; j++;

        }

        for(int i=s; i<=t; i++)

              a[i]=r[i];  

        return 0;

}

 

分配排序

基本思想:

先将数据分配到不同的桶中

再将桶中的数据收集到一起

两种方法:

桶式排序(单关键字排序)

链式基数排序（多关键字排序）

 

桶式排序

假设待排序的记录的值在0~m-1之间

设置m个桶，

依次扫描待排序的记录，R[1]，…，R[n-1]，把关键字等于k的记录全都装入到第k个箱子里(分配)，

然后按序号依次将各非空的箱子首尾连接起来(收集)。

顺序存储完成桶式排序

int main()

{

    int b[1001],n,i,j,m=0,x;

    memset(b,0,sizeof(b));        //初始化  

    cin>>n;

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

    {    

        cin>>x;     

        b[x]++;    //将等于x的值全部装入第x桶中  }

    for (i=0;i<=1000;i++)    //输出排序结果       

        if (b[i]>0) cout<<i<<“ ”<<b[i]<<endl; // 数值及其出现的次数  

        cout<<endl;

    return 0;

}

如何表示桶？即，如何存储具有相同关键字的记录

建立m个单链表(队列)，将值为m的记录存放到第m个单链表中（队列）

可以建立静态链表，也可以建立动态链表动态链表中节点的定义

struct Node{

   int key;

   Node * next;

}

分配操作如何进行？

分配操作是将数据插入到表示桶的一个队列中，即分配操作为入队操作

分配算法

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

    Node *p,*q;

    p=first;    int data;

    while(p)    {

        data=p->data;  //桶的编号

        q=p->next;   

        if(list[data].first)

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

        else

            list[data].first=p;

        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;

    }

}

桶式排序算法

int  main(){

    Node *s,*first;    head *list;

    int m;cin>>m;

    list=new head[m];

    for (int i=0;i<=m;i++){

        list[i].first=NULL;    list[i].rear=NULL;}

    int n;

    cin>>n;

    first=NULL;

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

    {    s=new Node;    cin>>s->data;    s->next=first;    first=s;    }

    distribute(first,n,list);

    collect(list,first,m);

    Node *p=first;

    while(p){

        cout<<p->data<<"\t";    p=p->next;    }

    cout<<endl;

    return 0;

}

 

基数排序

基本思想

从关键字的最“低位”开始，将关键字分配到r(基数）个堆（桶）中；

按桶的编号将关键字收集起来；

然后，以“次低位”将关键字又分配到r个桶中；再收集，……，重复直到“最高位”为止

，这时，以按关键字有序。

基数排序的分配算法

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;

    }

}

基数排序算法

    ……

    int d;

    cout<<"Please input the size of a data:";

    cin>>d;

    for(i=1;i<=d;i++) //处理每一“位”（个位、十位...）

    {

        distribute(first,n,list ,i);

        collect(list,first,m);

        for (int i=0;i<=m;i++)

        {

            list[i].first=NULL;    

            list[i].rear=NULL;    

        }

}

 

对排序算法应该从以下几个方面综合考虑：

⑴时间复杂性；

⑵空间复杂性；

⑶稳定性；

 

稳定性比较

所有排序方法可分为两类，

（1）一类是稳定的，包括直接插入排序、起泡排序、和归并排序，基数桶式排序；

（2）另一类是不稳定的，包括直接选择排序、希尔排序、快速排序和堆排序。

 

算法简单性比较

从算法简单性看，

（1）一类是简单算法，包括直接插入排序、直接选择排序和起泡排序，

（2）另一类是改进后的算法，包括希尔排序、堆排序、快速排序、归并排序和基数排序，这些算法都很复杂。