白话数据结构之基本概念篇(2)_复杂度

979_

已于 2022-06-22 14:39:33 修改

阅读量270

点赞数

分类专栏：数据结构文章标签：数据结构

于 2022-06-04 23:51:54 首次发布

本文链接：https://blog.csdn.net/qq_38211182/article/details/125114984

版权

数据结构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

白话数据结构系列文章目录

基本概念篇
1. 入门概述
 2. 复杂度
 3. 数组&链表
 4. 栈&堆
 5. 排序算法
 6. 查找算法

编程思想篇

实际问题篇
1. 约瑟夫环

文章目录

白话数据结构系列文章目录
一、前言
二、前置条件
三、本文参考资料
四、正文部分
五、总结

一、前言

数据结构本身就是为了解决性能问题，那么使用什么东西来衡量不同算法间的性能呢？
本节介绍的就是复杂度的概念，主要分为时间复杂度与空间复杂度两个。

二、前置条件

C语言基础

三、本文参考资料

大话数据结构
数据结构与算法之美
百度

四、正文部分

4.1 分析复杂度的原因

明明可以完成算法后实践出数据，那么为什么还需要提前分析复杂度呢？
这种方法没有错，是最准确的方法，这种方法称为事后统计法，但存在几个弊端

测试环境中硬件的不同会对测试结果有很大的影响。
测试结果受数据规模的影响很大

所以，我们需要一个不用具体的测试数据来测试，就可以粗略地估计算法的执行效率的方法。

4.2 大 O 复杂度表示法

算法的执行效率，粗略地讲，就是算法代码执行的时间。

从 CPU 的角度来看，这段代码的每一行都执行着类似的操作：读数据-运算-写数据。
尽管每行代码对应的 CPU 执行的个数、执行的时间都不一样，但是，我们这里只是粗略估计，所以可以假设每行代码执行的时间都一样，为 unit_time。

可以得到以下结论：
所有代码的执行时间 T(n) 与每行代码的执行次数 f(n) 成正比。
即，T(n) = O(f(n))

大 O 时间复杂度实际上并不具体表示代码真正的执行时间，而是表示代码执行时间随数据规模增长的变化趋势，
所以，也叫作渐进时间复杂度（asymptotic time complexity），简称时间复杂度。

当 n 很大时，你可以把它想象成 10000、100000。
而公式中的低阶、常量、系数三部分并不左右增长趋势，所以都可以忽略。我们只需要记录一个最大量级就可以了，
如果用大 O 表示法表示刚讲的那两段代码的时间复杂度，就可以记为：T(n) = O(2n+2) = O(n)； T(n) = O(2n2+2n+3) = O(n2)。

4.3 时间复杂度分析

由于时间复杂度是渐进增长，所以引出了以下几个常用分析技巧：

只关注循环执行次数最多的一段代码，也就是n的量级
加法法则：总复杂度等于量级最大的那段代码的复杂度，其余部分都会随着增长被忽略
乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积，尤其需要注意内外嵌套的复杂度都为n时，此时最终时间复杂度为n²

4.4 几种常见时间复杂度实例分析

在这里插入图片描述
上图可分为多项式量级和非多项式量级。
其中，非多项式量级只有两个：O(2n) 和 O(n!)。

我们把时间复杂度为非多项式量级的算法问题叫作 NP（Non-Deterministic Polynomial，非确定多项式）问题。
当数据规模 n 越来越大时，非多项式量级算法的执行时间会急剧增加，求解问题的执行时间会无限增长。
所以，非多项式时间复杂度的算法其实是非常低效的算法。
因此，关于 NP 时间复杂度我就不展开讲了。

我们主要来看几种常见的多项式时间复杂度。

O(1)
一般情况下，只要算法中不存在循环语句、递归语句，即使有成千上万行的代码，其时间复杂度也是Ο(1)。
O(logn)、O(nlogn)
```
 i=1;
 while (i <= n)  {
	i = i * 2;
 }
```
从代码中可以看出，变量 i 的值从 1 开始取，每循环一次就乘以 2。当大于 n 时，循环结束。
实际上，变量 i 的取值就是一个等比数列。
如果我把它一个一个列出来，就应该是这个样子的：

所以，我们只要知道 x 值是多少，就知道这行代码执行的次数了。
x=log2n，所以，这段代码的时间复杂度就是 O(log2n)。

实际上，不管是以 2 为底、以 3 为底，还是以 10 为底，我们可以把所有对数阶的时间复杂度都记为 O(logn)。

我们知道，对数之间是可以互相转换的，log3n 就等于 log32 * log2n，所以 O(log3n) = O(C * log2n)，其中 C=log32 是一个常量。
基于我们前面的一个理论：在采用大 O 标记复杂度的时候，可以忽略系数，即 O(Cf(n)) = O(f(n))。所以，O(log2n) 就等于 O(log3n)。

因此，在对数阶时间复杂度的表示方法里，我们忽略对数的“底”，统一表示为 O(logn)。
O(m+n)、O(m*n)
代码的复杂度由两个数据的规模来决定
我们无法事先评估 m 和 n 谁的量级大，所以我们在表示复杂度的时候，就不能简单地利用加法法则，省略掉其中一个。

4.5 特殊时间复杂度

4.5.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;
			break;
		}
	}
	return pos;
}

因为，要查找的变量 x 可能出现在数组的任意位置。
如果数组中第一个元素正好是要查找的变量 x，那就不需要继续遍历剩下的 n-1 个数据了，那时间复杂度就是 O(1)。
但如果数组中不存在变量 x，那我们就需要把整个数组都遍历一遍，时间复杂度就成了 O(n)。

所以，不同的情况下，这段代码的时间复杂度是不一样的。
为了表示代码在不同情况下的不同时间复杂度，我们需要引入三个概念：最好情况时间复杂度、最坏情况时间复杂度和平均情况时间复杂度。
顾名思义，最好情况时间复杂度就是，在最理想的情况下，执行这段代码的时间复杂度。
最坏情况时间复杂度就是，在最糟糕的情况下，执行这段代码的时间复杂度。

4.5.2 平均情况时间复杂度

要查找的变量 x 在数组中的位置，有 n+1 种情况：在数组的 0～n-1 位置中和不在数组中。
我们把每种情况下，查找需要遍历的元素个数累加起来，然后再除以 n+1，就可以得到需要遍历的元素个数的平均值，即：
n个数据，就是n种情况，在加上一个不在n个数据中的情况，所以共有n+1种情况，则 1+…+n为n(n+1)/2 ，则再加个n就为n(n+3)/2 ，在除以n+1为n(n+3)/2(n+1)
在这里插入图片描述
但是我们刚讲的这 n+1 种情况，出现的概率并不是一样的。
我们知道，要查找的变量 x，要么在数组里，要么就不在数组里。这两种情况对应的概率统计起来很麻烦，为了方便你理解，我们假设在数组中与不在数组中的概率都为 1/2。另外，要查找的数据出现在 0～n-1 这 n 个位置的概率也是一样的，为 1/n。所以，根据概率乘法法则，要查找的数据出现在 0～n-1 中任意位置的概率就是 1/(2n)。

因此，前面的推导过程中存在的最大问题就是，没有将各种情况发生的概率考虑进去。如果我们把每种情况发生的概率也考虑进去，那平均时间复杂度的计算过程就变成了这样：
在这里插入图片描述
这个值就是概率论中的加权平均值，也叫作期望值，所以平均时间复杂度的全称应该叫加权平均时间复杂度或者期望时间复杂度。
引入概率之后，前面那段代码的加权平均值为 (3n+1)/4。
用大 O 表示法来表示，去掉系数和常量，这段代码的加权平均时间复杂度仍然是 O(n)。

只有同一块代码在不同的情况下，时间复杂度有量级的差距，我们才会使用这三种复杂度表示法来区分。

4.5.3 均摊时间复杂度

平均复杂度只在某些特殊情况下才会用到，而均摊时间复杂度应用的场景比它更加特殊、更加有限。

这段代码实现了一个往数组中插入数据的功能。
当数组满了之后，也就是代码中的 count == array.length 时，我们用 for 循环遍历数组求和，并清空数组，将求和之后的 sum 值放到数组的第一个位置，然后再将新的数据插入。
但如果数组一开始就有空闲空间，则直接将数据插入数组。

// array表示一个长度为n的数组
// 代码中的array.length就等于n
int[] array = new int[n];
int count = 0;

void insert(int val) {
	if (count == array.length) {
		int sum = 0;
		for (int i = 0; i < array.length; ++i) {
			sum = sum + array[i];
		}
		array[0] = sum;
		count = 1;
	}
	
	array[count] = val;
	++count;
}

最理想的情况下，数组中有空闲空间，我们只需要将数据插入到数组下标为 count 的位置就可以了，所以最好情况时间复杂度为 O(1)。
最坏的情况下，数组中没有空闲空间了，我们需要先做一次数组的遍历求和，然后再将数据插入，所以最坏情况时间复杂度为 O(n)。
那平均时间复杂度是多少呢？答案是 O(1)。

对比一下这个 insert() 的例子和前面那个 find() 的例子，你就会发现这两者有很大差别。

find() 函数在极端情况下，复杂度才为 O(1)。
insert() 在大部分情况下，时间复杂度都为 O(1)。只有个别情况下，复杂度才比较高，为 O(n)。这是 insert()第一个区别于 find() 的地方。
对于 insert() 函数来说，O(1) 时间复杂度的插入和 O(n) 时间复杂度的插入，出现的频率是非常有规律的，而且有一定的前后时序关系，一般都是一个 O(n) 插入之后，紧跟着 n-1 个 O(1) 的插入操作，循环往复。

所以，针对这样一种特殊场景的复杂度分析，我们并不需要像之前讲平均复杂度分析方法那样，找出所有的输入情况及相应的发生概率，然后再计算加权平均值。
针对这种特殊的场景，我们引入了一种更加简单的分析方法：摊还分析法，通过摊还分析得到的时间复杂度我们起了一个名字，叫均摊时间复杂度。

每一次 O(n) 的插入操作，都会跟着 n-1 次 O(1) 的插入操作，所以把耗时多的那次操作均摊到接下来的 n-1 次耗时少的操作上，均摊下来，这一组连续的操作的均摊时间复杂度就是 O(1)。这就是均摊分析的大致思路。

应用场景

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