实现一个排序算法并统计其运行时间
1．实现一个排序算法并统计其运行时间。包括：1) 实现一个排序算法；2) 利用事后统计法观察其时间复杂度: 对于每组待排序记录，统计你的排序算法排序所花的CPU时间。对于不同规模的输入，统计相应的CPU时间，并作出时间随规模变化的统计图(利用某种方法生成足够大的输入, 将输入和输出存到文件中以便于观察。)；3) 你是如何确保你的排序是正确的?能否给出一个测试排序正确性的函数?
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
class Array
{
protected:
int n;
int a[100000];//容量为10万的数组
public:
Array(int n,int choice)
{
GetN(n);
if(choice==1)
creat();//随机产生数据
else
Creat();//倒叙产生数据
}
void creat();//随机产生数据
void Creat();//倒叙产生数据
int GetN(int x)
{
n=x;
return n;
}
int GetArray(int i){return a[i];}
void OutArray();
void QSort(){QuickSort(0,n-1);}
void QuickSort(int left,int right);//快速排序
//void InSort(){InsertSort({1,2,3,4,5}, n);}
bool Test();
void InsertSort(); //直接插入排序
};
void Array::creat()
{
if(n<=100000)
{
srand( (unsigned)time( NULL ) );
for(int i=0;i { a[i]=rand()%n;//随机产生0-（n-1）之间的数 } } else { cout<<"输入数组超出了范围，请重新输入n的取值（n<100000）：___\b\b\b"; cin>>n; creat(); } } void Array::Creat() { if(n<=100000) { for(int i=0;i a[i]=n-i; } else { cout<<"输入数组超出了范围，请重新输入n的取值（n<100000）：___\b\b\b"; cin>>n; Creat(); } } void Array::OutArray() { for(int i=0;i { if((i+1)%6==0)//每六个数换一次行 cout< cout<<"a["< } cout< } void Array::QuickSort(int left,int right) { int i,j; if(left { i=left; j=right+1; do { do i++; while(a[i] do j--; while(a[j]>a[left]); if(i swap(a[i],a[j]); }while(i swap(a[left],a[j]); QuickSort(left,j-1);//对低端序列快速排序 QuickSort(j+1,right);//对高端序列快速排序} }//快速排序 void Array::InsertSort() { int i,j; int temp; for(i=1;i if(a[i-1]>a[i]){ temp=a[i]; j=i-1; while(a[j]>temp){ a[j+1]=a[j]; j--; } a[j+1]=temp; } //OutArray(); }//直接插入排序 bool Array::Test() { for(int i=0;i { if(a[i-1]>a[i]) return false; } return true; } void Function() { int n;//自定义数组长度 bool test; clock_t start,finsh;//统计CUP时间的变量 double totaltime;//最终CUP所用的时间 cout<<"请输入数组长度："; cin>>n; Array a(n,1);//定义Array类对象，实现随机数组的创建 ofstream ofs("c:\\排序之前的数组（快速排序）.txt",ios::app);//把随机产生的数组，写进c:\\排序之前的数组（快速排序）.txt中 for(int i=0;i { ofs< if((i+1)%5==0) ofs< } ofs<<" "< // a.OutArray();/*显示排序之前的数组元素*/ start=clock(); a.QSort(); finsh=clock(); a.Test(); totaltime=(double)(finsh-start)/CLOCKS_PER_SEC; cout<<"\n快速排序所花的CPU时间为"< ofstream ofs1("c:\\快速排序所花的CPU时间.txt",ios::app);//把快速排序所花的CPU时间，写进c:\\快速排序所花的CPU时间.txt中 ofs1<<"规模为"< // a.OutArray();/*显示排序之后的数组元素*/ ofstream ofs2("c:\\排序之后的数组（快速排序）.txt",ios::app);//把排序之后的数组，写进c:\\排序之后的数组（快速排序）.txt中 for(i=0;i { ofs2< if((i+1)%5==0) ofs2< } ofs2<<" "< } void Function1() { int n;//自定义数组长度 bool test; clock_t start,finsh;//统计CUP时间的变量 double totaltime;//最终CUP所用的时间 cout<<"请输入数组长度："; cin>>n; Array a(n,2);//定义Array类对象，实现数组的创建 ofstream ofs("c:\\排序之前的数组（直接插入排序）.txt",ios::app);//把随机产生的数组，写进c:\\排序之前的数组（直接插入排序）.txt中 for(int i=0;i { ofs< if((i+1)%5==0) ofs< } ofs<<" "< // a.OutArray();/*显示排序之前的数组元素*/ start=clock(); a.InsertSort(); ///!!!!!!!!!!!!!! finsh=clock(); a.Test(); totaltime=(double)(finsh-start)/CLOCKS_PER_SEC; cout<<"\n直接插入排序所花的CPU时间为"< ofstream ofs1("c:\\直接插入排序所花的CPU时间.txt",ios::app);//把直接插入排序所花的CPU时间，写进c:\\直接插入排序所花的CPU时间.txt中 ofs1<<"规模为"< // a.OutArray();/*显示排序之后的数组元素*/ ofstream ofs2("c:\\排序之后的数组（直接插入排序）.txt",ios::app);//把排序之后的数组，写进c:\\排序之后的数组（直接插入排序）.txt中 for(i=0;i { ofs2< if((i+1)%5==0) ofs2< } ofs2<<" "< } void Run() { system("color 1f"); int ch; cout< cout<<"**************************"< cout<<"**** 排序系统****"< cout<<"****0.退出****"< cout<<"****1.快速排序****"< cout<<"****2.直接插入排序****"< cout<<"**************************"< cout<<"请选择排序的类型："< cin>>ch; switch(ch) { case 0: break; case 1: Function(); break; case 2: Function1(); break; } } void main() { Run(); } 地理时间计算方法 ?地理时间计算方法 地理时间计算方法 一、地方时的计算 由于地球自西向东自转，所以同纬度上不同的地区见到日出的时间有早有晚，东边的时刻比西边的时刻要早，这种因经度不同而产生的不同时刻，称为地方时。由于时刻东早西晚，所以每向东15°时间要早1小时，每向西15°时间要晚1小时，经度相差1°，时间 相差4分钟。 二、区时的计算 为了便于不同地区的交流，1884年国际上按统一标准划分时区，实行分区计时的办法。按照这个划分方法，地球上每15°作为一个时区，全球共分24个时区，每个时区中央经线的地方时即为该时区的标准时间区时。区时的计算一般分以下几个步骤： 1. 时区的计算： 如果要求某一经度的区时，首先要计算出该经度所在的时区。经度换算时区的公式：经度数÷15°=M（商）……n（余数）（n<7.5°时，时区数=M；n>7.5°时，时区数=M 1）。根据此公式也可以计算M时区所跨的经度范围，即：15°×M（时区数）±7.5°（15°×时区数为这个时区的中央经线的经度）。 2. 区时差的计算： 如果知道甲地的区时，求乙地的区时，首先要计算两地的区时差。如果甲、乙两地位于中时区的同侧，计算区时差用减法，如东八区与 东二区差6个区时，西九区与西二区差7个区时。如果甲、乙两地位于中时区的两侧，计算区时差用加法，如西六区与东六区差12个 区时。 3. 区时的计算： 区时的计算遵循“东加西减”的原则。已知甲地的时间，求乙地的时间，那么乙地的时间=甲地的时间±甲、乙两地所在时区的区时差（乙地在甲地的东侧用“ ”，乙地在甲地的西侧用“－”）。 4. 计算结果的处理： 由于全天采用24小时制，所以计算结果若大于24小时，要减去24小时，日期加一天，即为所求的时间；计算结果若为负值，要加24小时，日期减一天，即为所求的时间。碰到跨年、月时，要注 意大月、小月、平年、闰年。 三、日界线 日界线简单地说就是“今天”和“昨天”的分界线。从本初子午线开始，如果向东到180°经线，那么180°经线比本初子午线要早12小时；如果向西到180°经线，那么180°经线比本初子午线要晚12小时。这样，同是180°经线，时间却相差24小时。因此，国际上规定，把180°经线作为国际日期变更线，它既是一天的开始，又是一天的结束，即东十二区和西十二区时刻相同，日期相差一天，东十二区比西十二区早一天。值得注意的是，国际日期变更线并非与180°经线完全重合，受各国领土的影响，有些地方日界线不得不改变它的位置而发生弯曲。另一条日界线为0时日界线（或子夜日界 排序算法比较 主要容： 1)利用随机函数产生10000个随机整数，对这些数进行多种方法排序。 2）至少采用4种方法实现上述问题求解（可采用的方法有插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序），并把排序后的结功能果保存在不同的文件里。 3）给出该排序算法统计每一种排序方法的性能（以运行程序所花费的时间为准进行对比），找出其中两种较快的方法。 程序的主要功能： 1.随机数在排序函数作用下进行排序 2.程序给出随机数排序所用的时间。 算法及时间复杂度 （一）各个排序是算法思想： （1）直接插入排序：将一个记录插入到已排好的有序表中，从而得到一个新的，记录数增加1的有序表。 （2）冒泡排序：首先将第一个记录的关键字和第二个记录的关键字进行比较，若为逆序，则将两个记录交换，然后比较第二个记录和第三个记录的关键字。依此类推，直到第N-1和第N个记录的 关键字进行过比较为止。上述为第一趟排序，其结果使得关键字的最大纪录被安排到最后一个记录的位置上。然后进行第二趟起泡排序，对前N-1个记录进行同样操作。一共要进行N-1趟起泡排序。 （3）快速排序：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，已达到整个序列有序。 （4）选择排序：通过N-I次关键字间的比较，从N-I+1个记录中选出关键字最小的记录，并和第I（1<=I<=N）个记录交换。 时间复杂度分析 10000个数据的时间比较： 程序源代码： /********************************************************************************************** package test; public class SortArray { private static final int Min = 1;//生成随机数最小值 private static final int Max = 10000;//生成随机数最大值 private static final int Length = 10000;//生成随机数组长度(测试的朋友建议不要超过40000,不然你要等很久,如果你电脑配置绝对高的情况下你可以再加个0试试) public static void main(String[] args) { System.out.println("数组长度："+Length+", Min："+Min+", Max："+Max); long begin; long end; int arr[] = getArray(Length); HUNAN UNIVERSITY 课程实习报告 题目：排序算法的时间性能学生姓名 学生学号 专业班级 指导老师李晓鸿 完成日期 设计一组实验来比较下列排序算法的时间性能 快速排序、堆排序、希尔排序、冒泡排序、归并排序(其他排序也可以作为比较的对象） 要求 (1)时间性能包括平均时间性能、最好情况下的时间性能、最差情况下的时间性能等。 (2)实验数据应具有说服力，包括：数据要有一定的规模（如元素个数从100到10000）；数据的初始特性类型要多，因而需要具有随机性；实验数据的组数要多，即同一规模的数组要多选几种不同类型的数据来实验。实验结果要能以清晰的形式给出，如图、表等。 (3)算法所用时间必须是机器时间，也可以包括比较和交换元素的次数。 (4)实验分析及其结果要能以清晰的方式来描述，如数学公式或图表等。 (5)要给出实验的方案及其分析。 说明 本题重点在以下几个方面： 理解和掌握以实验方式比较算法性能的方法；掌握测试实验方案的设计；理解并实现测试数据的产生方法；掌握实验数据的分析和结论提炼；实验结果汇报等。 一、需求分析 (1) 输入的形式和输入值的范围：本程序要求实现各种算法的时间性能的比 较，由于需要比较的数目较大，不能手动输入，于是采用系统生成随机数。 用户输入随机数的个数n，然后调用随机事件函数产生n个随机数，对这些随机数进行排序。于是数据为整数 (2) 输出的形式：输出在各种数目的随机数下，各种排序算法所用的时间和 比较次数。 (3) 程序所能达到的功能：该程序可以根据用户的输入而产生相应的随机 数，然后对随机数进行各种排序，根据排序进行时间和次数的比较。 （4）测试数据：略 二、概要设计 排序算法 一、插入排序(Insertion Sort) 1. 基本思想： 每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；直到待排序数据元素全部插入完为止。 2. 排序过程： 【示例】： [初始关键字] [49] 38 65 97 76 13 27 49 J=2(38) [38 49] 65 97 76 13 27 49 J=3(65) [38 49 65] 97 76 13 27 49 J=4(97) [38 49 65 97] 76 13 27 49 J=5(76) [38 49 65 76 97] 13 27 49 J=6(13) [13 38 49 65 76 97] 27 49 J=7(27) [13 27 38 49 65 76 97] 49 J=8(49) [13 27 38 49 49 65 76 97] Procedure InsertSort(Var R : FileType); //对R[1..N]按递增序进行插入排序, R[0]是监视哨// Begin for I := 2 To N Do //依次插入R[2],...,R[n]// begin R[0] := R[I]; J := I - 1; While R[0] < R[J] Do //查找R[I]的插入位置// begin R[J+1] := R[J]; //将大于R[I]的元素后移// J := J - 1 end R[J + 1] := R[0] ; //插入R[I] // end End; //InsertSort // 二、选择排序 1. 基本思想： 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 2. 排序过程： 【示例】： 初始关键字[49 38 65 97 76 13 27 49] 第一趟排序后13 ［38 65 97 76 49 27 49] 第二趟排序后13 27 ［65 97 76 49 38 49] 第三趟排序后13 27 38 [97 76 49 65 49] 第四趟排序后13 27 38 49 [49 97 65 76] 第五趟排序后13 27 38 49 49 [97 97 76] 中国古代时间的计算方法（1） 现时每昼夜为二十四小时，在古时则为十二个时辰。当年西方机械钟表传入中国，人们将中西时点，分别称为“大时”和“小时”。随着钟表的普及，人们将“大时”忘淡，而“小时”沿用至今。 古时的时（大时）不以一二三四来算，而用子丑寅卯作标，又分别用鼠牛虎兔等动物作代，以为易记。具体划分如下：子（鼠）时是十一到一点，以十二点为正点；丑（牛）时是一点到三点，以两点为正点；寅（虎）时是三点到五点，以四点为正点；卯（兔）时是五点到七点，以六点为正点；辰（龙）时是七点到九点，以八点为正点；巳（蛇）时是九点到^一点，以十点为正点；午（马）时是^一点到一点，以十二点为正点；未（羊）时是一点到三点，以两点为正点；申（猴）时是三点到五点，以四点为正点；酉（鸡）时是五点到七点，以六点为正点；戌（狗）时是七点到九点，以八点为正点；亥（猪）时是九点到^一点，以十点为正点。 古人说时间，白天与黑夜各不相同，白天说“钟”，黑夜说“更”或“鼓”。又有“晨钟暮鼓”之说，古时城镇多设钟鼓楼，晨起（辰时，今之七点）撞钟报时，所以白天说“几点钟”；暮起（酉时，今之十九点）鼓报时，故夜晚又说是几鼓天。夜晚说时间又有用“更” 的，这是由于巡夜人，边巡行边打击梆子，以点数报时。全夜分五个更，第三更是子时，所以又有“三更半夜”之说。 时以下的计量单位为“刻”，一个时辰分作八刻，每刻等于现时的十五分钟。旧小说有“午时三刻开斩”之说，意即，在午时三刻钟（差十五分钟到正午）时开刀问斩，此时阳气最盛，阴气即时消散，此罪大恶极之犯，应该“连鬼都不得做”，以示严惩。阴阳家说的阳气最盛，与现代天文学的说法不同，并非是正午最盛，而是在午时三刻。古代行斩刑是分时辰开斩的，亦即是斩刑有轻重。一般斩刑是正午开刀，让其有鬼做；重犯或十恶不赦之犯，必选午时三刻开刀，不让其做鬼。皇城的午门阳气也最盛，不计时间，所以皇帝令推出午门斩首者，也无鬼做。 刻以下为“字”，关于“字”，广东广西的粤语地区和福建广东的闽南语地区至今仍然使用，如“下午三点十个字”，其意即“十五点五十分”。据语言学家分析，粤语中所保留的“古汉语”特别多，究其原因，盖因古中原汉人流落岭南，与中原人久离，其语言没有与留在中原的人“与时俱进”。“字”以下的分法不详，据《隋书律历志》载，秒为 古时间单位，秒以下为“忽”；如何换算，书上没说清楚，只说：“’秒’如芒这样细； '忽’如最细的蜘蛛丝”。 C程序中可使用不同类型的变量来进行延时设计。经实验测试，使用unsigned char类型具有比unsigned int更优化的代码，在使用时 应该使用unsigned char作为延时变量。以某晶振为12MHz的单片 机为例，晶振为12M H z即一个机器周期为1u s。一. 500ms延时子程序 程序: void delay500ms(void) { unsigned char i,j,k; for(i=15;i>0;i--) for(j=202;j>0;j--) for(k=81;k>0;k--); } 计算分析: 程序共有三层循环 一层循环n:R5*2 = 81*2 = 162us DJNZ 2us 二层循环m:R6*(n+3) = 202*165 = 33330us DJNZ 2us + R5赋值 1us = 3us 三层循环: R7*(m+3) = 15*33333 = 499995us DJNZ 2us + R6赋值 1us = 3us 循环外: 5us 子程序调用 2us + 子程序返回2us + R7赋值 1us = 5us 延时总时间 = 三层循环 + 循环外 = 499995+5 = 500000us =500ms 计算公式:延时时间=[(2*R5+3)*R6+3]*R7+5 二. 200ms延时子程序 程序: void delay200ms(void) { unsigned char i,j,k; for(i=5;i>0;i--) for(j=132;j>0;j--) for(k=150;k>0;k--); } 三. 10ms延时子程序 程序: void delay10ms(void) { unsigned char i,j,k; for(i=5;i>0;i--) for(j=4;j>0;j--) for(k=248;k>0;k--); 数据结构课程设计 课程名称：内部排序算法比较 年级/院系：11级计算机科学与技术学院 姓名/学号： 指导老师： 第一章问题描述 排序是数据结构中重要的一个部分，也是在实际开发中易遇到的问题，所以研究各种排算法的时间消耗对于在实际应用当中很有必要通过分析实际结合算法的特性进行选择和使用哪种算法可以使实际问题得到更好更充分的解决！该系统通过对各种内部排序算法如直接插入排序，冒泡排序，简单选择排序，快速排序，希尔排序，堆排序、二路归并排序等，以关键码的比较次数和移动次数分析其特点，并进行比较，估算每种算法的时间消耗，从而比较各种算法的优劣和使用情况！排序表的数据是多种不同的情况，如随机产生数据、极端的数据如已是正序或逆序数据。比较的结果用一个直方图表示。 第二章系统分析 界面的设计如图所示： |******************************| |-------欢迎使用---------| |-----（1）随机取数-------| |-----（2）自行输入-------| |-----（0）退出使用-------| |******************************| 请选择操作方式： 如上图所示该系统的功能有： （1）：选择1 时系统由客户输入要进行测试的元素个数由电脑随机选取数字进行各种排序结果得到准确的比较和移动次数并 打印出结果。 （2）选择2 时系统由客户自己输入要进行测试的元素进行各种排序结果得到准确的比较和移动次数并打印出结果。 （3）选择0 打印“谢谢使用！！”退出系统的使用！！ 第三章系统设计 （I）友好的人机界面设计：（如图3.1所示） |******************************| |-------欢迎使用---------| |-----（1）随机取数-------| |-----（2）自行输入-------| |-----（0）退出使用-------| 排序算法比较 主要内容： 1)利用随机函数产生10000个随机整数，对这些数进行多种方法排序。 2）至少采用4种方法实现上述问题求解（可采用的方法有插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序），并把排序后的结功能果保存在不同的文件里。 3）给出该排序算法统计每一种排序方法的性能（以运行程序所花费的时间为准进行对比），找出其中两种较快的方法。 程序的主要功能： 1.随机数在排序函数作用下进行排序 2.程序给出随机数排序所用的时间。 算法及时间复杂度 （一）各个排序是算法思想： （1）直接插入排序：将一个记录插入到已排好的有序表中，从而得到一个新的，记录数增加1的有序表。 （2）冒泡排序：首先将第一个记录的关键字和第二个记录的关键字进行比较，若为逆序，则将两个记录交换，然后比较第二个记录和第三个记录的关键字。依此类推，直到第N-1和第N个记录的 关键字进行过比较为止。上述为第一趟排序，其结果使得关键字的最大纪录被安排到最后一个记录的位置上。然后进行第二趟起泡排序，对前N-1个记录进行同样操作。一共要进行N-1趟起泡排序。 （3）快速排序：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，已达到整个序列有序。 （4）选择排序：通过N-I次关键字间的比较，从N-I+1个记录中选出关键字最小的记录，并和第I（1<=I<=N）个记录交换。 时间复杂度分析 排序算法最差时间时间复杂度是否稳定？ 插入排序O(n2) O(n2) 稳定冒泡排序O(n2) O(n2) 稳定快速排序O(n2) O(n*log n) 不稳定 2 选择排序O(n2) O(n2) 稳定 1．实现一个排序算法并统计其运行时间。包括：1) 实现一个排序算法；2) 利用事后统计法观察其时间复杂度: 对于每组待排序记录，统计你的排序算法排序所花的CPU时间。对于不同规模的输入，统计相应的CPU时间，并作出时间随规模变化的统计图(利用某种方法生成足够大的输入, 将输入和输出存到文件中以便于观察。)；3) 你是如何确保你的排序是正确的?能否给出一个测试排序正确性的函数? #include C++运行时间的代码 如何获取代码运行时间在调试中，经常需要计算某一段代码的执行时间，下面给出两种常用的方式： 第一种：使用GetTickCount函数 #include 各种排序算法的总结和比较 1 快速排序（QuickSort） 快速排序是一个就地排序，分而治之，大规模递归的算法。从本质上来说，它是归并排序的就地版本。快速排序可以由下面四步组成。 （1）如果不多于1个数据，直接返回。 （2）一般选择序列最左边的值作为支点数据。（3）将序列分成2部分，一部分都大于支点数据，另外一部分都小于支点数据。 （4）对两边利用递归排序数列。 快速排序比大部分排序算法都要快。尽管我们可以在某些特殊的情况下写出比快速排序快的算法，但是就通常情况而言，没有比它更快的了。快速排序是递归的，对于内存非常有限的机器来说，它不是一个好的选择。 2 归并排序（MergeSort） 归并排序先分解要排序的序列，从1分成2，2分成4，依次分解，当分解到只有1个一组的时候，就可以排序这些分组，然后依次合并回原来的序列中，这样就可以排序所有数据。合并排序比堆排序稍微快一点，但是需要比堆排序多一倍的内存空间，因为它需要一个额外的数组。 3 堆排序（HeapSort） 堆排序适合于数据量非常大的场合（百万数据）。 堆排序不需要大量的递归或者多维的暂存数组。这对于数据量非常巨大的序列是合适的。比如超过数百万条记录，因为快速排序，归并排序都使用递归来设计算法，在数据量非常大的时候，可能会发生堆栈溢出错误。 堆排序会将所有的数据建成一个堆，最大的数据在堆顶，然后将堆顶数据和序列的最后一个数据交换。接下来再次重建堆，交换数据，依次下去，就可以排序所有的数据。 Shell排序通过将数据分成不同的组，先对每一组进行排序，然后再对所有的元素进行一次插入排序，以减少数据交换和移动的次数。平均效率是O(nlogn)。其中分组的合理性会对算法产生重要的影响。现在多用D.E.Knuth的分组方法。 Shell排序比冒泡排序快5倍，比插入排序大致快2倍。Shell排序比起QuickSort，MergeSort，HeapSort慢很多。但是它相对比较简单，它适合于数据量在5000以下并且速度并不是特别重要的场合。它对于数据量较小的数列重复排序是非常好的。 5 插入排序（InsertSort） 插入排序通过把序列中的值插入一个已经排序好的序列中，直到该序列的结束。插入排序是对冒泡排序的改进。它比冒泡排序快2倍。一般不用在数据大于1000的场合下使用插入排序，或者重复排序超过200数据项的序列。 年份、月份的认识 一年：12个月 一月、三月、五月、七月、八月、十月、十二月，是大月（31日）。 四月、六月、九月、十一月，是小月（30日）。 二月既不是大月，也不是小月。 平年：365天；平年二月28天 闰年：366天；闰年二月29天 （闰年比平年多一天是：2月29日） 每四年一闰 平年与闰年的判断：用年份除以4，没有余数是闰年，有余数的是平年。 如果年份是整百，整千，（如2100、2000）就用年除以400，没有余数是闰年，有余数是平年。 七、八月是唯一连续的大月，合共62天。 如果有人是四年过一次生日，这个人一定是2月29日出生。 时间的认识与学习 一天：24小时，一天时针在钟表上走两圈。 1小时=60分1分钟=60秒 1小时=60分=3600秒 24小时计时法与普通计时法在表示上的区别： 24小时计时法只有数字：如，7：00 ，19：00。 普通计时法要有数字也有文字：如，上午7：00，晚上7：00。 24小时计时法与普通计时法的转化： 对于上午的时间：不变 对于下午的时间：24小时计时法（变）→普通计时法用时间减去12 普通计时法（变）→24小时计时法用时间加上12 年、月、日的计算 当要求求年份： 结束年份-开始年份=经过年份 结束年份-经过年份=开始年份 开始年份+经过年份=结束年份 当要求求月份： ①都在同一年： 结束月份-开始月份=经过月份 结束月份-经过月份=开始月份 开始月份=经过月份=结束月份 ②跨年：用一年总月数-开始月份+结束月份=经过月份 当要求求天数： ①都在同一个月：结束天数-开始天数+1=经过天数 ②跨月（不在同一个月）： 用开始月份的总天数-开始天数+结束天数+1=经过天数 大月：31天 小月：30天 平年二月：28天 闰年二月：29天 24小时计算法的计算： Matlab中计算程序运行时间的三种方法 经常我们需要计算我们程序到底运行多长时间，这样可以比较程序的执行效率。当然这个对于只有几秒钟的小程序没有什么意义，但是对于大程序就有很重要的意义了。 下面我们就说说Matlab中计算程序运行时间的三种常用方法吧！ 注意：三种方法由于使用原理不一样，得到结果可能有一定的差距！ 1、tic和toc组合(使用最多的) 计算tic和toc之间那段程序之间的运行时间，它的经典格式为 1. tic 2. 。。。。。。。。。。 3. toc 复制代码 换句话说程序，程序遇到tic时Matlab自动开始计时，运行到toc时自动计算此时与最近一次tic之间的时间。这个有点拗口，下面我们举个例子说明 1. % by dynamic of Matlab技术论坛 2. % see also https://www.sodocs.net/doc/2d201174.html, 3. % contact me matlabsky@https://www.sodocs.net/doc/2d201174.html, 4. % 2009-08-18 12:08:47 5. clc 6. tic;%tic1 7. t1=clock; 8. for i=1:3 9. tic ;%tic2 10. t2=clock; 11. pause(3*rand) 12. %计算到上一次遇到tic的时间，换句话说就是每次循环的时间 13. disp(['toc计算第',num2str(i),'次循环运行时间：',num2str(toc)]); 14. %计算每次循环的时间 15. disp(['etime计算第',num2str(i),'次循环运行时间：',num2str(etime(clock,t2))]); 16. %计算程序总共的运行时间 17. disp(['etime计算程序从开始到现在运行的时间:',num2str(etime(clock,t1))]); 18. disp('======================================') 19. end 20. %计算此时到tic2的时间，由于最后一次遇到tic是在for循环的i=3时，所以计算 的是最后一次循环的时间 21. disp(['toc计算最后一次循环运行时间',num2str(toc)]) 22. disp(['etime程序总运行时间：',num2str(etime(clock,t1))]); 复制代码 运行结果如下，大家可以自己分析下 1. toc计算第1次循环运行时间： 2.5628 2. etime计算第1次循环运行时间：2.562 信息学部算法分析 上机报告 学号0901******** 姓名陈龙 指导老师秦明 时间2011.11.1~11.23 一．上机实验题目 实验1 比较归并排序和快速排序的区别。 实验2 利用贪心算法对背包问题进行求解。 二．算法设计思路 归并排序： 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列，设定两个指针，最初位置分别为两个已经排序序列的起始位置，比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置，重复步骤直到某一指针达到序列尾，将另一序列剩下的所 有元素直接复制到合并序列尾。 快速排序： 设置两个变量I、J，排序开始的时候：I=0，J=N-1；以第一个数组元素作为关键数据，赋值给key，即key=A[0]；从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于key的值A[J]，并与key交换；从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于key的A[I]，与key交换；重复第3、4、5步，直到I=J；(3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i，j指针位置不变。另外当i=j这过程一定正好是i+或j-完成的最后另循环结束。) 背包问题： 用子问题定义状态：即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是：f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]} 。可以压缩空间，f[v]=max{f[v],f[v-c[i]]+w[i]} 三. 源程序 归并排序 #include 排序法最差时间分析平均时间复杂度稳定度空间复杂度 冒泡排序()() 稳定() 快速排序()(*) 不稳定()() 选择排序()() 稳定() 二叉树排序()(*) 不一顶() 插入排序()() 稳定() 堆排序(*) (*) 不稳定() 希尔排序不稳定() 、时间复杂度 （）时间频度一个算法执行所耗费地时间，从理论上是不能算出来地，必须上机运行测试才能知道.但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费地时间多，哪个算法花费地时间少就可以了.并且一个算法花费地时间与算法中语句地执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多.一个算法中地语句执行次数称为语句频度或时间频度.记为(). （）时间复杂度在刚才提到地时间频度中，称为问题地规模，当不断变化时，时间频度()也会不断变化.但有时我们想知道它变化时呈现什么规律.为此，我们引入时间复杂度概念. 一般情况下，算法中基本操作重复执行地次数是问题规模地某个函数，用()表示，若有某个辅助函数(),使得当趋近于无穷大时，（)()地极限值为不等于零地常数，则称()是()地同数量级函数.记作()Ｏ(()),称Ｏ(()) 为算法地渐进时间复杂度，简称时间复杂度. 在各种不同算法中，若算法中语句执行次数为一个常数，则时间复杂度为(),另外，在时间频度不相同时，时间复杂度有可能相同，如()与()它们地频度不同，但时间复杂度相同，都为(). 按数量级递增排列，常见地时间复杂度有：常数阶(),对数阶(),线性阶(), 线性对数阶(),平方阶()，立方阶(),...，次方阶(),指数阶().随着问题规模地不断增大，上述时间复杂度不断增大，算法地执行效率越低. 、空间复杂度与时间复杂度类似，空间复杂度是指算法在计算机内执行时所需存储空间地度量.记作: ()(()) 我们一般所讨论地是除正常占用内存开销外地辅助存储单元规模.讨论方法与时间复杂度类似，不再赘述. （）渐进时间复杂度评价算法时间性能主要用算法时间复杂度地数量级(即算法地渐近时间复杂度)评价一个算法地时间性能. 、类似于时间复杂度地讨论，一个算法地空间复杂度( )()定义为该算法所耗费地存储空间，它也是问题规模地函数.渐近空间复杂度也常常简称为空间复杂度. 空间复杂度( )是对一个算法在运行过程中临时占用存储空间大小地量度.一个算法在计算机存储器上所占用地存储空间，包括存储算法本身所占用地存储空间，算法地输入输出数据所占用地存储空间和算法在运行过程中临时占用地存储空间这三个方面.算法地输入输出数据所占用地存储空间是由要解决地问题决定地，是通过参数表由调用函数传递而来地，它不随本算法地不同而改变.存储算法本身所占用地存储空间与算法书写地长短成正比，要压缩这方面地存储空间，就必须编写出较短地算法.算法在运行过程中临时占用地存储空间随算法地不同而异，有地算法只需要占用少量地临时工作单元，而且不随问题规模地大小而改变，我们称这种算法是“就地"进行地，是节省存储地算法，如这一节介绍过地几个算法都是如此；有地算法需要占用地临时工作单元数与解决问题地规模有关，它随着地增大而增大，当较大时，将占用较多地存储单元，例如将在第九章介绍地快速排序和归并排序算法就属于这种情况.文档收集自网络，仅用于个人学习 如当一个算法地空间复杂度为一个常量，即不随被处理数据量地大小而改变时，可表示为()；当一个算法地空间复杂度与以为底地地对数成正比时，可表示为()；当一个算法地空司复杂度与成线性比例关系时，可表示为().若形参为数组，则只需要为它分配一个存储由实参传送 内容： Q:如何获取时间？精度如何？ A: 1 使用time_t time( time_t * timer ) 精确到秒 计算时间差使用double difftime( time_t timer1, time_t timer0 ) 2 使用clock_t clock() 得到的是CPU时间精确到1/CLOCKS_PER_SEC秒 3 使用DWORD GetTickCount() 得到的是系统运行的时间精确到毫秒 4 如果使用MFC的CTime类，可以用CTime::GetCurrentTime() 精确到秒 5 要获取高精度时间，可以使用 BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency)获取系统的计数器的频率 BOOL QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount)获取计数器的值 然后用两次计数器的差除以Frequency就得到时间。 6 还有David的文章中提到的方法： Multimedia Timer Functions The following functions are used with multimedia timers. timeBeginPeriod/timeEndPeriod/timeGetDevCaps/timeGetSystemTime timeGetTime/timeKillEvent/TimeProc/timeSetEvent 精度很高 Q:GetTickCount()函数，说是毫秒记数，是真的吗，还是精确到55毫秒？ A: GetTickCount()和GetCurrentTime()都只精确到55ms(1个tick就是55ms)。如果要精确到毫秒，应该使用timeGetTime函数或QueryPerformanceCounter函数。具体例子可以参考QA001022 "VC++中使用高精度定时器"、QA001813 "如何在Windows实现准确的定时"和QA004842 "timeGetTime函数延时不准"。 Q:vc++怎样获取系统时间，返回值是什么类型的变量呢？ GetSystemTime返回的是格林威志标准时间 GetLocalTime，和上面用法一样，返回的是你所在地区的时间，中国返回的是北京时间VOID GetSystemTime( LPSYSTEMTIME lpSystemTime // address of system time structure ); 函数就可以获得了，其中LPSYSTEMTIME 是个结构体 含：年，月，日，周几，小时，分，秒，毫秒。 以下是Time的MSDN文档: Compatibility in the Introduction. Libraries LIBC.LIBSingle thread static library, retail versionLIBCMT.LIBMultithread static library, retail versionMSVCRT.LIBImport library for MSVCRT.DLL, retail version Return Value time returns the time in elapsed seconds. There is no error return. Parameter timer Storage location for time Remarks 几种排序的算法时间复杂度比较 1.选择排序：不稳定，时间复杂度 O(n^2) 选择排序的基本思想是对待排序的记录序列进行n-1遍的处理，第i遍处理是将L[i..n]中最小者与L[i]交换位置。这样，经过i遍处理之后，前i个记录的位置已经是正确的了。 2.插入排序：稳定，时间复杂度 O(n^2) 插入排序的基本思想是，经过i-1遍处理后,L[1..i-1]己排好序。第i遍处理仅将L[i]插入L[1..i-1]的适当位置，使得L[1..i] 又是排好序的序列。要达到这个目的，我们可以用顺序比较的方法。首先比较L[i]和L[i-1]，如果L[i-1]≤ L[i]，则L[1..i]已排好序，第i遍处理就结束了；否则交换L[i]与L[i-1]的位置，继续比较L[i-1]和L[i-2]，直到找到某一个位置j(1≤j≤i-1)，使得L[j] ≤L[j+1]时为止。图1演示了对4个元素进行插入排序的过程，共需要(a),(b),(c)三次插入。 3.冒泡排序：稳定，时间复杂度 O(n^2) 冒泡排序方法是最简单的排序方法。这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮。在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即“轻”的元素在下面，就交换它们的位置。显然，处理一遍之后，“最轻”的元素就浮到了最高位置；处理二遍之后，“次轻”的元素就浮到了次高位置。在作第二遍处理时，由于最高位置上的元素已是“最轻”元素，所以不必检查。一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序。 4.堆排序：不稳定，时间复杂度 O(nlog n) 堆排序是一种树形选择排序，在排序过程中，将A[n]看成是完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。 5.归并排序：稳定，时间复杂度 O(nlog n) 各种排序算法的时间耗费比较 //源代码如下： #include Qt系统运行时间差计算 在网上查了很多资料，发觉网上很多用Qt写的系统运行时间差的例子写的都不是很全，今天自己研究了一下，可以成功得显示日时分秒，觉得不错，就与大家分享了 #include地理时间计算方法
排序算法时间复杂度比较
数据结构各种排序算法的时间性能
各种排序算法比较
古代时间的计算方法
单片机C延时时间怎样计算
数据结构课程设计(内部排序算法比较_C语言)
排序算法时间复杂度比较
实现一个排序算法并统计其运行时间
c++程序计时
各种排序算法的总结和比较
三年级年月日计算方法
Matlab中计算程序运行时间的三种方法
排序算法比较实验报告
常用的排序算法的时间复杂度和空间复杂度
vc++获取系统时间和程序运行时间
几种排序的算法时间复杂度比较
各种排序算法的时间耗费比较
Qt系统运行时间差计算
相关文档
- 内排序算法时间计算
- 排序算法时间复杂度比较
- 选择排序算法运行时间测试(java)
- 排序算法时间复杂度比较
- C语言各种排序方法及其所耗时间比较程序
- 七种排序算法的比较及每种排序的上机统计时间
- 数据结构各种排序算法的时间性能.
- (完整word版)各种内排序算法的实现及性能比较
- 数据结构各种排序算法的时间性能
- 排序算法时间复杂度分析
- 内部排序算法比较课程设计报告(7种基本排序)
- 各种排序算法时间性能的比较讲解
- 数据结构各种排序算法的时间性能
- 几种排序的算法时间复杂度比较
- 常用的排序算法的时间复杂度和空间复杂度
- 各种排序算法的时间复杂度
- 常见排序算法的时间复杂度
- 内部排序算法的分析与比较
- 数据结构各种排序算法的时间性能
- 常用排序算法时间复杂度