算法中的精确时间计数器的应用

关注

原创最新推荐文章于 2025-11-09 02:56:55 发布 1.2k 阅读 AI 写同款· GEO 优化 ›

算法设计：案例分析1（计数器控制的循环）举个例子：一个有10名学生的班级进行了一次测试，每个学生的成绩（0·····100范围内的整数）已知。确定本次测验中的班级平均成绩。首先，用伪码列出要执行的动作并指定它们的执行顺序。我们用计数器控制的循环每次输入一个成绩。用一个变量控制一组语句执行的次数。 ······························································ 阅读详情

算法中的精确时间计数器的应用

流浪狗 2006.3

评价一个算法的好坏，在运行时所消耗的时间是一个很重要的参数，可以反应出该算法的时间复杂度。要测试一个程序运行时所消耗的时间，我们可以写出很多种算法。很多编译器都提供了相关的时间函数库，还有系统的API等等。但是，我们会发现这些函数在程序中根本本能得到满意的结果。有时候设计得很好的算法，或者很小的算法，在运行的时候非常快，在1ms以内，这时候要测试这个算法所消耗的时间就是一件不容易的事情。

在头文件time.h中有个函数clock(),返回clock_t的类型，可以通过两次调用clock函数，来确定时间间隔。API中有一个函数叫做GetTickCount的函数，可以得到当前计算机运行的时间，它返回一个DWORD值。在程序短之前加入一句DWORD t=GetTickCount();在程序段后加入t=GetTickCount()-t,则t的结果就是此程序段运行的时间。但是我们会发现很多程序段的结果输出都是0ms，所以我们需要比这个精度更高的函数。有没有这样的函数呢，通过查询MSDN，发现有两个函数满足要求，QueryPerformanceFrequency和QueryPerformanceCounter，它可以精确到0.5微秒,具体说明可以参见MSDN。为了方便我们以后在对算法时间的计算，我们把他封装成一个计时器类：

#include <windows.h>
#include<iostream.h>

using namespace std;

class TimeTake{
public:
TimeTake():dCount(0)
{
  // 获得计数器的时钟频率
  QueryPerformanceFrequency(&lPoint);
  dFreq=(double)lPoint.QuadPart;
}
~TimeTake()
{
}
void print()
{
  cout<<dCount<<" ms elapse in the algothim!"<<endl;
}
void start()
{
  //第一次取计数器的值
  QueryPerformanceCounter(&lPoint);
  lPart=lPoint.QuadPart;
}
void end()
{
  //再一次取计数器的值并计算中间的时间间隔，表示成ms
  QueryPerformanceCounter(&lPoint);
  dCount=(double(lPoint.QuadPart-lPart)/dFreq)*1000;
}
private:
LARGE_INTEGER lPoint;
LONGLONG lPart;
double dFreq, dCount;
};

我们可以写三个算法，用其对他们进行测试，下面几个算法都是求最大公约数的问题，第二个是第一个算法的改进，第三个是求使得a*m+b*n=d的最大公因数，详细算法如下：

DWORD mode1(DWORD m,DWORD n)
{
int r=m%n;
while(r!=0)
{
  m=n;
  n=r;
  r=m%n;
}
return n;

}
DWORD mode2(DWORD m,DWORD n)
{
DWORD r,result;
while(1)
{
  r=m%n;
  if(r==0)
  {
   result=n;
   break;
  }

  m=n%r;
  if(m==0)
  {
   result=r;
   break;
  }

  n=r%m;
  if(n==0)
  {
   result=m;
   break;
  }

}
return result;
}

//求接a,b使得am+bn=d,d为最大公倍数
DWORD mode(DWORD m,DWORD n,int& a,int& b)
{
int al,bl; //求解al,bl使得al*m+bl*n=c;
DWORD c,d,q,r,t;
c=m;
d=n;
a=bl=0;
b=al=1;
while(1)
{
  q=c/d;
  r=c%d;
  if(r==0)
   break;
  else
  {
   c=d; d=r;
   t=al;
   al=a;
   a=t-q*a;
   t=bl;
   bl=b;
   b=t-q*b;
  }
}
return d;

}

然后编写主程序进行测试：

int _tmain(int argc, _TCHAR* argv[])

{

TimeTake tk;
int a,b;
DWORD m,n,d1,d2;
cout<<"please input m and n"<<endl;
cin>>m>>n;
while(n==0)
{
cout<<"n can't be zero,please input n again!"<<endl;
cin>>n;
}

tk.start();
d1=mode1(m,n);
cout<<"the mode 1's result is "<<d1<<endl;
tk.end();
tk.print();

tk.start();
d2=mode2(m,n);
cout<<"the mode 2's result is "<<d2<<endl;
tk.end();
tk.print();

tk.start();
d2=mode(m,n,a,b);
cout<<"the result is "<<a;
if(b>=0)
cout<<"*m+"<<b<<"*n="<<d2<<endl;
else
cout<<"*m"<<b<<"*n="<<d2<<endl;
tk.end();
tk.print();

return 0;
}

输出结果如下：

please input m and n
150
456
the mode 1's result is 6
1.9469 ms elapse in the algothim!
the mode 2's result is 6
1.23787 ms elapse in the algothim!
the result is -3*m+1*n=6
1.18842 ms elapse in the algothim!
Press any key to continue

通过多组数据的输入，我们可以肯定的是第二种算法比第一种算法用的时间少，因为第二种算法避免了第一种算法的重复赋值。但是第三种算法与前两种算法相比，体现出时间的不确定性，有时候时间处于前两种算法之间，有时候又比前两种都少。从表面上来看，第三种算法比前两种做的事情都要多，但是为什么他用的时间最少呢？