获取程序运行时间以判别算法优劣

最新推荐文章于 2023-06-13 20:00:27 发布
最新推荐文章于 2023-06-13 20:00:27 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： 数据结构学习笔记 文章标签： 数据结构 算法优劣 clock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ramay7/article/details/48161999
版权

clock():捕捉从程序开始运行到clock()被调用所耗费的时间，这个时间单位是clock tick，即“时钟打点”。

常数CLK_TCK:机器时钟每秒所走的时间打点数

源代码示例：

#include <stdio.h>
#include <time.h>
clock_t start,stop;//clock_t是clock()函数返回的变量类型
double duration;//记录被测函数运行时间，以秒为单位 
int main()
{
	/*不在测试范围内的准备工作写在clock()之前*/
	start=clock();//开始计时 
	MyFunction();//把被测函数加在里面 
	stop=clock();//停止计时 
	duration=(double(stop-start))/CLK_TCK; //计算运行时间
	/*其他不在测试范围内的处理写在后面，例如输出duration的值*/ 
    return 0;
}

例如：计算下面式子的两个算法比较。



源代码：

#include <stdio.h>
#include <math.h>
#include <time.h>
clock_t start,stop;
double duration;
#define MAXN 10		//多项式项数，即多项式最大阶数加一 
double fun1(double a[],int n,double x);//n为数组最大下标 
double fun2(double a[],int n,double x);
int main()
{
	int i;
	double a[MAXN];	//存储系数
	for(i=0;i<MAXN;i++){//初始化 
		a[i]=i;
	} 
	start=clock();
	fun1(a,MAXN,1.1);
	stop=clock();
	duration=((double)(stop-start))/CLK_TCK;
	printf("ticks1=%f\n",(double)(stop-start));
	printf("duration1=%6.2e\n",duration);
	
	start=clock();
	fun2(a,MAXN,1.1);
	stop=clock();
	duration=((double)(stop-start))/CLK_TCK;
	printf("ticks1=%f\n",(double)(stop-start));
	printf("duration2=%6.2e\n",duration);
    return 0;
}
double fun1(double a[],int n,double x){//直接逐项计算 
	int i;
	double result=a[0];
	for(i=1;i<=n;i++){
		result+=(a[i]*pow(x,i));
	}
	return result;
}
double fun2(double a[],int n,double x){//将f(x)看成f(x)=a0+x*(a1+x*(...(an-1+x*(an))...)) 
	int i;
	double result=a[n];
	for(i=n;i>0;i--){
		result=a[i-1]+x*result;
	}
	return result;
}

运行结果：


之所以结果都是0，这是因为程序跑得太快，捕捉时间太短。于是，可以利用重复多次运行程序方法进行比较。

修改代码如下：

#include <stdio.h>
#include <math.h>
#include <time.h>
clock_t start,stop;
double duration;
#define MAXK 1e7	//被测函数最大重复调用次数 
#define MAXN 10		//多项式项数，即多项式最大阶数加一 
double fun1(double a[],int n,double x);//n为数组最大下标 
double fun2(double a[],int n,double x);
int main()
{
	int i;
	double a[MAXN];	//存储系数
	for(i=0;i<MAXN;i++){//初始化 
		a[i]=i;
	} 
	start=clock();
	for(i=0;i<MAXK;i++){//重复调用函数以获得充分多的时钟打点数 
		fun1(a,MAXN,1.1);
	}
	stop=clock();
	duration=((double)(stop-start))/CLK_TCK/MAXK;//计算函数单次运行时间 
	printf("ticks1=%f\n",(double)(stop-start));
	printf("duration1=%6.2e\n",duration);
	
	start=clock();
	for(i=0;i<MAXK;i++){
		fun2(a,MAXN,1.1);
	}
	stop=clock();
	duration=((double)(stop-start))/CLK_TCK/MAXK;
	printf("ticks1=%f\n",(double)(stop-start));
	printf("duration2=%6.2e\n",duration);
    return 0;
}
double fun1(double a[],int n,double x){//直接逐项计算 
	int i;
	double result=a[0];
	for(i=1;i<=n;i++){
		result+=(a[i]*pow(x,i));
	}
	return result;
}
double fun2(double a[],int n,double x){//将f(x)看成f(x)=a0+x*(a1+x*(...(an-1+x*(an))...)) 
	int i;
	double result=a[n];
	for(i=n;i>0;i--){
		result=a[i-1]+x*result;
	}
	return result;
}

运行：


可见算法1的要比算法2大得多，算法2更好。


再如：

源代码：

#include <stdio.h>
#include <math.h>
#include <time.h>
clock_t start,stop;
double duration;
#define MAXK 1e5	//被测函数最大重复调用次数 
#define MAXN 101	//多项式项数，即多项式最大阶数加一 
double fun1(double x);
double fun2(double x);
int main()
{
	int i;
	start=clock();
	for(i=0;i<MAXK;i++){//重复调用函数以获得充分多的时钟打点数 
		fun1(1.1);
	}
	stop=clock();
	duration=((double)(stop-start))/CLK_TCK/MAXK;//计算函数单次运行时间 
	printf("ticks1=%f\n",(double)(stop-start));
	printf("duration1=%6.2e\n",duration);
	
	start=clock();
	for(i=0;i<MAXK;i++){
		fun2(1.1);
	}
	stop=clock();
	duration=((double)(stop-start))/CLK_TCK/MAXK;
	printf("ticks1=%f\n",(double)(stop-start));
	printf("duration2=%6.2e\n",duration);
    return 0;
}
double fun1(double x){//利用递归逐项累加 
	int i;
	double result=1.0;
	for(i=1;i<MAXN;i++){
		result+=(pow(x,i)/i);
	}
	return result;
}
double fun2(double x){//先对加数项进行预算 
	int i=1;
	double temp=x;
	double result=1.0;
	while(i<MAXN){
		result+=x;
		x*=temp*i/(i+1);
		i++;
	}
	return result;
}


注意，这里的最大重复调用次数是1e5

运行效果：


算法还是不够简洁，可以仿照上面的例子，利用数组初始化。

修改代码如下：

#include <stdio.h>
#include <math.h>
#include <time.h>
clock_t start,stop;
double duration;
#define MAXK 1e5	//被测函数最大重复调用次数 
#define MAXN 101	//多项式项数，即多项式最大阶数加一 
double fun1(double a[],int n,double x);
double fun2(double a[],int n,double x);
int main()
{
	int i;
	double a[MAXN];
	for(i=1;i<MAXN;i++){
		a[i]=1.0/i;
	}
	start=clock();
	for(i=0;i<MAXK;i++){//重复调用函数以获得充分多的时钟打点数 
		fun1(a,MAXN,1.1);
	}
	stop=clock();
	duration=((double)(stop-start))/CLK_TCK/MAXK;//计算函数单次运行时间 
	printf("ticks1=%f\n",(double)(stop-start));
	printf("duration1=%6.2e\n",duration);
	
	start=clock();
	for(i=0;i<MAXK;i++){
		fun2(a,MAXN,1.1);
	}
	stop=clock();
	duration=((double)(stop-start))/CLK_TCK/MAXK;
	printf("ticks1=%f\n",(double)(stop-start));
	printf("duration2=%6.2e\n",duration);
    return 0;
}
double fun1(double a[],int n,double x){//利用递归逐项累加 
	int i;
	double result=1.0;
	for(i=1;i<MAXN;i++){
		result+=(pow(x,i)*a[i]);
	}
	return result;
}
double fun2(double a[],int n,double x){//先对加数项进行预算 
	int i=1;
	double temp=x;
	double result=1.0;
	while(i<MAXN){
		result+=x;
		x*=temp*a[i+1]/a[i];
		i++;
	}
	return result;
}

效果：


额，仿佛也还是那回事敲打。那再思考下，既然在第一个例子中“将f(x)看成f(x)=a0+x*(a1+x*(...(an-1+x*(an))...))”那么这道题也可以用同样的思想：

#include <stdio.h>
#include <math.h>
#include <time.h>
clock_t start,stop;
double duration;
#define MAXK 1e5	//被测函数最大重复调用次数 
#define MAXN 101	//多项式项数，即多项式最大阶数加一 
double fun1(double a[],int n,double x);
double fun2(double a[],int n,double x);
double fun3(double a[],int n,double x);
int main()
{
	int i;
	double a[MAXN];
	for(i=1;i<MAXN;i++){
		a[i]=1.0/i;
	}
	start=clock();
	for(i=0;i<MAXK;i++){//重复调用函数以获得充分多的时钟打点数 
		fun1(a,MAXN,1.1);
	}
	stop=clock();
	duration=((double)(stop-start))/CLK_TCK/MAXK;//计算函数单次运行时间 
	printf("ticks1=%f\n",(double)(stop-start));
	printf("duration1=%6.2e\n",duration);
	
	start=clock();
	for(i=0;i<MAXK;i++){
		fun2(a,MAXN,1.1);
	}
	stop=clock();
	duration=((double)(stop-start))/CLK_TCK/MAXK;
	printf("ticks1=%f\n",(double)(stop-start));
	printf("duration2=%6.2e\n",duration);
	
	start=clock();
	for(i=0;i<MAXK;i++){
		fun3(a,MAXN,1.1);
	}
	stop=clock();
	duration=((double)(stop-start))/CLK_TCK/MAXK;
	printf("ticks3=%f\n",(double)(stop-start));
	printf("duration3=%6.2e\n",duration);
    return 0;
}
double fun1(double a[],int n,double x){//利用递归逐项累加 
	int i;
	double result=1.0;
	for(i=1;i<MAXN;i++){
		result+=(pow(x,i)*a[i]);
	}
	return result;
}
double fun2(double a[],int n,double x){//先对加数项进行预算 
	int i=1;
	double temp=x;
	double result=1.0;
	while(i<MAXN){
		result+=x;
		x*=temp*a[i+1]/a[i];
		i++;
	}
	return result;
}
double fun3(double a[],int n,double x){
	int i;
	double result=a[MAXN-1];
	for(i=MAXN-1;i>1;i--){
		result=a[i-1]+x*result;
	}
	return result+1.0;
}


跑了几次，感觉2和3差不多... 敲打



那就酱吧。敲打

ramay7
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】代码时间判断
tianty1121的博客
07-21 347
声明：参考自MOOC浙大课程 代码时间判断 判断一串代码的好坏，可以调用一个函数clock(): 这个函数可以捕捉程序开始运行到clock()被调用时所耗费的时间。 这个时间单位是clock tick，即“时钟打点”，注意这里不是秒。 想要观察秒数的不同需要除以CLK _TCK。 常数CLK_TCK：机器时钟每秒所走的时钟打点数。 /*clock_t是clock()函数返回的变量类型 duration记录被测函数运行时间，以秒为单位 (double)(stop-start)/CLK_TCK;是将机器打点时
【Java】Java中计算程序运行耗时的方法对比（时间）
qq_30885821的博客
04-27 4196
Java中测试程序代码运行时间的方式有两种： 第一种：以毫秒为单位计算的。 long startTime=System.currentTimeMillis(); //下面是一些测试代码：耗时操作 for(int i=0;i<10000;i++){ System.out.println("当前是："+i); } long endTime=System.currentTimeMillis(); System.out.println("当前程序耗时："+（endTime-startTime）+"ms"
clock（）函数计算代码运行时间
lyl20040822的博客
03-26 133
clock（）：捕捉从程序开始运行到clock（）被调用所耗费的时间。这个时间单位是clock tick，即“时间打点”。常数CLK_TCK:机械时钟每秒钟所走的时钟打点数。
C语言时间函数
mengao1999的博客
05-12 330
C语言 时间函数 / 计时进行 /测试函数运行时间/ #include<stdio.h> #include<time.h> //利用clock()函数进行计时，他是记录从mian函数开始的时钟打点数 #define MAXK 1e7 //被测试函数被调用的次数 clock_t start, stop; //clock_t是clock()函数返回的变量类型 double num; //记录被测试函数运行的时间，以秒为单位 int myFunction(int n); int m
如何分析程序的时间消耗
前路漫漫的博客
09-23 2241
总结一些常用的方法，思考如何分析一个程序的时间消耗。 1.  Trace Log  这个是大家最常用，也是最简单和有效地方法。通常是在函数的开始和结束的位置加入Log, 最后通过Log记录时间统计函数的时间消耗。 有时嫌2次log太麻烦，我们可以通过RAII进行封装： class CTimeCostDebug { public:  CTimeCostDebug(L
现在用MATLAB软件编写程序来实现LMSE算法计算判别函数.doc
05-12
"使用MATLAB软件编写程序来实现LMSE算法计算判别函数" 在这篇文章中，我们将讨论如何使用MATLAB软件编写程序来实现LMSE（Least Mean Square Error，最小二乘法）算法计算判别函数。LMSE算法是一种常用的机器学习...
基于广义判别分析算法的matlab程序.zip_判别分析_广义判别分析算法
09-20
这个压缩包“基于广义判别分析算法的matlab程序”很可能包含了一系列的MATLAB脚本和函数，用于实现上述过程。用户可以通过运行这些脚本来学习如何在实际项目中应用GDA。这不仅可以加深对算法的理解，也有助于提升...
Fisher线性判别算法描述
12-20
Fisher线性判别算法（Fisher's Linear Discriminant Analysis, LDA）是一种经典的数据降维和分类方法，尤其在机器学习和统计学领域中广泛应用。它的主要目标是找到一个线性变换，使得数据在新的坐标系下，各类别的...
一个VB数理统计程序——逐步判别算法
05-12
标题中的“一个VB数理统计程序——逐步判别算法”表明这是一个使用Visual Basic（VB）编程语言编写的软件，主要用于数理统计领域的分析，特别是采用了逐步判别算法。逐步判别算法是一种在分类问题中常用的数据挖掘...
测试程序运行时间
12-22
功 能: 返回处理器调用某个进程或函数所花费的时间。 　　用 法: clock_t clock(void); 　　说明：clock_t其实就是long，即长整形。该函数返回值是硬件滴答数，要换算成秒或者毫秒，需要除以CLK_TCK或者 CLK_TCK CLOCKS_PER_SEC。比如，在VC++6.0下，这两个量的值都是1000，这表示硬件滴答1000下是1秒，因此要计算一个进程的时间，用clock()除以1000即可
算法源码-分类与判别：基于Fisher算法的分类程序.zip
06-06
《算法源码-分类与判别：基于Fisher算法的分类程序》 在这个压缩包中，包含的是一个基于Fisher算法的分类程序。Fisher算法，全称为Fisher线性判别分析（Fisher's Linear Discriminant Analysis, FDA），是统计学中...
时间复杂度
m0_62360926的博客
11-23 302
对于时间复杂度，我的理解其实就是一个代码的执行时间啦，时间复杂度低的代码运行快，时间复 杂度高的代码运行速度慢。 但这么说显然无法解释清楚时间复杂度，于是我去找了百度： 一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。 一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f (n)的极限值为不等于零的常数
算法运行时间、logN、NlogN 之间的比较
weixin_30580341的博客
01-27 834
1 大部分程序的大部分指令之执行一次，或者最多几次。如果一个程序的所有指令都具有这样的性质，我们说这个程序的执行时间是常数。 logN 如果一个程序的运行时间是对数级的，则随着N的增大程序会渐渐慢下来，如果一个程序将一个大的问题分解成一系列更小的问题，每一步都将问题的规 模缩减成几分之一，一般就会出现这样的运行时间函数。在我们所关心的范围内，可以认为运行时间小于...
实际案例4个测试学习算法的时间复杂度分析
黑马程序员官方博客
05-06 1167
在上一篇内容从0开始认识数据结构与算法，我们已经介绍了，研究算法的最终目的就是如何花更少的时间，如何占用更少的内存去完成相同的需求，并且 也通过案例演示了不同算法之间时间耗费和空间耗费上的差异，但我们并不能将时间占用和空间占用量化，因此， 接下来我们要学习有关算法时间耗费和算法空间耗费的描述和分析。有关算法时间耗费分析，我们称之为算法的时间复杂度分析，有关算法的空间耗费分析，我们称之为算法的空间复杂度分析。 一、算法的时间复杂度分析 我们要计算算法时间耗费情况，首先我们得度量算法的执行时间，那么如何度量
多种智能优化算法运行时间和不同函数测试对比附matlab代码
最新发布
matlab_dingdang的博客
06-13 925
智能优化算法是一种常用的求解最优化问题的方法，包括遗传算法、粒子群优化算法、蚁群算法等等。这些算法具有不同的优缺点和适用范围，因此在实际应用中需要进行对比。下面是一些常见的智能优化算法及其特点：遗传算法（GA）：通过模拟种群遗传过程来寻找最优解，具有全局搜索能力和收敛速度较快的特点。粒子群算法（PSO）：通过模拟粒子在解空间中的运动过程来寻找最优解，具有易于实现和求解速度快的特点。蚁群算法（ACO）：利用蚁群在食物与蚂蚁巢穴之间的搜索规律来寻找最优解，具有分布式搜索和适用于多目标优化等特点。
【cs基础】如何判断算法的好坏
菜鸟实验室
04-01 1981
算法复杂度 平时我们说算法的好坏，排除一些软件和硬件上的限制，怎么去衡量这个算法运行的更快呢？这就是Big O notation的作用啦！ Big O notation Big O notation是一种描述述函数渐进行为的理论，说白了，表达算法的增长趋势，一个算法会渐渐走向快速还是缓慢的表达方式。 这种渐进表达有三种记号来表示：O、 Θ 和 Ω 记号法。Θ 记号渐进地给出了一个函数的上界和下界，当
C语言如何统计程序运行时间
Lan_yangyanga的博客
08-21 6680
clock函数用法，计算程序运行时间。
如何衡量一个算法的优劣?
热门推荐
weixin_44826600的博客
04-24 1万+
一.通过计算算法的效率来衡量 算法效率分析分为两种：第一种是时间效率，第二种是空间效率。时间效率被称为时间复杂度，而空间效率 被称作空间复杂度。 时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要 的额外空间，在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机 行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值