深圳幻海软件技术有限公司 欢迎您!

【数据结构与算法】时间复杂度与空间复杂度

2023-03-14

目录一.前言二.时间复杂度1.概念二.大O的渐进表示法概念:总结:三.常见时间复杂度计算举例例1例2例3例4例5.计算冒泡排序的时间复杂度例6.二分算法的时间复杂度例7.阶乘递归Fac的时间复杂度例8.斐波那契递归的时间复杂度四.常见时间复杂度对比 五.空间复杂度概念例1例2例3一.前言从

目录

一.前言

二.时间复杂度

1.概念

二.大O的渐进表示法

概念:

总结:

三.常见时间复杂度计算举例

例1

例2

例3

例4

例5.计算冒泡排序的时间复杂度

例6.二分算法的时间复杂度

例7.阶乘递归Fac的时间复杂度

例8.斐波那契递归的时间复杂度

四.常见时间复杂度对比

 五.空间复杂度

概念

例1

例2

例3


一.前言

从这篇文章开始,C语言的学习就结束了,接下来将会开启数据结构与算法的学习。

早期,计算机刚被发明出来,内存空间并不是很大,所以不仅追求程序运行时的时间效率,还追求空间效率,但发展到今天,已经不太追求空间效率了,时间效率的追求是不变的。

下面就让我们一起学习时间复杂度和空间复杂度是什么吧~

二.时间复杂度

1.概念

1.时间复杂度是一个函数(注意这不是编程语言里的函数,而是数学意义上的函数)

2.这个函数指的是算法跑的次数的函数,并不是算法运行的时间,因为同一个算法在不同的机器上运行的时间可能是不同的,用算法的运行时间表示时间复杂度是欠妥的;

3.一个算法所花费的时间与其中语句的执行次数成正比例,算法中的基本操作的执行次数,为算法的时间复杂度。

二.大O的渐进表示法

概念:

大O符号(Big O notation):是用于描述函数渐进行为的数学符号。
推导大O阶方法:
1、用常数1取代运行时间中的所有加法常数
2、在修改后的运行次数函数中,只保留最高阶项
3、如果最高阶项存在且不是1,则去除与这个项目相乘的常数。得到的结果就是大O阶。

需要注意的是算法运行时可能会存在最好情况,最坏情况,平均情况,这个时候我们取最坏情况时的大O;

最坏情况:任意输入规模的最大运行次数(上界)
平均情况:任意输入规模的期望运行次数
最好情况:任意输入规模的最小运行次数(下界)

总结:

1.大O里的数就是函数表达式中对结果影响最大的项,或是最大的量级所在的项

2.如果这个项的系数不是1,那么将它变成1,简单来说,这个项前面的系数得是1

3.如果函数表达式是个常数,不管这个常数多大,都写成O( 1 )

光说不练假把式,让我们通过例题来更好的理解上述所说吧~


三.常见时间复杂度计算举例

例1

  1. // 请计算一下Func1中++count语句总共执行了多少次?
  2. void Func1(int N)
  3. {
  4. int count = 0;
  5. for (int i = 0; i < N ; ++ i)
  6. {
  7. for (int j = 0; j < N ; ++ j)
  8. {
  9. ++count;
  10. }
  11. }
  12. for (int k = 0; k < 2 * N ; ++ k)
  13. {
  14. ++count;
  15. }
  16. int M = 10;
  17. while (M--)
  18. {
  19. ++count;
  20. }
  21. printf("%d\n", count);
  22. }

不难看出:

Func1 执行的基本操作次数 :

             F(N)=N^2+2^N+10

  N = 10        F(N) = 130
  N = 100      F(N) = 10210
  N = 1000    F(N) = 1002010

显然最大的量级是 N^2

所以时间复杂度为O(N^2)


例2

  1. // 计算Func2的时间复杂度?
  2. void Func2(int N)
  3. {
  4. int count = 0;
  5. for (int k = 0; k < 2 * N ; ++ k)
  6. {
  7. ++count;
  8. }
  9. int M = 10;
  10. while (M--)
  11. {
  12. ++count;
  13. }
  14. printf("%d\n", count);
  15. }

F(N)=2*N+10

影响最大的项为2*N,因为它的系数不是1,所以要变成1,即

时间复杂度:O(N)


例3

  1. // 计算Func3的时间复杂度?
  2. void Func3(int N, int M)
  3. {
  4. int count = 0;
  5. for (int k = 0; k < M; ++ k)
  6. {
  7. ++count;
  8. }
  9. for (int k = 0; k < N ; ++ k)
  10. {
  11. ++count;
  12. }
  13. printf("%d\n", count);
  14. }

F(N)=M+N

由于并未明确告知M和N的关系,所以时间复杂度:O(M+N)

若M远大于N,则为O(M);

若N远大于M,则为O(N);

若亮着差不多大,则为O(N)或O(M);


例4

  1. // 计算Func4的时间复杂度?
  2. void Func4(int)
  3. {
  4. int count = 0;
  5. for (int k = 0; k < 100; ++ k)
  6. {
  7. ++count;
  8. }
  9. printf("%d\n", count);
  10. }

F(N)=100

这是一个常数,所以时间复杂度:O(1)


例5.计算冒泡排序的时间复杂度

不了解冒泡算法请戳我

  1. // 计算BubbleSort的时间复杂度?
  2. void BubbleSort(int* a, int n)
  3. {
  4. assert(a);
  5. for (size_t end = n; end > 0; --end)
  6. {
  7. int exchange = 0;
  8. for (size_t i = 1; i < end; ++i)
  9. {
  10. if (a[i-1] > a[i])
  11. {
  12. Swap(&a[i-1], &a[i]);
  13. exchange = 1;
  14. }
  15. }
  16. if (exchange == 0)
  17. break;
  18. }
  19. }

最好情况:

原本已排好序,所以进入第二个for循环时不进入if语句,所以exchange==0,直接跳出循环,所以时间复杂度:O(N)

最坏情况:

执行完了所有的循环,所以时间复杂度:O(N^2)

取最坏情况,所以最终的时间复杂度为:O(N^2)

如果没有exchange相关语句,那么最好情况和最坏情况都是O(N^2)


例6.二分算法的时间复杂度

  1. // 计算BinarySearch的时间复杂度?
  2. int BinarySearch(int* a, int n, int x)
  3. {
  4. assert(a);
  5. int begin = 0;
  6. int end = n-1;
  7. // [begin, end]:begin和end是左闭右闭区间,因此有=号
  8. while (begin <= end)
  9. {
  10. int mid = begin + ((end-begin)>>1);
  11. if (a[mid] < x)
  12. begin = mid+1;
  13. else if (a[mid] > x)
  14. end = mid-1;
  15. else
  16. return mid;
  17. }
  18. return -1;
  19. }

最好情况:

第一次就找到了,所以时间复杂度:O(1)

最坏情况:

找到就剩最后一个数才找到

设数组中有N个数,一共找了X次

所以

      N/(2*2*2*2.....*2)=1

     一共X个2,即:2^X=N  ->  X=logN(注意这是一个简写,真正的意思是以2为底的N的对数)

所以取最坏情况 ,时间复杂度:O(logN)


例7.阶乘递归Fac的时间复杂度

  1. long long Fac(size_t N)
  2. {
  3. if(0 == N)
  4. return 1;
  5. return Fac(N-1)*N;
  6. }

不难看出一共会递归N次,所以时间复杂度为:O(N)     


例8.斐波那契递归的时间复杂度

  1. // 计算斐波那契递归Fib的时间复杂度?
  2. long long Fib(size_t N)
  3. {
  4. if(N < 3)
  5. return 1;
  6. return Fib(N-1) + Fib(N-2);
  7. }

对于这种较复杂的时间复杂度的计算可以通过画图来观察;

 

 三角形那一块是缺失的部分;

通过上图我们发现,一共会执行F(N)=2^N-X(这个X是一个常数)

所以时间复杂度:O(2^N)


四.常见时间复杂度对比

一般算法常见的复杂度如下:

 


 五.空间复杂度

概念

1.空间复杂度也是一个数学表达式,是对一个算法在运行过程中临时占用存储空间大小的量度;
2.空间复杂度不是程序占用了多少bytes的空间,因为这个也没太大意义,所以空间复杂度算的是变量的个数;
3.空间复杂度计算规则基本跟实践复杂度类似,也使用大O渐进表示法;
注意:函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了,因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

例1

  1. // 计算BubbleSort的空间复杂度?
  2. void BubbleSort(int* a, int n)
  3. {
  4. assert(a);
  5. for (size_t end = n; end > 0; --end)
  6. {
  7. int exchange = 0;
  8. for (size_t i = 1; i < end; ++i)
  9. {
  10. if (a[i-1] > a[i])
  11. {
  12. Swap(&a[i-1], &a[i]);
  13. exchange = 1;
  14. }
  15. }
  16. if (exchange == 0)
  17. break;
  18. }
  19. }

显然上面的代码带上形参共有5个变量,根据大O渐进法的规则,空间复杂度:O(1);

例2

  1. // 计算Fibonacci的空间复杂度?
  2. // 返回斐波那契数列的前n项
  3. long long* Fibonacci(size_t n)
  4. {
  5. if(n==0)
  6. return NULL;
  7. long long * fibArray = (long long *)malloc((n+1) * sizeof(long long));
  8. fibArray[0] = 0;
  9. fibArray[1] = 1;
  10. for (int i = 2; i <= n ; ++i)
  11. {
  12. fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
  13. }
  14. return fibArray;
  15. }

上述代码除了5个变量外,还有malloc函数开辟的n+1个空间,F(N)=n+6,

即空间复杂度:O(n)

例3

  1. // 计算阶乘递归Fac的空间复杂度?
  2. long long Fac(size_t N)
  3. {
  4. if(N == 0)
  5. return 1;
  6. return Fac(N-1)*N;
  7. }

这是一个递归,每次进入递归时都会再次创建变量,建立栈帧,返回时销毁变量,上述代码啊一共会递归N次,所以会创建N个变量,

即空间复杂度:O(N)


😸😼到此本篇文章就结束了,这是数据结构的第一篇文章,往后也会继续更新的;🤖👻

🥰😍若本篇文章有错误或是有建议,欢迎小伙伴们提出哦;😄🤩

😃😁希望各位大佬们多多支持博主~🤩😍

🦖🐲谢谢你的阅读。🐯🦁

文章知识点与官方知识档案匹配,可进一步学习相关知识
算法技能树首页概览40346 人正在系统学习中
ame("script")[0]; s.parentNode.insertBefore(hm, s); })();