【数据结构】详解时间复杂度和空间复杂度的计算

一、时间复杂度（执行的次数）

1.1时间复杂度的概念

1.2时间复杂度的表示方法

1.3算法复杂度的几种情况

1.4简单时间复杂度的计算

例一

例二

例三

1.5复杂时间复杂度的计算 

例一：未优化冒泡排序时间复杂度

例二：经过优化的冒泡排序

例三：二分查找的时间复杂度

例四：阶乘递归的时间复杂度

例五：斐波那契递归（二叉树）的时间复杂度

1.6不同时间复杂度效率的比较

​编辑

二、空间复杂度（变量的个数）

2.1空间复杂度的概念

2.2常见空间复杂度的计算

对于递归：

前言之空间可以重复利用

例一：冒泡排序的空间复杂度（有坑）

例二：二分法空间复杂度的计算

例三：阶乘递归的空间复杂度

例四：斐波那契递归的空间复杂度（难点）并不是O（2^N）

三、重难点知识回顾与总结 

一、时间复杂度（执行的次数）

1.1时间复杂度的概念

时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。(这里的函数指的是数学中的函数，而不是我们C语言中的函数)

一个算法执行所耗费的时间，从理论上说是不能算出来的，因为只有当我们把程序放在机器上跑起来，才能知道具体时间。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。

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

一句话概括：时间复杂度算的是执行次数，而不是具体的时间

但是需要小心误区：并不是有多少个循环次数时间复杂度就是多少，得具体分析算法逻辑

shellsort 用了三个循环 但是它的时间复杂度是O（N^1.3）

1.2时间复杂度的表示方法

我们计算时间复杂度时不是计算算法运行的具体次数，而是用大O的渐进表示法来计算，其具体计算方法如下：

  • 用常数1取代运行时间中的所有加法常数。eg:O（100）->O（1）
  • 在修改后的运行次数函数中，只保留最高阶项。eg：O（N^2+N）->O（N^2）
  • 如果最高阶项存在且不是1，则去除与这个项目相乘的常数。O（2N^2）->O（N^2）

 

1.3算法复杂度的几种情况

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

但是需要注意的是：

 

 在实际中一般情况关注的是算法的最坏运行情况

1.4简单时间复杂度的计算

例一

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

O（100）-> O(1) 

 

例二

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;}printf("%d\n", count);
}

上面程序具体执行的次数：N * N + 2*N + 10

用大O的渐进表示法得出时间复杂度：O(N^2) (只保留最高阶项)

 

例三

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);
}

 上面程序具体执行的次数：2*N + 10

用大O的渐进表示法得出时间复杂度：O(N) (如果最高阶项存在且不是1，则去除与这个项目相乘的常数

1.5复杂时间复杂度的计算 

例一：未优化冒泡排序时间复杂度

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

 

分析可知： 

 

所以本质上是一个等差数列

刚开始一共有N个数，所以需要比较N-1次 第二次需要比较 N-2 次

 所以（N-1）+(N-2)+(N-3)+...+3+2+1= (N^2-N)/2

用大O的渐进表示法得出时间复杂度：O(N^2)

 但是这是未经过优化的冒泡排序，不管原先数组是否有序，都要经过全部遍历

 

例二：经过优化的冒泡排序

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;}}
}

多了一个exchange变量，这个变量的好处是： 

对于已经有序的数组，不再会进行排序

当exchange为0时，表示在当前一轮的比较中没有发生任何元素交换，这意味着待排序的数组已经是有序的状态。这种情况下，BubbleSort算法可以提前结束，而不必再进行后续的比较操作。

举个具体的例子来说明，对于输入序列 1 2 3 5 4：

  • 在第一轮排序中，会先比较1和2，然后比较2和3，接着比较3和5，最后比较5和4，发现5和4的顺序不对，进行交换，exchange被设置为1。
  • 在第二轮排序中，会继续比较1和2，2和3，3和4。因为在这一轮中没有发生任何交换，exchange保持为0。
  • 根据exchange为0的判断，算法将会提前结束，因为在这一轮中没有发生交换，说明数组已经是有序的（除了最后的4和5位置互换），不需要再进行后续的比较和排序操作。

因此，exchange的作用在于提供了一种优化机制，可以在数组已经有序的情况下提前结束排序过程，减少不必要的比较操作，从而提高算法的效率。

那么当我们的数组有序的时候，也就是最好的情况，我们的复杂度是O（N），遍历一次发现exchange是0，停止循环

 但是我们的时间复杂度算的是悲观保守的估计，所以即使优化了，我们的时间复杂度最终的结果还是O（N^2）！ 

当然这也给我们一个启示，一段代码中并不是只有一个复杂度，不同的情况有不同的复杂度

例三：二分查找的时间复杂度

最好的情况：O(1)

最坏的情况：

 

 分析最坏情况：

刚开始在N个数中找，接下来在N/2个数中找，接着在N/4数中找....

没找一次，次数+1，当我们有N个数据的时候，很容易得知我们只需要 Log₂x 就找出是否存在

 用大O的渐进表示法得出时间复杂度：O(logN) （一般省略底数）

例四：阶乘递归的时间复杂度

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

 

 用大O的渐进表示法得出时间复杂度：O(N)

换句话讲就是：每次调用是O（1），但是调用N次

例五：斐波那契递归（二叉树）的时间复杂度

long long Fibonacci(size_t N)
{return N < 2 ? N : Fibonacci(N - 1) + Fibonacci(N - 2);
}

可以推导出最后一层的节点数量应该是2^n-1 （因为第1层是0次方） 

那么我们的时间复杂度就转变为：2^0+2^1+...+2^n-1

我们可以用公式：

得知Sn=2^n-1

或者用错位相减法：

 

小羊表示：错位相减法yyds！！

最终可以得知 用大O的渐进表示法得出时间复杂度为：O(2^N)

说明斐波那契这个函数很挫，复杂度很高

1.6不同时间复杂度效率的比较

 我们可以看到当测试数据很大时 O(logN) 和 O(1) 的效率几乎是一样的，所以二分查找是一种效率很高的算法，但是它也有一个缺陷，那就是它操作的数组元素必须是有序的。

二、空间复杂度（变量的个数）

2.1空间复杂度的概念

空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，空间复杂度算的是变量的个数。 空间复杂度计算规则基本跟时间复杂度类似，也使用大O的渐进表示法。

而且我们找的变量，必须是这个程序临时占用的，额外占用的，别人给咱们的不算

谨记：时间是一去不复返的，需要累计；空间是可以重复利用的，不需要累计

2.2常见空间复杂度的计算

对于递归：

每次递归的开辟的大小 * 递归的次数

前言之空间可以重复利用

我们接下来要开始计算空间复杂度了，但是会有很多问题，所以我们先算一个程序

#include<bits/stdc++.h>
using namespace std;
void f(int n)
{int a=0;int *p=(int*)malloc(4*n);cout << &a << " " << &p << endl;
}
int main()
{f(10);f(100);return 0;
}

从结果中我们可以看出：当函数栈帧销毁之后，再次调用该函数的时候，还是用的上一次的那个空间，而不会新开辟空间 

例一：冒泡排序的空间复杂度（有坑）

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;}}
}

 这里我们在循环外部定义了两个变量，然后在循环内部又定义了一个变量；可能有的同学会认为temp变量因为在循环内部，每次进入循环都会被重新定义，所以空间复杂度为N^2，其实不是的；

我们知道虽然时间是累积的，一去不复返，但是空间是不累积的，我们可以重复使用；对于我们的temp变量来说，每次进入if这个局部范围时开辟空间，离开这个局部范围时空间销毁，下一次在进入时又重新开辟空间，出去又再次销毁；所以其实从始至终temp都只占用了一个空间；

而且还有一个误导人的就是那个数组：尽管有数组而且还有N个变量，但是这个数组是别的程序开辟好传进来的，并不是我们所开辟的，所以我们算一个数组首地址变量即可

所以exchange end i 这三个变量都是开辟了一个空间，每次销毁之后，再次在原来的地址上开辟空间

例二：二分法空间复杂度的计算

#include<bits/stdc++.h>
using namespace std;
int n,m;int j=0;
const int N = 1000010;
int a[N];
bool check(int num,int x)
{if(num < x)//在例子中 x就是3{return true;}else{return false;}
}
int binary_search(int q[],int len,int x)
{int l=-1,r=n;while(l+1 < r)//循环条件写成这样可以节约时间{int mid= (l+r) >> 1;if(check(q[mid],x)){l=mid;}else{r=mid;}}//因为存在找不到的情况if(q[r]==x)//r就是我们要的那个位置{return r+1;}else{return -1;}
}
int main()
{cin >> n >> m;for(int i=0;i<n;++i){cin >> a[i];}while(m--){int x;//这里原先x写成数组是真没有必要cin >> x;int res=binary_search(a,n,x);cout << res << " ";}return 0;
}

 对于循环的二分查找而言，空间复杂度是O(1)。

例三：阶乘递归的空间复杂度

long long Fac(int N)
{return N < 2 ? N : Factorial(N - 1) * N;
}

 

我们知道，每次函数调用开始时都会在栈区上形成自己的函数栈帧，调用结束时函数栈帧销毁；

对于上面的递归来说：只有当 N < 2 的时候函数才开始返回，而在这之前所形成的 Fac(N) Fac(N-1) Fac(N-2) … 这些函数的函数栈帧在返回之前都不会释放，而是一直存在，知道函数一步一步开始返回的时候开辟的空间才会被逐渐释放。所以在计算递归类空间复杂度度时，我们在意的是递归的深度；

这里调用的递归深度为 n - 1（递归 n - 1 次），所以空间复杂度为O(N)。

例四：斐波那契递归的空间复杂度（难点）并不是O（2^N）

long long Fibonacci(size_t N)
{return N < 2 ? N : Fibonacci(N - 1) + Fibonacci(N - 2);
}

递归的深度是N

每层是常数个

所以空间复杂度是O（N） 

斐波那契是逐个分支进行递归的，以上图为例，它会先递归6-5-4-3-2-1，再递归6-5-4-3-2，再递归6-5-4-2，以此类推，直到把最后一个分支递归完；

其次，空间是不会累积的，所以尽管我们同一个函数的函数栈帧会被开辟很多次，但是它仍然只计入一次开辟的空间复杂度。

所以递归调用开递归的深度，这里的空间复杂度为O(N)。

对于时间复杂度而言：左分支f（3）和 右分支f（3）是不一样的，因为只要有，就会浪费时间

但是对于空间复杂度而言：f（3）的栈帧是同一个东西，只要左分支的f（3）消失了，那么下一次建立这个变量的空间还是在同样的位置（详情可以看前言）

三、重难点知识回顾与总结 

  • 时间复杂度和空间复杂度都是用大O的渐进表示法来表示。
  • 时间复杂度看运算执行的次数，空间复杂度看变量定义的个数。
  • 在递归中，时间复杂度看调用的次数，空间复杂度看调用的深度。
  • 时间是累积的，一去不复返；空间是不累积的，可以重复利用。

  • 冒泡排序的时间复杂度为O(N^2)，空间复杂度为O(1)。
  • 二分查找的时间复杂度为O(logN)，空间复杂度为O(1)。
  • 阶乘递归的时间复杂度为O(N)，空间复杂度为O(N)。
  • 斐波那契递归的时间复杂度为O(2^N)，空间复杂度为O(N)。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/536583.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

JAVA初阶数据结构链表（2）双向链表（ +专栏数据结构练习是完整版）

JAVA初阶数据结构链表（2）双向链表（ +专栏数据结构练习是完整版）

1.双向链表的结构&#xff08;双向不带头不循环链表&#xff09; 需要注意的一点就是&#xff0c;在jdk中的链表就是双向链表 一个节点有三个域 val&#xff08;数值域&#xff09; next&#xff08;地址域&#xff09; prev&#xff08;前驱记录前一个节点的地址&#xff09…
阅读更多...
Express学习（四）

Express学习（四）

使用Express写接口 创建基本的服务器 创建API路由模块 编写GET接口 编写POST接口 CORS跨域资源共享 什么是CORS CORS由一系列HTTP响应头组成&#xff0c;这些HTTP响应头决定浏览器是否阻止前端JS代码跨域获取资源。浏览器的同源安全策略默认会阻止网页“跨域”获取资源。但如…
阅读更多...
yum安装mysql 数据库tab自动补全

yum安装mysql 数据库tab自动补全

centos7上面没有mysql&#xff0c;它的数据库名字叫做mariadb [rootlocalhost ~]#yum install mariadb-server -y [rootlocalhost ~]#systemctl start mariadb.service [rootlocalhost ~]#systemctl stop firewalld [rootlocalhost ~]#setenforce 0 [rootlocalhost ~]#ss -na…
阅读更多...
Three.js点线几何空间图形代码

Three.js点线几何空间图形代码

Three.js点线几何空间图形代码。效果如下 下载地址 Three.js点线几何空间图形代码
阅读更多...
docker部署springboot jar包项目

docker部署springboot jar包项目

docker部署springboot jar包项目 前提&#xff0c;服务器环境是docker环境&#xff0c;如果服务器没有安装docker&#xff0c;可以先安装docker环境。 各个环境安装docker&#xff1a; Ubuntu上安装Docker&#xff1a; ubuntu离线安装docker: CentOS7离线安装Docker&#xff1…
阅读更多...
Python语言基础与应用-北京大学-陈斌-P40-39-基本扩展模块/上机练习：计时和文件处理-给算法计时-上机代码

Python语言基础与应用-北京大学-陈斌-P40-39-基本扩展模块/上机练习：计时和文件处理-给算法计时-上机代码

Python语言基础与应用-北京大学-陈斌-P40-39-基本扩展模块/上机练习&#xff1a;计时和文件处理-给算法计时-上机代码 上机代码&#xff1a; # 基本扩展模块训练 给算法计时 def factorial(number): # 自定义一个计算阶乘的函数i 1result 1 # 变量 result 用来存储每个数的阶…
阅读更多...
【论文阅读】Natural Adversarial Examples 自然对抗的例子

【论文阅读】Natural Adversarial Examples 自然对抗的例子

文章目录 一、文章概览&#xff08;一&#xff09;摘要&#xff08;二&#xff09;导论&#xff08;三&#xff09;相关工作 二、IMAGENET-A 和 IMAGENET-O&#xff08;一&#xff09;数据集构造方式&#xff08;二&#xff09;数据收集过程 三、模型的故障模式四、实验&#x…
阅读更多...
Docker自建蜜罐系统【失陷检测、外网威胁感知、威胁情报】

Docker自建蜜罐系统【失陷检测、外网威胁感知、威胁情报】

项目地址&#xff1a; https://hfish.net Hfish是一款基于Docker的网络钓鱼平台&#xff0c;它能够帮助安全团队模拟各种网络钓鱼攻击&#xff0c;以测试和提高组织的安全防御能力。 Hfish的优点 为什么选择Hfish&#xff1f; 蜜罐通常被定义为具有轻量级检测能力、低误报率…
阅读更多...
Qt中QCheckBox的三种状态设置

Qt中QCheckBox的三种状态设置

首先启用QCheckbox的tristate属性 //启用QCheckBox的tristate属性&#xff0c;使checkbox有三种状态。例&#xff1a; questionCheckBox->setTristate(true);//使用setCheckState(Qt::CheckState state)函数设置checkbox当前的状态。例&#xff1a; //Qt::CheckState是枚举…
阅读更多...
算法：数据结构顺序表表的插入、删除和查找

算法：数据结构顺序表表的插入、删除和查找

#include <iostream> #include <stdio.h> #define MaxSize 50 typedef int ElemType; typedef struct {ElemType data[MaxSize];int length; }SqList; bool ListInsert(SqList &L,int i,ElemType e)//插入数据 {if(i<1 || i>L.length1)//判断插入的位置是…
阅读更多...
OPENCV（0-1之0.1）

OPENCV（0-1之0.1）

OPENCV-0.1 学习安排计算机视觉简介是什么&#xff1f;应用领域基础概念 OpenCV简介历史背景和主要贡献者支持的语言和平台主要模块和功能 安装(windows_python)pip安装验证安装&#xff08;记得安装jupyter&#xff09; 第一个OpenCV程序实践练习 官方文档 学习安排 计算机视…
阅读更多...
详解Postman使用

详解Postman使用

简介&#xff1a; 1.简介 PostMan&#xff0c;一款接口调试工具。 特点&#xff1a; 可以保留接口请求的历史记录 可以使用测试集Collections有效管理组织接口 可以在团队之间同步接口数据 1.简介 PostMan&#xff0c;一款接口调试工具。 特点&#xff1a; 可以保留接口请求…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023