数据结构之常用排序算法的对比分析

数据结构之常用排序算法的对比分析

 

1．实验题目

      各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。试通过随机的数据比较各算法的关键字比较次数和关键字移动次数，以取得直观感受。

2．需求分析

      本程序用C++编写，完成了记录表的随机生成，输出记录了表的功能，各种内部排序算法的实现，计算每种排序中关键字的移动次数和比较次数。

        ①输入的形式和输入值的范围：本程序不支持用户的自定义输入，程序中定义开始的循序表的长度为100，1000，10000，100000,1000000。表中的关键字由随机函数随机生成。

        ②输出的形式：分别输出当前数量级以及各种排序方法的排序时间、移动次数、比较次数。

        ③程序所能达到的功能：计算每种排序所执行的时间、关键字移动的次数、关键字比较的次数。

        ④测试数据：由随机产生器决定。

3．概要设计

      1）为了实现上述程序功能，需要定义待排序记录表的抽象数据类型：

            ADT RedList{

           数据对象：D={ri|ri∈sq，i=1，2，⋯，n，n≥0}

           数据关系：R={<ri,ri+1>|ri,ri+1∈D}

           基本操作：

           CreateNum()

           操作结果：创建一个随机数生成的数组。

           sq init()

           初始条件：存在一个随机数生成的数组。

           操作结果：创建一个顺序表，并将随机函数生成的数组值赋值给关键字。

           InsertSort(sq &L)

           初始条件：顺序表L存在

           操作结果：将顺序表用直接插入排序拍成有序序列，输出关键字移动次数，比较次数。

           ShellInsert(sq &L,int dk)

           初始条件：顺序表L，增量dk存在

           操作结果：将全部记录分成dk个组，所有间隔为dk的记录分到同一组，各组内为有序序列，记录关键字的涌动次数各比较次数。

           ShellSort(sq &L,int t)

           初始条件：顺序表L存在，增量的个数t存在，ShellInsert(sq &L,int dk)函数存在。

           操作结果：将无序表用希尔排序排列为有序序列，记录关键字的移动次数，比较次数Partition(sq &L,int low,int high)

           初始条件：顺序表L存在，low和high存在

           操作结果：返回顺序表L中子表r[low..high]的枢轴位置，记录关键字移动次数，比次数，枢轴前的关键字小于枢轴关键字，枢轴后的关键字大于枢轴关键字QSort(sq &L,int low,int high)

           初始条件： 顺序表L存在，low和high存在，Partition(sq &L,int low,int high)函数存在。

           操作结果：将无序表排列为有序表。

           QuickSort(sq &L)

           初始条件：Partition(sq &L,int low,int high)，QSort(sq &L,int low,int high)函数存在，顺序表L存在。

           操作结果：无序表为有序表。

           BubbleSort(sq &L)

           初始条件：顺序表L存在

           操作结果：将无序表用冒泡排序法排序为有序序列，记录关键字移动次数，比较次数SelectSort(sq &L)

           初始条件：顺序表L存在

           操作结果：将无序表用简单选择排序法排序为有序序列，记录关键字移动次数，比较次数

           HeapAdjust(sq &L,int s,int m)

           初始条件：顺序表L存在，整数s，m存在。

           操作结果：将r[s..m]调整为以r[s]为根的大根堆。记录关键字移动次数，比较次数。CreatHeap(sq &L)

           初始条件：顺序表L存在，HeapAdjust(sq &L,int s,int m)函数存在。

           操作结果：将无序序列调整为大根堆

           HeapSort(sq &L)

           初始条件：顺序表L存在，HeapAdjust，CreatHeap两个函数存在。

           操作结果：将顺序表L进行堆排序，排序为有序序列，记录关键字移动次数，比较次数。show(sq L)

           初始条件：顺序表L存在

           操作结果：输出顺序表L

           }

2）本程序包含14个函数：

           ①主函数main()

           ②随机数函数CreateNum()

           ③构造顺序表函数 init()

           ④直接插入排序函数InsertSort（）

           ⑤增量为dk的希尔排序ShellInsert()

           ⑥增量为d[t]的希尔插入排序函数ShellSort()

           ⑦返回顺序表L中的子表r[low..high]枢轴函数Partition()

           ⑧对顺序表L中的子序列L.r[low..high]做快速排序函数QSort()

           ⑨对顺序表L做快速排序函数QuickSort()

           ⑩冒泡排序函数BubbleSort()

           ⑪简单选择排序函数SelectSort()

           ⑫筛选法调整堆函数HeapAdjust（）

           ⑬初建堆函数CreatHeap（）

           ⑭堆排序函数HeapSort（）

4．详细设计

      实现概要设计中定义的所有的数据类型，对每个操作给出伪码算法。对主程序和其他模块也都需要写出伪码算法。

      1) 结点类型和指针类型

 typedef struct{

    int len;

    ElemType *r；

}sq;//顺序表

2）其他模块伪码算法

void CreateNum(){

       srand((unsigned)time(NULL));//产生随机数

       for(int i=1;i<=maxn;i++){

        N[i]=rand()%MAXN;对一个数组进行赋值}

}//随机数函数

sq init(){

      sq L;

      L.len=maxn;//对顺序表中的key进行赋值

      L.r=new ElemType[maxn+1];

      for(int i=1;i<=maxn;i++){

        L.r[i].key=N[i];}

      return L;

}//构造顺序表

void InsertSort(sq &L){

      int j;

      将第一关键字作为有序序列，分别将之后的关键字插入到该序列中，插入到最后一个大于它的关键字前。

      有key的比较L.r[i].key<L.r[i-1].key就产生一次关键字的比较InsertComp++;

      有对顺序表中赋值语句L.r[i].key=L.r[j].key;出现就有关键字移动。

用for语句将所有关键字进行排序。

}

void ShellInsert(sq &L,int dk){

      int i,j;

      用for循环进行分组   

ShellComp++;与所有排序函数中一样，出现L.r[i].key<L.r[i-dk].key，关键字比较次数增加一次

      分组时进行组内排序，记录关键字移动次数和比较次数

}//希尔插入排序

  void ShellSort(sq &L,int t){//5 3 1 -> t=3   7 5 3 1 -> t=4

      int dt[100];

用for循环和dt[j]=-2*j+t+2语句取出所有的增量。

      用for取遍所有增量的希尔排序

}//增量为dt[t]的希尔插入排序

int Partition(sq &L,int low,int high){

     对顺序表L中的子表r[low..high]进行一趟排序，返回枢轴位置

用子表的第一个记录做枢轴记录

枢轴记录关键字保存在pivotkey中

从表的两端交替地向中间扫描

将比枢轴记录小的记录移到低端

将比枢轴记录大的记录移到高端

重新定义枢轴记录，用子表的第一个记录做枢轴记录

返回枢轴位置

}//Partition

 void QSort(sq &L,int low,int high){

调用前置初值：low=1; high=L.length;

对顺序表L中的子序列L.r[low..high]做快速排序

将L.r[low..high]一分为二，pivotloc是枢轴位置

      对左子表递归排序

      对右子表递归排序

}  

void QuickSort(sq &L){

    //对顺序表L做快速排序

    QSort(L,1,L.len);

 }

void BubbleSort(sq &L){

    for(int i=1;i<L.len;i++){

        for(int j=1;j<=L.len-i;j++){

            BubbleComp++;

            if(L.r[j+1].key<L.r[j].key) {

                swap(L.r[j+1],L.r[j]);

                BubbleMove+=2;

            }

        }

    }  

}//冒泡排序

void SelectSort(sq &L)

{

    在L.r[i..L.len]中选择关键字最小的的记录

将记录表的第一个元素与最小记录元素位置互换，直到排序完毕

}//简单选择排序

void HeapAdjust(sq &L,int s,int m)//筛选法调整堆

{ 假设r[s+1..m]已经是堆，将r[s..m]调整为以r[s]为根的大堆根

沿key较大的孩子结点向下筛选

if(j<m&&L.r[j].key<L.r[j+1].key) ++j;//j为key较大的记录的下标

    HeapComp++;

    if(rc.key>=L.r[j].key) break;        //rc应插入在位置s上

    L.r[s]=L.r[j];

    HeapMove++;

    s=j;                                

    L.r[s]=rc;

    HeapMove++;     //插入

}

void CreatHeap(sq &L)                       //建初堆

{  

反复调用HeapAdjust，将无序序列建成大根堆

}

void HeapSort(sq &L)        //堆排序

{

      CreatHeap(L);           //建成大堆根

      用for循环交换堆定元素和最后一个记录。

      将堆顶记录和当前未经排序子序列L.r[1..i]中最后一个记录互换

      HeapAdjust(L,1,i-1);//重新调整为大根堆

    }

void show(sq L){

     for(int i=1;i<=L.len;i++)

     cout<<L.r[i].key<<' ';

     puts("");输出记录的关键字

}//输出函数

5．调试分析

      将计算比较次数语句放在了if语句前，否则会忽略if语句中在不满足条件时一次关键字比较

6．使用说明

      系统随机产生数据，并进行各项排序。

7．测试结果

       

 8．附代码

// 实验六.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"


#include<iostream>
using namespace std;

#include   <stdlib.h>    
#include   <time.h> //随机数的头文件
#define MAXN 100000000
int maxn;
int N[MAXN+5];
//        Compare 比较次数          Move 移动次数 
long long InsertMove,InsertComp,
    BInsertMove,BInsertComp,
    QComp,QMove,
    BubbleComp,BubbleMove,
    ShellComp,ShellMove,
    SelectComp,SelectMove,
    HeapComp,HeapMove;
 
typedef struct{
    int key;
    //int m;
}ElemType;//记录类型
 
typedef struct{
    int len;
    ElemType *r;//*r 与 r[MAXNSIZE]有区别
}sq;//顺序表
 
void CreateNum(){
    srand((unsigned)time(NULL));
    for(int i=1;i<=maxn;i++){
        N[i]=rand()%MAXN;
    }
}//随机数函数
 
sq init(){
    sq L;
    L.len=maxn;
    L.r=new ElemType[maxn+1];
    for(int i=1;i<=maxn;i++){
        L.r[i].key=N[i];
    }
    return L;
}//构造顺序表
 
void InsertSort(sq &L){
    int j;
    for(int i=2;i<=L.len;i++){
        InsertComp++;
        if(L.r[i].key<L.r[i-1].key){
            L.r[0].key=L.r[i].key;
            InsertMove++;
            for(j=i-1;L.r[j].key>L.r[0].key;j--,InsertComp++){
                L.r[j+1].key=L.r[j].key;
                InsertMove++;
            }
            L.r[j+1].key=L.r[0].key;
            InsertMove++;
        }
    }
}//直接插入排序，两个关键字的比较不等式出现 比较次数加1，有关键字的赋值语句就有一次移动。
 
/*void BInsertSort(sq &L){
    int j,l,r,temp;
    for(int i=2;i<=L.len;i++){
        temp=L.r[i].key;
        l=1,r=i-1;
        while(l<=r){
            int m=(l+r)/2;
            if(temp<L.r[m].key) r=m-1;
            else l=m+1;
            BInsertComp++;
        }
        for(j=i;j>=l+1;j--) {
            L.r[j].key=L.r[j-1].key;//L.r[j]=L.r[j-1];
            BInsertMove++;
        }
        L.r[l].key=temp;
        BInsertMove++;
    }
}//折半插入排序*/
 
void ShellInsert(sq &L,int dk){
    int i,j;
    for(i=dk+1;i<=L.len;i++){
        ShellComp++;
        if(L.r[i].key<L.r[i-dk].key){
            L.r[0]=L.r[i];
            ShellMove++;
            for(j=i-dk;j>0&&L.r[0].key<L.r[j].key;j-=dk,ShellComp++){
                L.r[j+dk]=L.r[j];
                ShellMove++;
            }        
            L.r[j+dk]=L.r[0];
            ShellMove++;
        }
    }
}//希尔插入排序
 
void ShellSort(sq &L,int t){//5 3 1 -> t=3   7 5 3 1 -> t=4
    int dt[100];
    for(int j=0;j<t;j++){ 
    /*
    3 0 5 5
    3 1 3 5
    3 2 1 5
    */
        dt[j]=-2*j+t+2;
    }
     for(int i=0;i<t;i++)
         ShellInsert(L,dt[i]);
}//增量为dt[t]的希尔插入排序
 
int Partition(sq &L,int low,int high){
    //对顺序表L中的子表r[low..high]进行一趟排序，返回枢轴位置
    int pivotkey;
    L.r[0]=L.r[low];                        //用子表的第一个记录做枢轴记录
    pivotkey=L.r[low].key;                       //枢轴记录关键字保存在pivotkey中
    while(low<high)    {                                        //从表的两端交替地向中间扫描
        while(low<high&&L.r[high].key>=pivotkey) --high,QComp++;
        L.r[low]=L.r[high],QMove++;                //将比枢轴记录小的记录移到低端
        while(low<high&&L.r[low].key<=pivotkey) ++low,QComp++;
        L.r[high]=L.r[low],QMove++;                    //将比枢轴记录大的记录移到高端
        
    }//while
    L.r[low]=L.r[0];                        //枢轴记录到位
    return  low;                            //返回枢轴位置
}//Partition
 
void QSort(sq &L,int low,int high){    //调用前置初值：low=1; high=L.length;
    //对顺序表L中的子序列L.r[low..high]做快速排序
    int pivotloc;
    if(low<high){                                        //长度大于1
       pivotloc=Partition(L,low,high);         //将L.r[low..high]一分为二，pivotloc是枢轴位置
       QSort(L,low,pivotloc-1);                //对左子表递归排序
       QSort(L,pivotloc+1,high);            //对右子表递归排序
    }
}                                            //QSort
 
void QuickSort(sq &L){
    //对顺序表L做快速排序
   QSort(L,1,L.len);
}                                            //QuickSort
 
void BubbleSort(sq &L){
    for(int i=1;i<L.len;i++){
        for(int j=1;j<=L.len-i;j++){
            BubbleComp++;
            if(L.r[j+1].key<L.r[j].key) {
                swap(L.r[j+1],L.r[j]);
                BubbleMove+=2;
            }
        }
    }    
}//冒泡排序
 
void SelectSort(sq &L)
{
    for(int i=1;i<L.len;i++)
    {
        int k=i;
        for(int j=i+1;j<=L.len;j++)
        {
            SelectComp++;
            if(L.r[j].key<L.r[k].key)
            {
                k=j;
            }
        }
        if(k!=i)
        {
            ElemType t=L.r[i];
            L.r[i]=L.r[k];
            L.r[k]=t;
            SelectMove+=2;
        }
    }
}//简单选择排序

void HeapAdjust(sq &L,int s,int m)//筛选法调整堆
{//假设r[s+1..m]已经是堆，将r[s..m]调整为以r[s]为根的大堆根
    ElemType rc=L.r[s];
    for(int j=2*s;j<=m;j*=2)                 //沿key较大的孩子结点向下筛选
    {
        HeapComp++;
        if(j<m&&L.r[j].key<L.r[j+1].key) ++j;//j为key较大的记录的下标
        HeapComp++;
        if(rc.key>=L.r[j].key) break;        //rc应插入在位置s上
        L.r[s]=L.r[j];
        HeapMove++;
        s=j;                                 
    }
    L.r[s]=rc;
    HeapMove++;     //插入
}

void CreatHeap(sq &L)                       //建初堆
{//将无序序列建成大根堆
    int n=L.len;
    for(int i=n/2;i>0;--i)
    {
        HeapAdjust(L,i,n);                //反复调用HeapAdjust
    }
}

void HeapSort(sq &L)        //堆排序
{
    CreatHeap(L);           //建成大堆根
    for(int i=L.len;i>1;--i)
    {
        ElemType x=L.r[i];   //将堆顶记录和当前未经排序子序列L.r[1..i]中最后一个记录互换
        L.r[1]=L.r[i];
        L.r[i]=x;
        HeapMove+=2;
        HeapAdjust(L,1,i-1);//重新调整为大根堆
    }
}

void show(sq L){
    for(int i=1;i<=L.len;i++)
        cout<<L.r[i].key<<' ';
    puts("");
}//输出函数
 
int main(){
    int temp=100;
    for(int i=1;i<=5;i++)
    {//100~1000000
        InsertMove=0,InsertComp=0,
        BInsertMove=0,BInsertComp=0,
        QComp=0,QMove=0,
        BubbleComp=0,BubbleMove=0,
        ShellComp=0,ShellMove=0; 
        maxn=temp;
        cout<<"当前数量级是"<<temp<<endl;  
        CreateNum();//生成一组随机数
        sq L=init();
        double s=clock();//C++里面提供了一个clock()函数(它被<time.h>头文件收录)可以用于计算程序某个环节运行时间
        InsertSort(L);
        double e=clock();
        if(temp==100)
            show(L);
        cout<<"直接插入排序时间是"<<e-s<<"ms"<<endl;
        cout<<"直接插入移动次数是"<<InsertMove<<endl;
        cout<<"直接插入比较次数是"<<InsertComp<<endl<<endl;
        
       /* L=init();//还原无序的顺序表
        s=clock();
        BInsertSort(L);
        e=clock();
        cout<<"二分插入排序时间是"<<e-s<<"ms"<<endl;
        cout<<"二分插入移动次数是"<<BInsertMove<<endl;
        cout<<"二分插入比较次数是"<<BInsertComp<<endl<<endl;*/
        
        L=init();//还原无序的顺序表
        s=clock();
        QuickSort(L);
        e=clock();
        if(temp==100)
            show(L);
        cout<<"快排时间是"<<e-s<<"ms"<<endl;
        cout<<"快排移动次数是"<<QMove<<endl;
        cout<<"快排比较次数是"<<QComp<<endl<<endl;
        
        L=init();
        s=clock();
        ShellSort(L,3);// dt 5 3 1 -> 3
        e=clock();
        if(temp==100)
            show(L);
        cout<<"希尔排序时间是"<<e-s<<"ms"<<endl;
        cout<<"希尔排序移动次数是"<<ShellMove<<endl;
        cout<<"希尔排序比较次数是"<<ShellComp<<endl<<endl;
        
        L=init();
        s=clock();
        BubbleSort(L);
        e=clock();
        if(temp==100)
            show(L);
        cout<<"冒泡排序时间是"<<e-s<<"ms"<<endl;
        cout<<"冒泡排序移动次数是"<<BubbleMove<<endl;
        cout<<"冒泡排序比较次数是"<<BubbleComp<<endl<<endl;

        L=init();
        s=clock();
        SelectSort(L);
        e=clock();
        if(temp==100)
            show(L);
        cout<<"简单选择排序时间是"<<e-s<<"ms"<<endl;
        cout<<"简单选择排序移动次数是"<<BubbleMove<<endl;
        cout<<"简单选择排序比较次数是"<<BubbleComp<<endl<<endl;
        
        L=init();
        s=clock();
        HeapSort(L);
        e=clock();
        if(temp==100)
            show(L);
        cout<<"堆排序时间是"<<e-s<<"ms"<<endl;
        cout<<"堆排序移动次数是"<<BubbleMove<<endl;
        cout<<"堆排序比较次数是"<<BubbleComp<<endl<<endl;
        
        temp*=10;
        cout<<"------------------------------------------"<<endl;
    }
    return 0;
}