复杂度分析(下):浅析最好、最坏、平均、均摊时间复杂度

时间复杂度分析有哪些?

  • 最好情况时间复杂度(best case time complexity)
  • 最坏情况时间复杂度(worst case time complexity)
  • 平均情况时间复杂度(average case time complexity)
  • 均摊时间复杂度(amortized time complexity)

最好、最坏情况时间复杂度

最好情况时间复杂度就是在最理想的情况下,执行这段代码的时间复杂度。

最好情况时间复杂度就是在最糟糕的情况下,执行这段代码的时间复杂度。

来看看下面这段代码:

1 // n 表示数组 array 的长度
2 int find(int[] array, int n, int x) {
3   int i = 0;
4   int pos = -1;
5   for (; i < n; ++i) {
6     if (array[i] == x) {
7        pos = i;
8        break;
9     }
10   }
11   return pos;
12 }

上面这段代码要实现的功能是:在一个数组中查找变量 x 出现的位置,如果找到了,就马上跳出循环,返回它的位置值;如果找不到,就返回 -1。

这里不能只是看到了 for 循环就判定其时间复杂度为 O(n),因为这个数组的顺序是不确定的,有可能数组中的第一个元素就是 x,那就可以马上结束循环了,其时间复杂度就是 O(1);如果数组中不存在变量 x 或者是数组中的最后一个元素才是 x,那就需要遍历整个数组,时间复杂度就是 O(n)。

在这里,O(1) 就是最好情况时间复杂度,O(n) 就是最坏情况时间复杂度。

平均情况时间复杂度

最好、最坏情况时间复杂度都是极端情况下的代码复杂度,发生的概率很小。因此,我们还需要知道平均情况时间复杂度。

还是以刚刚查找变量 x 的位置的例子为例,要查找的变量 x 在数组中的位置,总共有 n+1 种情况:在数组的 0~n-1 位置中和不在数组中。我们把每种情况下,查找需要遍历的元素个数累加起来再除以 n+1,就可以得到需要遍历的元素个数的平均值,即:

1 + 2 + 3 + …… + n + n / n + 1 = n(n+1)+2n / 2(n+1) = n(n+3) / 2(n+1)

省略掉系数、低阶、常量,将以上公式进行简化之后,得到的平均时间复杂度就是 O(n)。

但是,以上的 n+1 种情况,出现的概率也不是一样的。这里可以引入概率论的相关知识,假设变量 x 在数组中与不在数组中的概率各为 1/2,出现在 0~n-1 这 n 个位置的概率都是 1/n。根据概率乘法法则,要查找的数据出现正在 0~n-1 中任意位置的概率就是 1/(2n)。

这样,就可以得到以下计算过程:

1 x 1/2n + 2 x 1/2n + 3 x 1/2n + …… + n x 1/2n + n x 1/2n = n(n+1)+2n / 2 x 1/2n = 3n+1 / 4

这个值就是概率论中的加权平均值,也叫做期望值。

根据这个加权平均值,去掉系数和常量,我们得到的平均时间复杂度也是 O(n)。

所以,平均时间复杂度就是:加权平均时间复杂度(亦称为期望时间复杂度)。

大部分情况下,我们并不需要区分最好、最坏、平均三种复杂度,平均复杂度只在某些特殊情况下才用到。

均摊时间复杂度

均摊时间复杂度:对一个数据结构进行一组连续操作中,大部分情况下时间复杂度都很低,只有个别情况下时间复杂度较高。而且这些操作之间存在前后连贯的时序关系,在这个时候,我们可以将这一组操作放在一块儿分析,看是否能将较高时间复杂度那次操作的耗时,平摊到其他那些时间复杂度较低的操作上。(在能够应用均摊时间复杂度分析的场合,一般均摊时间复杂度就等于最好情况时间复杂度)

均摊时间复杂度的应用场景比平均时间复杂度更加特殊、更加有限。

举个例子:

1 // array 表示一个长度为 n 的数组
2 // 代码中的 array.length 就等于 n
3 int[] array = new int[n];
4 int count = 0;
5
6 void insert(int val) {
7   if (count == array.length) {
8      int sum = 0;
9      for (int i = 0; i < array.length; ++i) {
10         sum = sum + array[i];
11      }
12      array[0] = sum;
13      count = 1;
14   }
15
16   array[count] = val;
17   ++count;
18 }

这段代码实现的是往一个数组中插入数据的功能,当数组满了以后,也就是 count == array.length 的时候,我们用 for 循环遍历数组求和,再将新的数据插入,其时间复杂度为 O(n)。但如果数组未满,则直接将数据插入数组,其时间复杂度为 O(1)。

我们来分析一下它的时间复杂度,数组的长度为 n,根据数据插入的不同位置,可以分为 n 种情况,每种情况的时间复杂度为 O(1)。还有一种最“糟糕”的情况,那就是数组已满,这个时候的时间复杂度为 O(n)。而且,这 n+1 种情况发生的概率是一样的,都是 1/(n+1)。所以,根据加权平均的计算方法,可知:

1 x 1/n+1 + 1 x 1/n+1 + …… + 1 x 1/n+1 + n x 1/n+1 = 1

我们求得的平均时间复杂度就是:O(1)。

对比一下 insert() 的例子和前面 find() 的例子,这两个例子的最好、最坏情况时间复杂度都一样,为什么平均时间复杂度相差这么多呢?

这两个例子之间最大的区别在于:find() 的最好、最坏情况时间复杂度都是在极端情况下才会发生,而 insert() 在大部分情况下,时间复杂度都是 O(1),只有在极端情况下,时间复杂度才是 O(n)。其次,对于 insert() 函数来说,每当碰到一个时间复杂度为 O(n) 的情况,接下来就会有 n-1 个 O(1) 的插入操作,循环往复。

均摊下来,这一组连续的操作的均摊时间复杂度就是 O(1)。这就是均摊时间复杂度分析的大致思路。

内容小结

最好、最坏情况时间复杂度分析起来比较简单,但平均、均摊时间复杂度分析相对比较复杂。

之所以分为这四种复杂度分析,是因为在不同输入的情况下,复杂度量级有可能是不一样的。

原文地址:https://www.cnblogs.com/hardyyao/p/9744427.html

时间: 2024-10-14 23:26:17

复杂度分析(下):浅析最好、最坏、平均、均摊时间复杂度的相关文章

Chapter4 复杂度分析(下):浅析最好,最坏,平均,均摊时间复杂度

四个复杂度分析: 1:最好情况时间复杂度(best case time complexity) 2:最坏情况时间复杂度(worst case time complexity) 3:平均情况时间复杂度(average case time complexity) 4:均摊时间复杂度(amortized time complexity) for (; i < n; ++i) { if (array[i] == x) { pos = i; break; } } 分析:1:最好情况时间复杂度:O(1) 2

[数据结构与算法 03] 最好、最坏、平均、均摊 时间复杂度

由来 /**** 在一个无序的数组(array)中 查找变量 x 第一次出现的位置.如果没有找到,就返回 -1 ****/ // n 表示数组array的长度 int find(int[] array, int n, int x) { int i = 0; int pos = -1; for (; i < n; ++i) { if (array[i] == x) pos = i; } return pos; } 分析出此函数的时间复杂度为 O(n) 在数组中查找一个数据,并不需要每次都把整个数组

最好、最坏、平均、均摊时间复杂度

关注公众号 MageByte,设置星标点「在看」是我们创造好文的动力.后台回复 "加群" 进入技术交流群获更多技术成长. 本文来自 MageByte-青叶编写 上次我们说过 时间复杂度与空间复度,列举了一些分析技巧以及一些常见的复杂度分析比如 O(1).O(logn).O(n).O(nlogn),今天会继续细化时间复杂度. 1. 最好情况时间复杂度(best case time complexity) 2.最坏情况时间复杂度(worst case time complexity) 3.

最好,最坏,平均,均摊时间复杂度

// n 表示数组 array 的长度int find(int[] array, int n, int x) {  int i = 0;  int pos = -1;  for (; i < n; ++i) {    if (array[i] == x) pos = i;  }  return pos;} 时间复杂度是O(n) // n 表示数组 array 的长度int find(int[] array, int n, int x) {  int i = 0;  int pos = -1; 

复杂度分析(下)

复杂度分析(下) 继续上篇,这篇将介绍四个复杂度分析方面的知识点:最好情况时间复杂度.最坏情况时间复杂度.平均情况时间复杂度.均摊时间复杂度. 1.最好.最坏情况时间复杂度 我们以数组查找举例,遍历数组找指定元素,找到则立即返回该元素所在数组的下标位置,没找到则返回-1.代码比较简单我就不写出来了. 我们来分析一下, 最好情况时间复杂度:最好情况当然是数组的第一个元素就是查找的元素,为O(1) 最坏情况时间复杂度:最坏情况就是数组的最后一个元素为查找的元素,需要遍历完整个数组才能找到该元素,或者

学好数据结构和算法 —— 复杂度分析

复杂度也称为渐进复杂度,包括渐进时间复杂度和渐进空间复杂度,描述算法随数据规模变化而逐渐变化的趋势.复杂度分析是评估算法好坏的基础理论方法,所以掌握好复杂度分析方法是很有必要的. 时间复杂度 首先,学习数据结构是为了解决“快”和“省”的问题,那么如何去评估算法的速度快和省空间呢?这就需要掌握时间和空间复杂度分析.同一段代码运行在不同环境.不同配置机器.处理不同量级数据…效率肯定不会相同.时间复杂度和空间复杂度是不运行代码,从理论上粗略估计算法执行效率的方法.时间复杂度一般用O来表示,如下例子:计

[算法]复杂度分析

时间复杂度 时间复杂度的分析 只关注循环执行次数最多的一段代码,因为使用大O表示法,其他执行次数较少的复杂度可以忽略 加法法则:总复杂度等于量级最大的那段代码的复杂度 乘法法则:嵌套代码的复杂度等于嵌套内外代码复杂度的乘积 常见的时间复杂度示例 复杂度从低阶到高阶为:(复杂度越高阶,执行效率越低) O(1).O(logn).O(n).O(nlogn).O(n^2) O(1) 该时间复杂度表示代码的执行时间可以认为与输入n无关,是一个固定的值 O(logn)&O(nlogn) o(logn)复杂度

DSA_02:复杂度分析

真正掌握了复杂度分析,可以说 DSA 便掌握了一小半. 复杂度分析分为:时间复杂度分析.空间复杂度分析. 时间复杂度的定义: 并不是指代码执行的具体.确定时间. 它表示的是一个算法执行效率与数据规模增长的变化趋势. 即便代码需要执行成千上万次,只要它不随数据规模变化而变化,那么它的复杂度就是 O(1). 空间复杂度的定义: 类似的,它表示空间占用与数据规模增长的变化趋势 同样,哪怕占用再多的空间,只要它不随数据规模变化而变化,那么它的复杂度就是 O(1). 复杂度的两种表示方法: 1. T(n)

数据结构算法——算法复杂度分析

算法复杂度分为时间复杂度和空间复杂度 首先要清楚一点,大O表示法的时间复杂度高不代表程序运行时间长,空间复杂度高不代表占用空间多. 他们表示的是代码执行时间随着数据规模增长的变化趋势.和算法储存空间与数据规模之间的增长关系. 时间复杂度判断方法 1.只关注循环次数最多的一段代码 2.加法法则:总复杂度等于量级最大的那段代码的复杂度 3.乘法原则:嵌套代码的复杂度等于嵌套内外代码复杂度的乘积 常见的复杂度量级(按数量级递增) 常量阶:O(1) 对数阶:O(logn) 线性阶:O(n) 线性对数阶: