算法时间复杂度和空间复杂度—算法系列

这是我参与更文挑战的第 16 天，活动详情查看: 更文挑战

序言

虽然做了多年 coding 工作，但是谈起算法，还是觉得离自己很远，似乎没有算法也可以写出能够满足用户需求的程序。不过最近觉得自己这样下去很难有所提升，所以准备开始刷题。

开始刷了点 LeetCode 的题，感觉有点无从下手，不知所措的感觉。为此决定还是从基础开始吧，先看数据结构。那么我们算法除了实现一些方法，而且更多会考虑时间和空间资源上销毁

在学习代码过程我们首先是要实现功能，然后再去提升性能，当你更多精力和时间是专注性能而非时间时候，好，这是你已经是今非昔比，功力提升一层，

不过时间复杂度是不能脱离实际，时间复杂度是用来衡量一个算法优劣的。所以随后我们会结合排序算法和搜索算法来具体说一说算法。

O分析主要用于衡量和比较算法在最坏情况下的理论运行时间复杂度，

基本信息

分类	内容
更新频率	日更(尽量)
语言	python /java
适用范围	面试

什么是算法

算法(Algorithm)是指用来操作数据、解决程序问题的一组方法。对于同一个问题，可能会有多种不同的算法来给出正确答案，但在过程中消耗的资源和时间却会有很大的区别。这也就是我们研究算法的目的。

时间复杂度和空间复杂度

时间复杂度：是指执行当前算法所消耗的时间。
空间复杂度：是指执行当前算法需要占用多少内存空间。

因此，评价一个算法的效率主要是看它的时间复杂度和空间复杂度情况。然而，有的时候时间和空间却又是鱼和熊掌，不可兼得的，那么我们就需要从中去取一个平衡点。

语言

准备提供这些语言版本关于问题的解决方案。

javascript
java
python
go
rust
cpp

时间复杂度

平时优化 code 时，我通常是在代码段前后输出时间来计算方法的耗时，认为这就是算法消耗的时间。不过我们这种优化的前提是我们使用的同样硬件配置，因为这个算法更多是因为硬件支持。其实我们是有一套尺度来衡量我们算法。

因此，另一种更为通用的方法就出来了：大 $O$ 符号表示法，即 $T(n) = O(f(n))$

const n = 10;
var j = 0;
for(let i=1; i<=n; ++i)
{
   j = i;
   j++;
}

通过大 O 符号表示法，这段代码的时间复杂度为：O(n) ，为什么呢?

复杂度量级

常见的时间复杂度量级有：

常数阶O(1)
对数阶O(logN)
线性阶O(n)
线性对数阶O(nlogN)
平方阶O(n²)
立方阶O(n³)
K 次方阶O(n^k)
指数阶(2^n)

常数时间复杂度 $O(1)$

def get_first_element(my_list):
    return my_list[0]

def calc_sum(my_list):
    total = 0
    for num in my_list:
        total += num
    return total

const N = 10;
var a = 0;
var b = 0;
for (let i = 0; i < N; i++) {
    a = a + Math.random()    // $N \times 1$ 操作 = O(N)
}

也就是运算时间随着输入数据的大小线性增长，

维度	值
时间复杂度	O(N)
空间复杂度	O(1)

for (let i = 0; i < N; i++) {
    a = a + Math.random()    // $N \times 1$ 操作 = O(N)
    b = b + Math.random()    // $N \times 1$ 操作 = O(N)
}

维度	值
时间复杂度	O(N) + O(N) = O(N)
空间复杂度	O(1)

for (let i = 0; i < N/2; i++) {
    b = b + Math.random()    // $ \frac{1}{2} N \times 1$ 操作 = O(N)
}

维度	值
时间复杂度	$\frac{1}{2} \times O(N) = O(N)$
空间复杂度	O(1)

空间复杂度 O(1) 因为不依赖于 N 所以是常数复杂度

for (let i = 0; i < N; i++) {
    for (let j = N; j > i; j--) {
        a = a + i + j;
    }
}

最简单有效方法，就是我们将每一个步骤一一列出后来总结规律来解决问题

 i = 0: j = N...1 (N)
 i = 1: j = N...2 (N-1)
 i = 3: j = N...3 (N-2)
 i = N-1: j = N (1)

时间复杂度，因为 $O(N^2)$ 复杂度要严格大于 $O(N)$ 的复杂度 $1 + 2 + 3 ,\dots + N = N \times \frac{N + 1}{2} = N \times \frac{N}{2} + \frac{N}{2}$ $= \frac{1}{2} \times O(N^2) + \frac{1}{2} \times O(N) = O((N^2) + O(N) = O((N^2)$

维度	值
时间复杂度	$O(N^2)$
空间复杂度	$O(1)$

var a = 0;
var i = N;

while (i > 0) {
    a += i; //1 个操作
    i /= 2; //1 个操作
}

在算法中，时间复杂度度是一个单位，而不是具体用的时间，这一点希望大家一定要清楚，我们通过不同量级(单位)来衡量单位。例如我们平时使用时间单位，时、分和秒，而不是具体用了几个小时。而不是具体给出某一个算法具体耗时。这一点对于初学者可能是比较confusing

常数阶 $O(1)$

console.log("hello world")

这里执行一个操作就是 $O(1)$ 一个常数操作，输出三次 HelloWorld 也只算 $O(1)$ 这里 1 表示常数单位而不是具体数字 1 的意思。

线性阶 $O(n)$

var N = 10;

for(let i = 0; i < N; i++){
    console.log("hello world");
}

这里有一个循环说明执行 helloWord 输出操作与 N 有关所以记做 $O(N)$

平方阶 $O(n^2)$

for(let i =0; i < N; i++){
    for(let j=0; j< N; j++){
        console.log(i)
    }
}

冒泡算法

def bubble_sort(my_list):
    n = len(my_list)
    for i in range(n):
        for j in range(0, n-i-1):
            if my_list[j] > my_list[j+1]:
                my_list[j], my_list[j+1] = my_list[j+1], my_list[j]
    return my_list

立方阶 $O(n^3)$

例如矩阵相乘就是 $O(n^3)$ 时间复杂度，三重嵌套循环，

for(let i =0; i < N; i++){
    for(let n=0; n< N; n++){
        for(let m =0; m < N; m++){
            console.log(i)
        }
    }
}

$T(n) = n * n * n = n^3$ 到现在大家不难发现就是有几层 for 循环，时间复杂度就是 n 的几次方。

对数阶 $O(\log n)$

var N = 32
while(N > 0){
  console.log("hello world")
  N = N/2
}

这里我们要说一件事，就是这个 $O(\log n)$ 要远远小于 $O(n)$ 只要我们记住 $O(1) <$

$O(n \log n) 线性对数阶$

var N = 100
for(let i=1; i<N; i++)
{
    i = 1;
    while(i<N)
    {
        i = i * 2;
    }
}

$T(n) = O(n \log n)$

归并排序（Merge Sort是一种有效的排序算法，采用分而治之（Divide and Conquer）的方法进行排序。其主要思想是将大问题分解成一个一个的小问题，逐个击破，然后将小问题的解决方案组合起来解决大问题。具体到归并排序，这个“大问题”就是对整个数组进行排序，而“小问题”是对数组的子序列进行排序。

def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        L = arr[:mid]
        R = arr[mid:]

        merge_sort(L)
        merge_sort(R)

        i = j = k = 0

        while i < len(L) and j < len(R):
            if L[i] < R[j]:
                arr[k] = L[i]
                i += 1
            else:
                arr[k] = R[j]
                j += 1
            k += 1

        while i < len(L):
            arr[k] = L[i]
            i += 1
            k += 1

        while j < len(R):
            arr[k] = R[j]
            j += 1
            k += 1

# 示例用法
my_list = [12, 11, 13, 5, 6, 7]
merge_sort(my_list)
print("Sorted array is: ", my_list)

快速排序（Quick Sort）是一种高效的排序算法，由托尼·霍尔在 1960 年提出。它是一种基于分治法的比较排序，在平均情况下，排序n个项目要 $O(n \log n)$ 的时间复杂度。尽管它的最坏运行时间是 $O(n^2)$ ，但这种情况并不常见。实际上，快速排序通常明显比其他 $O(n log n)$ 算法更快，因为它的内部循环可以在大多数架构上非常高效地被实现出来

快速排序

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    
    pivot = arr[len(arr)//2]
    left =  [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

快速排序算法在最坏情况下的时间复杂度为 O(n²)。这种最坏情况通常发生在以下两种情况之一：

已经排序的数组（或接近排序） ：如果每次分区操作总是选择到最小或最大的元素作为基准值（pivot），这种情况下，快速排序的性能会降低。例如，如果数组已经是升序或降序排序，且每次选择第一个或最后一个元素作为基准，那么每次分区操作只会减少一个元素，导致需要进行 n-1 次分区操作。
包含许多重复元素的数组：如果数组中包含大量相同的元素，且这些元素经常被选为基准，那么快速排序的效率也会降低。在这种情况下，分区可能不会均匀地划分数组，从而导致与已排序数组类似的效果。

在这两种情况下，快速排序的分区操作不能有效地将问题划分为大致相等的子问题，导致递归深度接近于 n，而每一层递归都需要进行线性时间的分区操作。因此，总体的时间复杂度变为 O(n²)。

为了避免这种最坏情况，一个常见的策略是随机选择基准值，或使用一些启发式方法来选择一个“好”的基准值，比如选择头、中、尾三个值的中位数作为基准。这样做可以增加算法在平均情况下的效率，使其更接近于最佳性能 O(n log n)。

算法时间复杂度和空间复杂度—算法系列

序言

基本信息

什么是算法

时间复杂度和空间复杂度

语言

时间复杂度

复杂度量级

常数时间复杂度O(1)O(1)O(1)

常数阶 O(1)O(1)O(1)

线性阶O(n)O(n)O(n)

平方阶O(n2)O(n^2)O(n2)

立方阶 O(n3)O(n^3)O(n3)

对数阶O(log⁡n)O(\log n)O(logn)

O(nlog⁡n)线性对数阶O(n \log n) 线性对数阶O(nlogn)线性对数阶