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

最新推荐文章于 2022-03-30 21:03:05 发布
最新推荐文章于 2022-03-30 21:03:05 发布
阅读量1.6k 收藏 11
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 课程设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lt1095862229/article/details/78841736
版权

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

*版权所有(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;
    }
}


 

 

 

拾柒先生
关注
专栏目录
数据结构课程设计---内部排序算法的性能分析
西_北
04-01 8220
内部排序算法的性能分析  一  需求分析 1) 对起泡排序、直接排序、简单选择排序、快速排序、希尔排序、堆排序算法进行比较； 2) 排序表中数据数目不小于100 ，表中数据随机产生，至少用5组不同数据集作比较，比较指标有：关键字参加比较次数和关键字的移动次数（关键字交换记为3次移动）； 3) 输出比较结果。 二  系统设计 对于排序算法的比较采取关键字参加比较次数和关键字的移动次数还有
数据结构实验：内部排序算法的性能分析
littlekingw的博客
08-15 5706
文章目录前言一、问题描述二、问题分析三、实验结果及分析（1）实验数据描述（2）实验结果（3）性能分析四、源代码 前言 记录下本学期的数据结构实验 本实验主要集中于比较几种内部排序算法 提示：以下是本篇文章正文内容，下面案例可供参考 一、问题描述 设计一个程序，对各种内部排序算法的关键字比较次数和移动次数进行比较。具体要求如下： ⑴ 编程实现内部排序算法：编程实现直接插入排序，希尔排序，冒泡排序，快速排序，简单选择排序，堆排序，归并排序算法。 ⑵ 要求数据规模：待排序数据类型不限（整型或浮点型），读取..
数据结构内部排序算法的性能分析
qq_42850073的博客
02-01 2309
【 昨天在整理资料的时候，刚好整理到数据结构的内部排序算法这一块，主要内容为对起泡排序、直接排序、简单选择排序、快速排序、希尔排序、堆排序算法进行比较，仅供初学数据结构的新手浏览学习，哪里写的不对的地方，请大神指点；之前学习内部排序算法的时候距离写这篇博客隔了挺长时间，有什么不好的地方，请评论，一定虚心改正】 简介： 本博客分为三部分： 第一部分:内部排序算法的性能分析问题描述及要求...
内部排序算法性能分析
04-26
快速排序，希尔排序，冒泡排序，插入排序，等等常见六种排序算法的性能分析源代码和文档。
数据结构各种内部排序课程设计
woshinigeno1的专栏
05-19 1180
  /*dataList.h*/       #include       #include       const   int   DefaultSize=100;       templateclass   dataList;       templateclass   Element{       friend   class   dataList;       private:      
数据结构课程设计五——排序算法综合分析.doc
06-03
数据结构课程设计五——排序算法综合分析 该资源是一个数据结构课程设计的五个部分，主要讲解排序算法的综合分析。该资源涵盖了多种排序算法，包括直接插入排序、希尔排序、快速排序、冒泡排序、堆排序和归并法排序...
数据结构课程设计——多关键字排序.docx
01-17
### 数据结构课程设计——多关键字排序 #### 一、问题描述与任务定义 在实际应用场景中，例如高考分数处理，不仅需要对考生的总分进行排序，还要考虑到不同专业对单科成绩的不同要求。这就引入了多关键字排序的...
数据结构课程设计——中文文本字频统计源代码及课程报告
06-29
在本项目中，"数据结构课程设计——中文文本字频统计源代码及课程报告" 是一个典型的计算机科学教育实践，主要关注数据结构和C++编程的应用。该项目旨在帮助学生理解和运用基本的数据结构来解决实际问题，即统计中文...
数据结构课程设计——火车管理系统
12-17
在这个“数据结构课程设计——火车管理系统”项目中，我们将深入理解如何应用数据结构来解决实际问题。这个项目包含程序源码和一份文档，为学生提供了一个实践平台，帮助他们将理论知识转化为实践技能。 首先，我们...
数据结构课程设计 比较几种内部排序算法的关键字比较次数和移动次数以取得直观感受
06-18
设计一个测试程序比较几种内部排序算法的关键字比较次数和移动次数以取得直观感受
各种内部排序性能比较(数据结构课程设计报告)
11-24
该程序是用C++语言实现的，在程序中随机生成N个数据，对这些数进行多种方法的排序，所用的这些排序方法都是在数据结构课中学习过的比如：插入排序、快速排序、冒泡排序等，而且还要对各个排序做出相应的比较。
数据结构课程设计(内部排序算法性能分析).doc
06-08
1）选择排序 基本思想：在待排序的一组数据元素中，选出最小的一个数据元素与第一个位置的数据元素交换；然后在剩下的数据元素当中再找最小的与第二个位置的数据元素交换，循环到只剩下最后一个数据元素为止。 （2）起泡排序 基本思想：相邻的两个元素进行比较，将小的调到前面，大的调到后面。 （3）直接插入排序 待排序的记录放在数组R[0…n-1]中排序过程中某一时刻，R被划分成两个子区间R[0…i-1] (有序和)R[i…n-1](无序)。直接插入的基本操作是将当前无序区的一个记录R[i]插入到有序区R[0…i-1]中适当的位置 （4） 快速排序 基本思想：在待排序的数组的n个元素中取一个元素(一般取第一个)，将其移动到这样的位置：在其之前的元素的值都小于它，在其之后的元素都大于它，这样是一趟快速排序；然后对数组的两个部分进行同样的操作，直到每部分只有一个记录为止；总之，每趟使表的第一个元素放在适当位置，将表两分，再对两子表进行同样的递归划分，直至划分的子表长度为1！ （5）归并排序 基本思想：将两个或两个以上的有序表组成一个新的有序表。
数据结构课程设计——排序综合课程设计
06-24
这是数据结构课程设计 有关于排序综合课程设计 可四个人合作
内部排序算法比较 数据结构课程设计
06-21
一、需求分析 1、本演示程序对以下6种常用的内部排序算法进行实测比较：起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。 2、待排序表的表的元素的关键字为整数，表长不小于100；其中的数据要用伪随机数产生程序产生(乱序)和由键盘输入（正序、逆序）；至少要用5组不同的输入数据作比较；比较的指标为有关关键字参加的比较次数和关键字的移动次数（关键字交换记为3次移动）。 3、演示程序以用户和计算机对话的方式执行，即在计算机终端上显示“提示信息”下，用户可由键盘操作，由伪随机数产生器产生或由用户键盘输入待排序数据，每次测试完毕，列表显示各种比较指标值。 4、最后对结果做出简单分析，包括对各组数据得出结果波动大小给予解释。
数据结构课程设计——快速排序
09-13
数据结构课程设计 快速排序 两江大学出版社
内部排序算法的性能分析
DX奥特曼的博客
12-30 3758
[问题描述] 教科书第10章中，介绍了多种排序算法，并从理论角度对各种算法的时间复杂度进行了分析。依据书中的理论知识，设计一个排序算法比较程序，试比较几种内部排序算法的关键字比较次数和移动次数（关键字交换视为3次移动），以得到对各种排序算法执行效率的直观感受。 [基本要求] （1）以顺序表作为待排序表的存储结构，其中表长（即关键字个数）不小于100，表中数据随机产生，至少用5组不同数据作比较...
数据结构课程设计----综合排序
wsswsswss123的博客
03-30 4413
《数据结构课程设计》报告 日期： 项目名称： 综合排序 一、项目简介和需求分析 排序（sorting是计箅机程序设计的一种重要操作，它的功能是将一组任意顺序数据元素（记录），根据某一个（或几个）关键字按一定的顺序里新排列成为有序的序列。由于待排序的记录数量不同，使得排序过程中涉及的存储器的不同，可将排序方法分为两大类：一类是内部排序，指的是待排序的记录存放在计算机随机存储器中进行的排序过程；另一类是外部排序，指的是待排序记录的数量很大，以致内存一次不能容纳全部记
数据结构课程设计—内部排序算法比较
07-22
数据结构课程设计，主要是对内部排序算法比较！
数据结构课程设计(内部排序算法比较_C语言)
07-14
数据结构课程设计(内部排序算法比较_C语言) 数据结构课程设计(内部排序算法比较_C语言)
计算机科学系学生：数据结构课程设计——拓扑排序实践与报告指南
数据结构课程设计——拓扑排序是一份针对计算机科学专业的课程设计任务，目标是实现拓扑排序算法。拓扑排序是一种对有向无环图（DAG，Directed Acyclic Graph）进行排序的技术，它将图中的节点按照一定的线性顺序...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值