数据结构课程设计————内部排序性能分析

/***********************************************************************************

*版权所有(C)2017,LiuTao。

*

*文件名称:main.c

*文件标识:无

*内容摘要:该代码用于获取满足后缀要求的第一个文件

*其它说明:无

*当前版本:V1.0

*作者:Mr.Liu

*完成日期:2017/12/19

*

*修改记录:无

*修改日期:无

*版本号:V1.0

*修改人:无

*修改内容:创建

************************************************************************************/

 

#include <stdio.h>
#include <ctime>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include "sort.h"

 int cmp1,cmp2,cmp3,cmp4,cmp5,cmp6;
 int move1,move2,move3,move4,move5,move6;

int main()
{
    int i,n=10000;   //随机数个数
    double start,end;   //标记起始和结束时间
    double tim6,tim1,tim2,tim3,tim4,tim5;       //记录时间差
    srand((unsigned)time(NULL));
    RecType R[MaxSize],R1[MaxSize],R2[MaxSize];//随机数组
    RecType R3[MaxSize],R4[MaxSize],R5[MaxSize];


    for(int j=1;j<=3;j++)
{


    //生成随机数组
    for (i=0; i<n; i++)
    {
        R[i].key=rand();
        R1[i].key=R[i].key;
        R2[i].key=R[i].key;
        R3[i].key=R[i].key;
        R4[i].key=R[i].key;
        R5[i+1].key=R[i].key;
    }




//直接插入  1
    start=clock();//clock()GetTickCount()
    InsertSort(R,n);
    end=clock();
    tim1=end-start;


//折半插入  2
    start=clock();
    InsertSort1(R1,n);
    end=clock();
    tim2=end-start;


//希尔排序  3
    start=clock();
    ShellSort(R2,n);
    end=clock();
    tim3=end-start;



//冒泡排序  4
    start=clock();
    BubbleSort(R3,n);
    end=clock();
    tim4=end-start;



//快速排序  5
    start=clock();
    QuickSort(R4,0,n-1);
    end=clock();
    tim5=end-start;



//堆排序  6
    start=clock();
    HeapSort(R5,n);
    end=clock();
    tim6=end-start;






/*****************************输出格式**********************************/
printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
printf("┃排序类型       ┃       时间(ms)      ┃       比较次数     ┃      移动次数    ┃\n");
printf("┃━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┃\n");
printf("┃直接插入       ┃      %10f     ┃     %10d     ┃     %10d   ┃\n",tim1,cmp1,move1);
printf("┃━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┃\n");
printf("┃折半排序       ┃      %10f     ┃     %10d     ┃     %10d   ┃\n",tim2,cmp2,move2);
printf("┃━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┃\n");
printf("┃希尔排序       ┃      %10f     ┃     %10d     ┃     %10d   ┃\n",tim3,cmp3,move3);
printf("┃━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┃\n");
printf("┃冒泡排序       ┃      %10f     ┃     %10d     ┃     %10d   ┃\n",tim4,cmp4,move4);
printf("┃━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┃\n");
printf("┃快速排序       ┃      %10f     ┃     %10d     ┃     %10d   ┃\n",tim5,cmp5,move5);
printf("┃━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┃\n");
printf("┃堆排序         ┃      %10f     ┃     %10d     ┃     %10d   ┃\n",tim6,cmp6,move6);
printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");





/********************************清除数据***************************************/
    cmp1=0;cmp2=0;cmp3=0;cmp4=0;cmp5=0;cmp6=0;
    move1=0;move2=0;move3=0;move4=0;move5=0;move6=0;
    printf("\n");
    printf("\n");
    printf("\n");
    system("pause");


}
    return 0;
}

 

/***********************************************************

 

*版权所有(C)2014,LiuTao

*

*文件名称:Sort.h

*文件标识:无

*内容摘要:该代码用于获取满足后缀要求的第一个文件

*其它说明:无

*当前版本:V1.0

*作者:Mr.Liu

*完成日期:20171219

*

*修改记录:无

*修改日期:无

*版本号:V1.0

*修改人:Mr.Liu

*修改内容:创建

**********************************************************/

#ifndef SORT_H_INCLUDED
#define SORT_H_INCLUDED

#include <malloc.h>

extern  int cmp1,cmp2,cmp3,cmp4,cmp5,cmp6;
extern  int move1,move2,move3,move4,move5,move6;
#define MaxSize 10000
//下面的符号常量和结构体针对基数排序
#define Radix 10           //基数的取值
#define Digits 10          //关键字位数

typedef int KeyType;    //定义关键字类型
typedef char InfoType[10];
typedef struct          //记录类型
{
    KeyType key;        //关键字项
    InfoType data;      //其他数据项,类型为InfoType
} RecType;              //排序的记录类型定义

typedef struct node
{
    KeyType data;      //记录的关键字,同算法讲解中有差别
    struct node *next;
} RadixRecType;


void BubbleSort(RecType R[],int n);//冒泡排序
void QuickSort(RecType R[],int s,int t);//快速排序
void SelectSort(RecType R[],int n);//简单选择排序
void HeapSort(RecType Rp[],int n);//堆排序
void sift(RecType R[],int low,int high);//调整堆
void Merge(RecType R[],int low,int mid,int high);//两路归并
void MergePass(RecType R[],int length,int n);  //对整个数序进行一趟归并
void MergeSort(RecType R[],int n);   //自底向上的二路归并算法

void CreateLink(RadixRecType *&p,RecType R[],int n);  //采用后插法产生链表
void DestoryLink(RadixRecType *&p);//8. 基数排序的辅助函数,释放基数排序用的链表
void RadixSort(RadixRecType *&p);//8. 实现基数排序:*p为待排序序列链表指针,基数R和关键字位数D已经作为符号常量定义好

void InsertSort1(RecType R[],int n); //对R[0..n-1]按递增有序进行折半插入排序
void InsertSort(RecType R[],int n); //对R[0..n-1]按递增有序进行直接插入排序
void ShellSort(RecType R[],int n);//希尔排序

#endif // SORT_H_INCLUDED

 

 

 

 

 

 

/**************************************************************************

*版权所有(C)2014,LiuTao

*

*文件名称:Sort.c

*文件标识:无

*内容摘要:该代码用于获取满足后缀要求的第一个文件

*其它说明:无

*当前版本:V1.0

*作者:Mr.Liu

*完成日期:20171219

*

*修改记录:无

*修改日期:无

*版本号:V1.0

*修改人:Mr.Liu

*修改内容:创建

***********************************************************************************/

 

 

 

 

 

 

#include "sort.h"
#include <stdio.h>


/*********************************************************
*功能描述:冒泡排序
*输入参数:RecType R[]-待排序数组,int n-元素个数
*输出参数:无
*返回值:0-成功 其他-失败
*其它说明:消息字段之间用分号(;)分隔
************************************************************/


void BubbleSort(RecType R[],int n)   //冒泡排序
{
    int i,j,exchange;
    RecType tmp;
    for(i=0;i<n-1;i++)
    {
        exchange=0;
        for(j=n-1;j>i;j--)
        {
            cmp4++;                 //比较次数+1
            if(R[j].key<R[j-1].key)
            {
                tmp=R[j];
                R[j]=R[j-1];
                R[j-1]=tmp;
                move4+=2;           //移动次数+2
            }
        }
    }
}

/*********************************************************
*功能描述:快速排序
*输入参数:RecType R[]-待排序数组,int s-元素最小下标,Int t-元素最大下标
*输出参数:无
*返回值:0-成功 其他-失败
*其它说明:消息字段之间用分号(;)分隔
************************************************************/

void QuickSort(RecType R[],int s,int t)     //快速排序
{
    int i=s,j=t;
    RecType tmp;
    if(s<t)
    {
        tmp=R[s];
        while(i!=j)
        {
            cmp5++;                          //比较次数+1
            while(j>i && R[j].key>=tmp.key)
                j--;
            R[i]=R[j];
            move5++;                        //移动次数+1
            while(i<j && R[i].key<=tmp.key)
                i++;
            R[j]=R[i];
            move5++;                        //移动次数+1
        }
        R[i]=tmp;
        move5++;                            //移动次数+1
        QuickSort(R,s,i-1);
        QuickSort(R,i+1,t);
    }
}


/*********************************************************
*功能描述:简单选择排序
*输入参数:RecType R[]-待排序数组,int n-元素个数
*输出参数:无
*返回值:0-成功 其他-失败
*其它说明:消息字段之间用分号(;)分隔
************************************************************/
void SelectSort(RecType R[],int n)          //简单选择排序
{
    int i,j,k,l;
    RecType temp;
    for(i=0;i<n-1;i++)
    {
        k=i;
        for(j=i+1;j<n;j++)
            if(R[j].key>R[k].key)
                k=j;
        if(k!=i)
        {
            temp=R[i];
            R[i]=R[k];
            R[k]=temp;
        }
    }
}



/*********************************************************
*功能描述:调整堆
*输入参数:RecType R[]-待排序数组,int low-元素最小下标,Int high-元素最大下标
*输出参数:无
*返回值:0-成功 其他-失败
*其它说明:消息字段之间用分号(;)分隔
************************************************************/
void sift(RecType R[],int low,int high)     //调整堆
{
    int i=low,j=2*i;                        //R[j]是R[i]的左孩子
    RecType temp=R[i];
    while (j<=high)
    {
        if (j<high && R[j].key<R[j+1].key)  //若右孩子较大,把j指向右孩子
            {j++;cmp6++;}                                //变为2i+1    //比较次数+1
        if (temp.key<R[j].key)
        {
            R[i]=R[j];                          //将R[j]调整到双亲结点位置上
            move6++;                            //移动次数+1
            i=j;                                //修改i和j值,以便继续向下筛选
            j=2*i;
            cmp6++;                             //比较次数+1
        }
        else break;                             //筛选结束
    }
    R[i]=temp;                                  //被筛选结点的值放入最终位置
    move6++;                                    //移动次数+1
}


/*********************************************************
*功能描述:堆排序
*输入参数:RecType R[]-待排序数组,int n-元素个数
*输出参数:无
*返回值:0-成功 其他-失败
*其它说明:消息字段之间用分号(;)分隔
************************************************************/
void HeapSort(RecType R[],int n)                //堆排序
{
    int i;
    RecType temp;
    for (i=n/2; i>=1; i--) //循环建立初始堆
        sift(R,i,n);
    for (i=n; i>=2; i--) //进行n-1次循环,完成推排序
    {
        temp=R[1];       //将第一个元素同当前区间内R[1]对换
        R[1]=R[i];
        R[i]=temp;
        move6+=2;          //移动次数+2
        sift(R,1,i-1);   //筛选R[1]结点,得到i-1个结点的堆
    }
}



/*********************************************************
*功能描述:调整堆
*输入参数:RecType R[]-待排序数组,int low-元素最小下标,int mid-元素中间下标,Int high-元素最大下标
*输出参数:无
*返回值:0-成功 其他-失败
*其它说明:消息字段之间用分号(;)分隔
************************************************************/
void Merge(RecType R[],int low,int mid,int high)        //归并排序
{
    RecType *R1;
    int i=low,j=mid+1,k=0;
    R1=(RecType *)malloc((high-low+1)*sizeof(RecType));
    while(i<=mid && j<=high)
        if(R[i].key<=R[j].key)
        {
            R1[k]=R[i];
            i++;
            k++;
        }
        else
        {
            R1[k]=R[j];
            j++;
            k++;
        }
        while(i<=mid)
        {
            R1[k]=R[i];
            i++;
            k++;
        }
        while(j<high)
        {
            R1[k]=R[j];
            j++;
            k++;
        }
        for(k=0,i=low;i<=high;k++,i++)
            R[i]=R1[k];
}

void MergePass(RecType R[],int length,int n)  //对整个数序进行一趟归并
{
    int i;
    for(i=0;i+2*length-1<n;i=i+2*length)
        Merge(R,i,i+length-1,i+2*length-1);
    if(i+length-1<n)
        Merge(R,i,i+length-1,n-1);
}

void MergeSort(RecType R[],int n)   //自底向上的二路归并算法
{
    int length;
    for(length=1;length<n;length=2*length);
}

//基数排序


//8. 基数排序的辅助函数,创建基数排序用的链表
void CreateLink(RadixRecType *&p,RecType R[],int n)   //采用后插法产生链表
{
    int i;
    RadixRecType *s,*t;
    for (i=0; i<n; i++)
    {
        s=(RadixRecType *)malloc(sizeof(RadixRecType));
        s->data = R[i].key;
        if (i==0)
        {
            p=s;
            t=s;
        }
        else
        {
            t->next=s;
            t=s;
        }
    }
    t->next=NULL;
}

//8. 基数排序的辅助函数,释放基数排序用的链表
void DestoryLink(RadixRecType *&p)
{
    RadixRecType *q;
    while(p!=NULL)
    {
        q=p->next;
        free(p);
        p=q;
    }
    return;
}

//8. 实现基数排序:*p为待排序序列链表指针,基数R和关键字位数D已经作为符号常量定义好
void RadixSort(RadixRecType *&p)
{
    RadixRecType *head[Radix],*tail[Radix],*t; //定义各链队的首尾指针
    int i,j,k;
    unsigned int d1, d2=1;   //用于分离出第i位数字,见下面的注释
    for (i=1; i<=Digits; i++)                  //从低位到高位循环
    {
        //分离出倒数第i位数字,先通过对d1=10^i取余,得到其后i位,再通过整除d2=10^(i-1)得到第i位
        //例如,分离出倒数第1位,即个位数,先对d1=10取余,再整除d2=1
        //再例如,分离出倒数第2位,即十位数,先对d1=100取余,再整除d2=10
        //循环之前,d2已经初始化为1,在这一层循环末增加10倍
        //下面根据d2,得到d1的值
        d1=d2*10;
        for (j=0; j<Radix; j++)                 //初始化各链队首、尾指针
            head[j]=tail[j]=NULL;
        while (p!=NULL)                 //对于原链表中每个结点循环
        {
            k=(p->data%d1)/d2;           //分离出第i位数字k
            if (head[k]==NULL)          //进行分配
            {
                head[k]=p;
                tail[k]=p;
            }
            else
            {
                tail[k]->next=p;
                tail[k]=p;
            }
            p=p->next;                  //取下一个待排序的元素
        }
        p=NULL;                         //重新用p来收集所有结点
        for (j=0; j<Radix; j++)             //对于每一个链队循环
            if (head[j]!=NULL)          //进行收集
            {
                if (p==NULL)
                {
                    p=head[j];
                    t=tail[j];
                }
                else
                {
                    t->next=head[j];
                    t=tail[j];
                }
            }
        t->next=NULL;                   //最后一个结点的next域置NULL
        //下面更新用于分离出第i位数字的d2
        d2*=10;
    }
}

/*********************************************************
*功能描述:直接插入排序
*输入参数:RecType R[]-待排序数组,int n-元素个数
*输出参数:无
*返回值:0-成功 其他-失败
*其它说明:消息字段之间用分号(;)分隔
************************************************************/
void InsertSort(RecType R[],int n) //对R[0..n-1]按递增有序进行直接插入排序
{
    int i,j;
    RecType tmp;
    for (i=1; i<n; i++)
    {
        tmp=R[i];
        j=i-1;            //从右向左在有序区R[0..i-1]中找R[i]的插入位置
        while (j>=0 && tmp.key<R[j].key)
        {
            R[j+1]=R[j]; //将关键字大于R[i].key的记录后移
            j--;
            cmp1++;      //比较次数+1
            move1++;     //移动次数+1
        }
        R[j+1]=tmp;      //在j+1处插入R[i]
        move1+=2;        //移动次数+2
    }
}

/*********************************************************
*功能描述:折半插入排序
*输入参数:RecType R[]-待排序数组,int n-元素个数
*输出参数:无
*返回值:0-成功 其他-失败
*其它说明:消息字段之间用分号(;)分隔
************************************************************/
void InsertSort1(RecType R[],int n) //对R[0..n-1]按递增有序进行折半插入排序
{
    int i,j,low,high,mid;
    RecType tmp;
    for (i=1; i<n; i++)
    {
        tmp=R[i];
        low=0;
        high=i-1;
        while (low<=high)
        {
            mid=(low+high)/2;
            if (tmp.key<R[mid].key)
                high=mid-1;
            else
                low=mid+1;
            cmp2++;
        }
        for (j=i-1; j>=high+1; j--)
            {R[j+1]=R[j];move2++;}
        R[high+1]=tmp;
    }
}



/*********************************************************
*功能描述:希尔排序
*输入参数:RecType R[]-待排序数组,int n-元素个数
*输出参数:无
*返回值:0-成功 其他-失败
*其它说明:消息字段之间用分号(;)分隔
************************************************************/
void ShellSort(RecType R[],int n)//希尔排序
{
    int i,j,gap,k;
    RecType tmp;
    gap=n/2;
    while(gap>0)
    {
        for(i=gap;i<n;i++)
        {
            tmp=R[i];
            j=i-gap;
            while(j>=0 && tmp.key<R[j].key)
            {
                cmp3++;                     //比较次数+1
                R[j+gap]=R[j];
                move3++;                    //移动次数+1
                j=j-gap;
            }
            R[j+gap]=tmp;
            move3+=2;                       //移动次数+2
            j=j-gap;
        }
        gap=gap/2;
    }
}




























 

 

 

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值