复杂度分析
算法本质上是一连串的计算步骤。对于同一个问题，我们可以使用不同的算法来获得相同的结果，可是在计算过程中电脑消耗的时间和资源却有很大的区别。那我们如何来比较不同算法之间的优劣性呢？
目前分析算法主要从「时间」和「空间」两个维度来进行分析。时间维度顾名思义就是算法需要消耗的时间，「时间复杂度」是常用的分析单位。空间维度代表算法需要占用的内存空间，我们通常用「空间复杂度」来分析。
所以，分析算法的效率主要从「时间复杂度」和「空间复杂度」来分析。很多时候我们两者不可兼得，有时候要用时间换空间，或者空间换时间。下面我们一起来分别了解「时间复杂度」和「空间复杂度」的计算方式。
时间复杂度
- 常数阶O(1)
- 对数阶O(logN)
- 线性阶O(n)
- 线性对数阶O(nlogN)
- 平方阶O(n²)
- 立方阶O(n³)
- K次方阶O(n^k)
- 指数阶(2^n)
- 阶乘O(n!)
常数阶O(1)
只要没有循环或递归等复杂逻辑，无论代码执行多少行，代码复杂度都为O(1)，如下：
int x = 0;
int y = 1;
int temp = x;
x = y;
y = temp;上述代码在执行的时候，所消耗的时间不会随着特定变量的增长而增长，即使有几万行这样的代码，我们都可以用O(1)来表示它的时间复杂度。
线性阶O(n)
我们在上述的例子中讲解过O(n)的算法：
for (int i = 1; i <= n; i++) {
x++;
}在这段代码中，for循环会执行n遍，因此计算消耗的时间是随着n的变化而变化，因此这类代码都可以用O(n)来表示其时间复杂度。
对数阶O(logN)
来看以下的例子：
int i = 1;
while(i < n)
i = i * 2;
}在上面的循环中，每次i都会被乘以2，也意味着每次 i 都离 n 更进一步。那需要多少次循环 i 才能等于或大于 n 呢，也就是求解2的x次方等于n，答案x=log2^n。也就是说循环 log2^n次之后，i会大于等于n，这段代码就结束了。所以此代码的复杂度为：O(logN)。
线性对数阶O(nlogN)
线性对数阶O(nlogN)很好理解，也就是将复杂度为O(logN)的代码循环n遍：
for(int i = 0; i <= n: i++) {
int x = 1;
while(x < n) {
x = x * 2;
}
}*因为每次循环的复杂度为O(logN)，所以n logN = O(nlogN)**
平方阶O(n²)
在之前的例子我们也讲过，O(n²)就是将循环次数为n的代码再循环n遍：
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
x++;
}
}*O(n²) 的本质就是n n，如果我们将内层的循环次数改为m：**
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
x++;
}
}复杂度就变为 n m = O(n m)。
关于一些更高的阶级比如O(n³)或者O(n^k)，我们可以参考O(n²)来理解即可，O(n³)相当于三层循环，以此类推。
除了「大O表示法」还有其他「平均时间复杂度」、「均摊时间复杂度」、「最坏时间复杂度」、「最好时间复杂度」等等分析指数，但是最常用的依然是「大O表示法」。
空间复杂度
既然「时间复杂度」不是计算程序具体消耗的时间，「空间复杂度」也不是用来计算程序具体占用的空间。随着问题量级的变大，程序需要分配的内存空间也可能会变得更多，而「空间复杂度」反映的则是内存空间增长的趋势。
比较常用的空间复杂度有：O(1)、O(n)、O(n²)。在下面的例子中，我们用 S(n) 来定义「空间复杂度」。
O(1)空间复杂度
如果算法执行所需要的临时空间不随着某个变量n的大小而变化，此算法空间复杂度为一个常量，可表示为 O(1)：
int x = 0;
int y = 0;
x++;
y++;其中x, y所分配的空间不随着处理数据量变化，因此「空间复杂度」为 O(1)
O(n)空间复杂度
以下的代码给长度为n的数组赋值：
int[] newArray = new int[n];
for (int i = 0; i < n; i++) {
newArray[i] = i;
}在这段代码中，我们创建了一个长度为 n 的数组，然后在循环中为其中的元素赋值。因此，这段代码的「空间复杂度」取决于 newArray 的长度，也就是 n，所以 S(n) = O(n)。
最好，最坏情况时间复杂度
// 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)。所以，不同的情况下，这段代码的时间复杂度是不一样的。
顾名思义，****最好情况时间复杂度就是，在最理想的情况下，执行这段代码的时间复杂度。** 就像我们刚刚讲到的，在最理想的情况下，要查找的变量 x 正好是数组的第一个元素，这个时候对应的时间复杂度就是最好情况时间复杂度。**
同理，****最坏情况时间复杂度就是，在最糟糕的情况下，执行这段代码的时间复杂度。** 就像刚举的那个例子，如果数组中没有要查找的变量 x，我们需要把整个数组都遍历一遍才行，所以这种最糟糕情况下对应的时间复杂度就是最坏情况时间复杂度。**
平均情况时间复杂度
最好情况时间复杂度和最坏情况时间复杂度对应的都是极端情况下的代码复杂度，发生的概率其实并不大。为了更好地表示平均情况下的复杂度，我们需要引入另一个概念：平均情况时间复杂度，后面我简称为平均时间复杂度。
// 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 种情况：在数组的 0～n-1 位置中和不在数组中。我们把每种情况下，查找需要遍历的元素个数累加起来，然后再除以 n+1，就可以得到需要遍历的元素个数的平均值，即：
我们知道，时间复杂度的大 O 标记法中，可以省略掉系数、低阶、常量，所以，咱们把刚刚这个公式简化之后，得到的平均时间复杂度就是 O(n)。
这个结论虽然是正确的，但是计算过程稍微有点儿问题。我们刚讲的这 n+1 种情况，出现的概率并不是一样的。我们知道，要查找的变量 x，要么在数组里，要么就不在数组里。这两种情况对应的概率统计起来很麻烦，这里我们假设在数组中与不在数组中的概率都为 1/2。另外，要查找的数据出现在 0～n-1 这 n 个位置的概率也是一样的，为 1/n。所以，根据概率乘法法则，要查找的数据出现在 0～n-1 中任意位置的概率就是 1/(2n)。
因此，前面的推导过程中存在的最大问题就是，没有将各种情况发生的概率考虑进去。如果我们把每种情况发生的概率也考虑进去，那平均时间复杂度的计算过程就变成了这样：
这个值就是概率论中的加权平均值，也叫作期望值，所以平均时间复杂度的全称应该叫加权平均时间复杂度或者期望时间复杂度。
引入概率之后，前面那段代码的加权平均值为 (3n+1)/4。用大 O 表示法来表示，去掉系数和常量，这段代码的加权平均时间复杂度仍然是 O(n)。
均摊时间复杂度
均摊时间复杂度，听起来跟平均时间复杂度有点儿像。大部分情况下，我们并不需要区分最好、最坏、平均三种复杂度。平均复杂度只在某些特殊情况下才会用到，而均摊时间复杂度应用的场景比它更加特殊、更加有限。
// 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 == array.length 时，我们用 for 循环遍历数组求和，并清空数组，将求和之后的 sum 值放到数组的第一个位置，然后再将新的数据插入。但如果数组一开始就有空闲空间，则直接将数据插入数组。
最理想的情况下，数组中有空闲空间，我们只需要将数据插入到数组下标为 count 的位置就可以了，所以最好情况时间复杂度为 O(1)。最坏的情况下，数组中没有空闲空间了，我们需要先做一次数组的遍历求和，然后再将数据插入，所以最坏情况时间复杂度为 O(n)。
对一个数据结构进行一组连续操作中，大部分情况下时间复杂度都很低，只有个别情况下时间复杂度比较高，而且这些操作之间存在前后连贯的时序关系，这个时候，我们就可以将这一组操作放在一块儿分析，看是否能将较高时间复杂度那次操作的耗时，平摊到其他那些时间复杂度比较低的操作上。而且，在能够应用均摊时间复杂度分析的场合，一般均摊时间复杂度就等于最好情况时间复杂度。
版权属于：KevinBean
本文链接：https://www.kevinbean.top/index.php/default/37.html
转载时须注明出处及本声明