时间复杂度

         在日常编程学习的过程中，我们是如何判断一个算法它的优劣好坏之分呢？在算法编写成可执行程序后，运行时需要消耗时间资源和空间资源，所以一般我们从时间和空间两个维度上去衡量算法的优劣，即时间和空间复杂度。时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。

        时间复杂度是一个数学函数，它定量描述了算法的运行时间。算法中基本操作的执行次数，为算法的时间复杂度。

void Func1(int N)
{
int count = 0;
for (int i = 0; i < N ; ++ i)
{
 for (int j = 0; j < N ; ++ j)
 {
 ++count;
 }
}
 
for (int k = 0; k < 2 * N ; ++ k)
{
 ++count;
}
int M = 10;
while (M--)
{
 ++count;
}

}

        就比如上图的Func1（），定量计算++count的执行次数为N*2+2*N+M;

        N = 10                F(N) = 130

        N = 100              F(N) = 10210

        N = 1000            F(N) = 1002010

        我们可以观察到，当N越来越大时，2*N+M对F（N）的影响越来越小

        实际上，我们可以用clock函数来表示程序调用的时间（clock函数表示从程序调用开始到运行clock函数所调用的时间）

         在上图中，我们可以清晰地认识到，由于cpu每秒能够执行的语句非常多，所以当N比较小的时候，计算机执行的时间非常短，这个时候谈论最高阶项后面的项没有多大意义，而当N比较大时，后面的项对最高阶项的影响所以我们在考虑时间复杂度时，也一般只考虑最高阶项

那么这 里我们使用大O 的渐进表示法。 其规则如下：

        

大 O 符号（ Big O notation ）：是用于描述函数渐进行为的数学符号

1 、用常数 1 取代运行时间中的所有加法常数。

2 、在修改后的运行次数函数中，只保留最高阶项。

3 、如果最高阶项存在且不是 1 ，则去除与这个项目相乘的常数。得到的结果就是大 O 阶。

使用大 O 的渐进表示法以后， Func1 的时间复杂度为O（N^2）

同时我们需要注意，在实际中我们一般关注算法最坏的运行情况，就比如查找数组中的某个数，运气好可能第一次就找到了。运气不好可能要N次，所以我们取时间复杂度为O（N）。

下面我们看一些例子：

1、

void Func2(int N)
{
 int count = 0;
 for (int k = 0; k < 2 * N ; ++ k)
 {
 ++count;
 }
 int M = 10;
 while (M--)
 {
 ++count;
 }
 printf("%d\n", count);
}

在这个代码中，++count运行了2*N+M次

所以O（N）= N

2、

void Func3(int N, int M)
{
 int count = 0;
 for (int k = 0; k < M; ++ k)
 {
 ++count;
 }
 for (int k = 0; k < N ; ++ k)
 {
 ++count;
 }
 printf("%d\n", count);
}

在这个代码中，++count运行了M+N次，所以O（N）= M+N

时间复杂度中也可以出现两个字母，当M远大于N时，复杂度为O（M）；反之则为O(N).

3、

void Func4(int N)
{
 int count = 0;
 for (int k = 0; k < 100; ++ k)
 {
 ++count;
 }
 printf("%d\n", count);
}

在这个代码中，++count运行了常数100次，所以时间复杂度为O（1）

4、

void BubbleSort(int* a, int n)
{
 assert(a);
 for (size_t end = n; end > 0; --end)
 {
 int exchange = 0;
 for (size_t i = 1; i < end; ++i)
 {
 if (a[i-1] > a[i])
 {
 Swap(&a[i-1], &a[i]);
 exchange = 1;
 }
 }
 if (exchange == 0)
 break;
 }
}

在这段代码中，++count运行了（N*（N+1））/2

所以时间复杂度为O（N^2）

5、

long long Fib(size_t N)
{
 if(N < 3)
 return 1;
 
 return Fib(N-1) + Fib(N-2);
}

在这段代码中，程序运行了2^N次，所以时间复杂度为O（2^N）