数据结构与算法-算法复杂度-CSDN博客


//旋转数组:给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
//思路一：循环k次，将数组所有元素往后移动k次
//循环语句，将最后一个数组存储起来，然后将数组整体往后移动一位，再将头数组元素赋值为最后一个数组
void rotate(int* nums, int numsSize, int k) {
	while (k--)
	{
		int end = nums[numsSize - 1];
		for (int i = numsSize - 1; i >0; i--)
		{
			nums[i] = nums[i - 1];
		}
		nums[0] = end;
	}
}

运行后可以发现都是通过，但是提交的时候却发生了问题

可以看出这里显示了超出了时间限制，于是我们便可引入复杂度的概念。

2.1 复杂度的概念

算法在编写成可执行程序后，运行时需要耗费时间资源和空间资源。因此，衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。

时间复杂度主要是衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行时候所需要的额外空间（注意，是在运行之后的额外空间）

由于现在计算机技术的飞速发展，计算机能够储存的空间越来越大，空间复杂度并不是我们过度关注的点，时间复杂度关注的会更多一点。

三. 时间复杂度

在计算机科学中，算法的时间复杂度是一个函数式T(N)，它定量描述了该算法的运行时间。时间复杂度是衡量程序的时间效率

那为什么不去计算程序的运行时间呢，反而还要创建时间复杂度这个概念呢？

1. 因为程序运行时间和编译环境和运行机器的配置都有关系，比如同一个算法程序，用一个老编译器进行编译和新编译器编译，在同样的机器下运行时间是不同的。

2. 同一个算法程序，用一个老低配置机器和高新配置机器，运行时间也不同。

3. 并且时间只能在程序写好后测试，不能在写程序前通过理论思想计算评估。

那么算法的时间复杂度是一个函数式，这个函数式计算了程序的执行次数。算法程序被编译后生成二进制指令，程序运行，就是cpu执行这些编译好的二进制指令，我们通过程序代码或者理论思想计算出程序的执行次数的函数式T(N)，假设指令执行时间基本一样，那么执行次数和执行时间就是等比正相关，这样也脱离了具体的编译运行环境。执行次数就可以代表程序时间效率的优劣。

例如，算法a程序T(N)=N,算法b程序T(N)=N^2,那么算法a的效率一定优于算法b。

// 请计算⼀下Func1中++count语句总共执⾏了多少
次？ 
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; 
     } 
}

通过算法程序我们可知T(N)=N^2+2N+10

如果N越来越大我们可以发现，N^2的影响对于整个函数是最大的。

实际上在我们计算时间复杂度的时候，计算的也不是程序的精确的执行次数，精确的执行次数计算起来还是很麻烦的，意义也不是很大。

上面我们已经看到了当N不断变大时常熟和低阶项对结果的影响很小，所以我们只需要计算程序能代表增常量级的大概执行次数，复杂度的表示通常使用大O的渐进表示法

3.1 大O的渐进表示法

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

推导大O阶规则：

1.时间复杂度函数式T(N)中，只保留最高阶项，去掉那些低阶项，因为当N不断变大时，低阶项对结果影响越来越小，当N无穷大时，就可以忽略不计了。

2. 如果最高阶存在且不是1，则去除这个项目的常熟系数，因为当N不断变大，这个系数对结果影响越来越小，当N无穷大时，就可以忽略不计了。

3.T(N)中如果没有N相关的项目，只有常数项，用常熟1取代所有加法常熟。

所有，通过以上方法，我们可以得到Func1的时间复杂度为：O(N^2)

3.2 时间复杂度计算示例

3.2.1 示例1

// 计算Func2的时间复杂度？ 
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); 
}

T(N)=2N+10

根据推理得时间复杂度为O(N)

3.2.2 示例2

// 计算Func3的时间复杂度？ 
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); 
}

T(N)=M+N

时间复杂度为O(N)

3.2.3 示例3

// 计算Func4的时间复杂度？ 
void Func4(int N) 
{ 
 int count = 0; 
 for (int k = 0; k < 100; ++ k) 
 { 
     ++count; 
 } 
 printf("%d\n", count); 
}

T(N)=100

时间复杂度为O(1)

3.2.4 示例4

// 计算strchr的时间复杂度？ 
const char * strchr ( const char * str, int character)
    {
         const char* p_begin = s;
         while (*p_begin != character)
         {
             if (*p_begin == '\0')
             return NULL;
          p_begin++;
         }
         return p_begin;
    }

分情况：

1）若要查找的字符在字符串的首位，则T(N)=1

2）若在字符串中间，T(N)=N/2

3）若在字符串最后，T(N)=N

所以时间复杂度分别为O(1),O(N),O(N)

通过上面我们会发现，有些算法时间复杂度存在最好，最坏的情况

最坏情况：任意输入规模的最大运行次数（上界）

平均情况：任意输入规模的期望运行次数

最好情况：任意输入规模的最小运行次数（下界）

大O的渐进表示法在实际中一般情况关注的是算法的上界，也就是最坏运行的情况

3.2.5 示例5

// 计算BubbleSort的时间复杂度？ 
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; 
     } 
}

1）若数组有序，则T(N)=N

2）若数组有序且为降序，则T(N)=(N*(N+1))/2

因此最差情况为O(N^2)

3.2.6 示例6

void func5(int n)
{
 int cnt = 1;
 while (cnt < n)
 {
 cnt *= 2;
 }
}

当n=2时，执行次数为1

当n=4时，执行次数为2

当n=6时，执行次数为3

当n=x时，执行次数时log 2 n（以2为底n的对数）

所以时间复杂度0(log2n）

注意课件中和书籍中log2n，logn，lgn的表示

当n接近无穷大时，底数的大小对结果影响不大。因此，一般情况下不管底数是多少都可以省略不写，所以可以表示为logn

3.2.7 示例7

long long Fac(size_t N)
{
    if(0==N)
    return 1;
return Fac(N-1)*N;
}

阶乘递归的时间复杂度为O(n)

四. 空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中因为算法的需要额外临时开辟的空火箭。

空间复杂度不是程序占用了多少btyes的空间，因为常规情况每个对象大小差异不会很大，所以空间复杂度算的是变量的个数

空间复杂度也是使用大O渐进法

注意：函数运行时所需要的栈空间（存储参数、局部变量、一些寄存器信息等）在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显示申请的额外空间来确定

4.1 空间复杂度示例

4.1.1 示例1

// 计算BubbleSort的时间复杂度？ 
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; 
 } 
}

空间复杂度为O(1)