如何评测一个算法的好坏算法就是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每个指令表示一个或者多个操

什么是算法

算法就是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每个指令表示一个或者多个操作。

算法的特性

输入特性必须由输入
有穷性不能是无限循环
确定性必须有确定的结果
可行性可以

算法设计要求

正确性
可读性
健壮性
时间效率⾼高和储存量量低

如何评测

比如求1到100之间所有数据的和，有下面两种算法

算法1：

int sum , n; n = 100; sum = 0;
for(int i = 0; i <= n ; i++)
{
    sum += i; 
}
printf(“%d”,sum);

算法2：

int sum = 0 , n = 100; sum = (1 + n) * n / 2;
printf(“%d”,sum);

像这种简单的算法，我们可以看出是第二种算法好些，但是在复杂的一些算法中，就需要我们按照标准进行评测了，那么算法的评测标准是什么呢？

一、算法正确性

这个是算法好坏的首要标准，也是最基本的要求。一个算法设计的再巧妙，不能正确的决算出结果，都是白费。

二、算法可读性

算法如果设计的晦涩难懂，注释也不清楚，其他人都看不懂，也不是一个好的算法。

三、算法的健壮性

在设计算法的时候，需要考虑各种边界情况，尽量保证算法在任何情况下，都不会出现问题。

四、时间效率⾼高和储存量量低

时间效率高

我们在评测时间效率高的时候，用的就是时间复杂度。常用的表示法是大O表示法。

时间复杂度时间复杂度是指执行算法所需要的计算工作量

大O表示法原则：

用常数1取代运行时间中所有常数 3->1 O(1)
在修改运行次数函数中,只保留最高阶项 n^3+2n^2+5 -> O(n^3)
如果在最高阶存在且不等于1,则去除这个项目相乘的常数 2n^3 -> n^3

时间复杂度术语:

常数阶

/* 1. 常数阶时间复杂度计算 O(1) */
//1+1+1 = 3 O(1)
void testSum1(int n){
   int sum = 0;                //执行1次
   sum = (1+n)*n/2;            //执行1次
   printf("testSum1:%d\n",sum);//执行1次
}

//1+1+1+1+1+1+1 = 7 O(1)
void testSum2(int n){
   int sum = 0;                //执行1次
   sum = (1+n)*n/2;            //执行1次
   sum = (1+n)*n/2;            //执行1次
   sum = (1+n)*n/2;            //执行1次
   sum = (1+n)*n/2;            //执行1次
   sum = (1+n)*n/2;            //执行1次
   printf("testSum2:%d\n",sum);//执行1次
   
}
//x=x+1; 执行1次
void add(int x){
   x = x+1;
}

线性阶线性阶时间复杂度

//x=x+1; 执行n次 O(n)
void add2(int x,int n){
   for (int i = 0; i < n; i++) {
       x = x+1;
   }
}

//1+(n+1)+n+1 = 3+2n -> O(n)
void testSum3(int n){
   int i,sum = 0;               //执行1次
   for (i = 1; i <= n; i++) {   //执行n+1次
       sum += i;                //执行n次
   }
   printf("testSum3:%d\n",sum);  //执行1次
}

平方阶

//x=x+1; 执行n*n次 ->O(n^2)
void add3(int x,int n){
   for (int i = 0; i< n; i++) {
       for (int j = 0; j < n ; j++) {
           x=x+1;
       }
   }
}

//n+(n-1)+(n-2)+...+1 = n(n-1)/2 = n^2/2 + n/2 = O(n^2)
//sn = n(a1+an)/2
void testSum4(int n){
   int sum = 0;
   for(int i = 0; i < n;i++)
       for (int j = i; j < n; j++) {
           sum += j;
       }
   printf("textSum4:%d",sum);
   
}

//1+(n+1)+n(n+1)+n^2+n^2 = 2+3n^2+2n -> O(n^2)
void testSum5(int n){
   int i,j,x=0,sum = 0;           //执行1次
   for (i = 1; i <= n; i++) {     //执行n+1次
       for (j = 1; j <= n; j++) { //执行n(n+1)
           x++;                   //执行n*n次
           sum = sum + x;         //执行n*n次
       }
   }
   printf("testSum5:%d\n",sum);
}

对数阶

/*2的x次方等于n x = log2n  ->O(logn)*/
void testA(int n){
   int count = 1;         //执行1次
   //n = 10
   while (count < n) {
       count = count * 2;
   }
   
}

立方阶

void testB(int n){
   int sum = 1;                         //执行1次
   for (int i = 0; i < n; i++) {        //执行n次
       for (int j = 0 ; j < n; j++) {   //执行n*n次
           for (int k = 0; k < n; k++) {//执行n*n*n次
               sum = sum * 2;          //执行n*n*n次
           }
       }
   }
}

nlog阶
指数阶(不考虑) O(2^n)或者O(n!) 除非是非常小的n,否则会造成噩梦般的时间消耗. 这是一种不切实际的算法时间复杂度. 一般不考虑!
最好的情况与最坏的情况
比如这种情况，如果我们要找上面这个数组中找到6，那么只走一次就找到了，如果我们要找1的话，就需要运行10次，一般在这种情况下，我们一般按照最大次数算

空间复杂度

算法的空间复杂度通过计算算法所需的存储空间实现,算法空间复杂度的计算公式记做: S(n) = n(f(n)),其中,n为问题的规模,f(n)为语句句关于n所占存储空间的函数空间计算因素有

寄存本身的指令
常数
变量
输入
对数据操作的辅助空间在考量算法的空间复杂度，主要考虑算法执行时所需要的辅助空间

int temp; //temp为辅助空间且为常数1 则空间复杂度为O（1）
for(int i = 0; i < n/2 ; i++){
    temp = a[i];
    a[i] = a[n-i-1];
    a[n-i-1] = temp;
}

总结

我们在评测算法好坏的过程中，在保证正确，可读，健壮的前提下，时间复杂度越低越好，空间复杂度越少越好，总之，要综合考虑。没有最好的，只有最适合的。

如何评测一个算法的好坏