blog/_posts/算法/algorithm-characteristic.md

230 lines
8.6 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

---
title: 👶算法中的空间复杂度与时间复杂度理解
date: 2023-11-04
tags: 算法
---
## 算法的本质
算法algorithm的本质是将问题划分为一系列可执行的步骤并通过合理的计算和操作来达到预期的结果。同一个问题可以使用不同算法解决但计算过程中消耗的时间和资源可能千差万别。
那如何比较不同算法之间的优劣呢?目前分析算法主要从时间和空间两个维度进行。
1. 时间维度:时间复杂度(time complexity),算法需要消耗的时间。
2. 空间维度:空间复杂度(space complexity),算法需要占用的内存空间。
因此,分析算法利弊主要从时间复杂度和空间复杂度进行。大多时候二者不可兼得,有时用时间换空间,有时用空间换时间,来满足所在场景需要!
<!--more-->
## 1. 时间复杂度 Time Complexity
时间复杂度是衡量算法执行时间的增长率表示算法在处理输入规模增大时所需的时间。时间复杂度通常用大O符号O表示后跟一个表示增长率的函数.常见的时间复杂度有O(1)、O(log n)、O(n)、O(n log n)、O(n^2)等。
### O(1) (常数时间 Contant Time)
常数时间算法不会随数据量变化而变,时间固定。如下算法:
```php
/**
* 获取数组的第一个元素
*/
function array_first(array $array) {
return $array[0] ?? null;
}
// 示例用法
$array = [1, 2, 3, 4, 5];
$result = array_first($array);
echo $result; // 输出1
```
该函数执行所需时间与 `$array` 数组大小无关。无论数组有十个元素,还是一万个元素,该函数都只检查数组第一个元素。数据量变大时,算法所需时间保持不变。
为简便起见,用`O(1)`来表示常数时间。
### O(n)(线性时间 Linear Time
线性时间复杂度是最好理解的。随着数据量增加,耗费时间同步增加。如下算法:
```php
/**
* 数组求和
*/
function array_sum_items(array $array) {
$sum = 0;
foreach ($array as $element) { // 遍历数组中的每个元素
$sum += (int)$element; // 将元素累加到总和中
}
return $sum;
}
// 示例用法
$array = [1, 2, 3, 4, 5];
$result = array_sum_items($array);
echo $result; // 输出15
```
为简便起见,用`O(n)`表示线性时间复杂度。
### O(n^2)(平方时间 Quadratic Time
平方时间Quadratic Time也称为n的平方平方时间复杂度算法耗费时间是数据量的平方。参考以下代码
```php
function array_multiplication(array $array) {
$result = [];
foreach ($array as $element1) { // 遍历数组中的每个元素
foreach ($array as $element2) { // 遍历数组中的每个元素
$product = $element1 * $element2; // 计算两个元素的乘积
$result[] = $product; // 将乘积添加到结果数组中
}
}
return $result;
}
// 示例用法
$array = [1, 2, 3];
$result = array_multiplication($array);
print_r($result); // 输出Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 2 [4] => 4 [5] => 6 [6] => 3 [7] => 6 [8] => 9 )
```
上述代码中,`array_multiplication`函数接受一个数组作为输入并计算数组中每两个元素的乘积并将乘积存储在结果数组中。算法使用了嵌套的foreach循环来遍历数组中的每个元素因此算法的执行时间与输入数组大小的平方成正比。所以它的时间复杂度是O(n^2),即平方时间复杂度。
常规来讲同一问题下线性时间复杂度要好于平方时间复杂度。
### O(log n)(对数时间 Logarithmic Time
对数时间Logarithmic Time也称为n的对数对数时间复杂度算法耗费时间与数据量呈现对数走势。参考以下代码
```php
function array_add_log(int $n) {
$result = 0;
for ($i = 1; $i <= $n; $i *= 2) { // 每次将 i 乘以 2
$result++;
}
return $result;
}
// 示例用法
$n = 16;
$result = array_add_log($n);
echo $result; // 输出5
```
上述代码中,`array_add_log`函数接受一个整数n作为输入并使用一个循环来以2的幂次递增的方式遍历从1到n的范围。在每次循环迭代中$i的值将乘以2。算法的循环次数取决于$i的增长速度即取决于n的对数走势。因此该算法的时间复杂度是O(log n),即对数时间复杂度。
### O(n log n) 准线性时间 Quasilinear Time
准线性时间算法比线性时间算法效率低,但比平方时间算法效率高。如下代码:
```php
function array_add_near_line(array $array) {
$length = count($array);
$result = 0;
for ($i = 0; $i < $length; $i++) {
$result += $array[$i];
}
return $result;
}
// 示例用法
$array = [1, 2, 3, 4, 5];
$result = array_add_near_line($array);
echo $result; // 输出15
```
上述代码中,`array_add_near_line`函数接受一个数组作为输入,并遍历数组中的每个元素,将它们累加到结果中。该算法的执行时间与输入数组的大小成正比,因此它的时间复杂度可视为准线性时间复杂度。
## 2. 空间复杂度 Space Complexity
空间复杂度是衡量算法在执行过程中所需的额外空间的度量方式。它描述了算法在处理输入规模增大时所需的额外内存空间。
空间复杂度通常用大O符号O表示后跟一个表示空间占用的函数。它表示算法所需的额外空间随着输入规模的增加而增加的趋势, 常见的空间复杂度有:
O(1)、O(n)、O(n^2)、O(log n)。从名字看出空间复杂度和时间复杂度表示差不多,即:常数复杂度、线性复杂度、平方复杂度、指数复杂度。
### O(1) (常数空间 Contant Space)
常数空间复杂度算法内存占用不会随数据量变化而变,占用空间固定。如下算法:
```php
function array_sum_contant(int $n) {
$sum = 0;
for ($i = 1; $i <= $n; $i++) {
$sum += $i;
}
return $sum;
}
// 示例用法
$n = 5;
$result = array_sum_contant($array);
echo $result; // 输出15
```
在上面的代码中,`array_sum_contant`函数接受一个整数n作为输入并计算从1到n的所有数字的总和。该算法只使用了一个额外的变量$sum来存储计算结果而不随着输入规模的增加而增加额外的空间。因此该算法的空间复杂度是O(1),即常数空间复杂度。
### O(n)(线性空间 Linear Spance
线性空间复杂度是最好理解的。随着计算数据量增加,耗费空间同步线性增加。如下算法:
```php
function array_linear(int $n) {
$result = [];
for ($i = 1; $i <= $n; $i++) {
$result[] = $i;
}
return $result;
}
// 示例用法
$n = 5;
$result = array_linear($n);
print_r($result); // 输出Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 )
```
上面的代码中,`array_linear`函数接受一个整数n作为输入并生成一个包含从1到n的所有数字的数组。该算法使用了一个额外的数组$result来存储生成的数字其大小与输入规模n成正比。因此该算法的空间复杂度是O(n),即线性空间复杂度。。
### O(n^2)(平方空间 Quadratic Space
平方空间Quadratic Space也称为n的平方随着计算数据量增加占用空间是增加数量平方。参考以下代码
```php
function array_square(int $n) {
$result = [];
for ($i = 1; $i <= $n; $i++) {
for ($j = 1; $j <= $n; $j++) {
$result[] = $i * $j;
}
}
return $result;
}
// 示例用法
$n = 3;
$result = array_square($n);
print_r($result); // 输出Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 2 [4] => 4 [5] => 6 [6] => 3 [7] => 6 [8] => 9 )
```
上面的代码中,`array_square`函数接受一个整数n作为输入并生成一个包含从1到n的所有数字的平方的数组。该算法使用了一个额外的数组$result来存储生成的结果其大小与输入规模n的平方成正比。因此该算法的空间复杂度是O(n^2),即平方空间复杂度。
### O(log n)(对数空间 Logarithmic Space
```php
function array_space_log(int $n) {
$result = [];
$i = 1;
while ($i <= $n) {
$result[] = $i;
$i *= 2;
}
return $result;
}
// 示例用法
$n = 10;
$result = logarithmicSpaceAlgorithm($n);
print_r($result); // 输出Array ( [0] => 1 [1] => 2 [2] => 4 [3] => 8 )
```
上述代码中,`array_space_log`函数接受一个整数n作为输入并生成一个包含从1到n之间的所有2的幂次的数组。该算法使用了一个额外的数组$result来存储生成的结果其大小与输入规模n的对数成正比。因此该算法的空间复杂度是O(log n),即对数空间复杂度。