复杂度：如何衡量程序运行效率

复杂度：如何衡量程序运行效率

---

如果一个效率低下的系统是离线的，

那么它会让开发周期、测试周期变得很长

如果如果一个效率低下的系统是在线的，

那么它随时具有时间爆炸和内存爆炸的可能性

衡量代码的运行效率是一项非常重要的基本功

复杂度是什么

复杂度是衡量代码运行效率的重要的度量因素

计算机通过一个个程序去执行计算任务，也就是对输入数据进行加工处理，并最终的到结果的过程。

每个程序都是有代码构成的，可见编写代码的核心就是要完成计算。

但对于同一个计算任务，不同计算方法得到结果的过程复杂程度是不一样的

这就对实际任务处理效率就有很大影响

如何衡量复杂度

1.这段代码消耗的资源是什么？

代码执行过程中会消耗计算时间和计算空间，那么衡量的就是时间复杂度和空间复杂度

2.这段代码对于资源的消耗是多少？

不管是时间还是空间，它们的消耗程度都与输入的数据量高度有关

为了更客观的衡量消耗程度，通常会关注时间或空间消耗量与输入数据量之间的关系

复杂度是一个关于输入数据量n的函数

假设代码复杂度是f(n)—>O(f(n))

例如：

O(n)表示的是，复杂度与计算实例的个数n线性相关

O(log n)表示的是，复杂度与计算实例的个数n对数相关

复杂度计算方法遵循的原则

1.复杂度与具体的常系数无关

例如O(n)和O(2n)表示同样的复杂度

O(2n)=O(n+n)=O(n)+O(n)

一段复杂度的代码只是先后执行两遍，其复杂度是一致的

2.多项式的复杂度相加的时候，选择高者作为结果

例如O(n²)+O(n)和O(n²)表示同样的复杂度

O(n²)+O(n)=O(n²+n)

随着n越来越大，二阶多项式的变化率是比一阶多项式要大的，

因此，只需要通过更大变化率的二阶多项式来表示复杂度就可以

3.O(1)也表示一个特殊复杂度

含义为某个任务通过有限可数的资源即可完成

有限可数的的具体意义是：与输入数据量n无关

例如，代码处理10条数据需要消耗5个单位的时间资源，3个单位的空间资源

处理1000条数据还是只需要消耗5个单位的时间资源，3个单位的空间资源

//例如输入a=[1,2,3,4,5],输出[5,4,3,2,1]
public void s1(){
    int a[] = {1,2,3,4,5,};
    int b[] = new int[5];
    for(int i=0; i<a.length; i++){//给b初始化
        b[i] = a[i];
    }
    for(int i=0; i<a.length; i++){//给b赋值
        b[a.length-i-1] = a[i];
    }
    System.out.println(Arrays.toString(b));
}
//时间复杂度是O(n)+O(n)，也就是O(n)
//空间复杂度是O(n)
public void s2(){
    int a[] = {1,2,3,4,5,};
    int temp = 0;
    for(int i=0; i<(a.length/2); i++){//交换首尾对应的元素
        temp = a[i];
        a[i] = a[a.length-1];
        a[a.length-1] = temp;
    }
    System.out.println(Arrays.toString(b));
}
//时间复杂度是O(n/2)，也就是O(n)
//空间复杂度是O(1)

对于同一个问题，采用不同编码方法，对时间和空间的消耗有可能是不一样的

时间复杂度与代码结构的关系

//例1：定义一个数组a = [1,4,3],查找数组a中的最大值
public void s3(){
    int a = {1,4,3};
    int max = -1;
    int max_index = -1;
    for(int i=0; i<a.length; i++){//暂存当前最大值，遍历所有元素
        if(a[i]>max){
            max = a[i];
            max_index = i;
        }
    }
    System.out.println(max);
}
//时间复杂度是O(n)
//例2：定义一个数组a = [1,3,4,3,4,1,3],在这个数组中查找出出现次数最多的数字
public void s4(){
    int a = {1,3,4,3,4,1,3};
    int max = -1;
    int time_max = 0;
    int time_temp = 0;
    for(int i=0; i<a.length; i++){//对每个元素遍历
        time_temp=0;
        for(int i=0; i<a.length; i++){//对每个元素计算出现的次数
           if(a[i] == a[j]){
               time_temp += 1;
           }
           if(time_temp > time_max){//比较当前最大次数和全局最大次数
               time_max = time_temp;
               max = a[i];
           } 
        }
    }
    System.out.println(max);
}
//由于是双层循环,时间复杂度是O(n^2)

时间复杂度与代码的结构设计高度相关

空间复杂度与代码中数据结构的选择高度相关

一些经验性的的结论

1.一个顺序结构的代码，时间复杂度是O(1)

2.二分查找，或者更通用的说是采用分而治之的二分策略时间复杂度都是O(log n)

3.一个简单的for循环，时间复杂度是O(n)

4.两个顺序执行的for循环时间复杂度是O(n)+O(n)=O(2n)，也就是O(n)

5.两个嵌套的for循环，时间复杂度是O(n²)

降低时间复杂度的必要性

实际在线环境中，用户的访问请求可以看做一个流式数据

假设这个数据流中，每个访问的平均时间是 t，

如果代码无法在 t 时间内处理完单次的访问需求，那么这个系统最终被大量积压的任务给压垮

这就要求程序员必须通过优化代码，用户数据结构，来降低时间复杂度