《hello算法》之时间复杂度

最新推荐文章于 2024-07-08 22:12:26 发布

烟雨殇离

最新推荐文章于 2024-07-08 22:12:26 发布

阅读量964

点赞数 7

分类专栏：数据结构与算法-Hello算法文章标签：算法 python

本文链接：https://blog.csdn.net/m0_46427778/article/details/139684060

版权

数据结构与算法-Hello算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Hello算法第三课

时间复杂度

时间复杂度

运行时间可以直观且准确的反映算法的效率。想要准确预估一段代码的运行时间，需要

1、确定运行平台，包括硬件配置、编程语言、系统环境等。
2、评估各种计算操作所需的运行时间。例如加法操作+需要1ns，乘法操作*需要10ns，打印操作print()需要5ns等。
3、统计代码中所有的计算操作，并将所有操作的执行时间求和，从而得到运行时间。
例如下代码中，输入数据大小为n,

def algorithm(n:int):
    a = 2       # 1 ns
    a = a + 1   # 1 ns
    a = a * 2   # 10 ns
    # 循环n次
    for _ in range(n):  # 1 ns
        print(0)        # 5 ns
"""统计代码运行时间为：1+1+10+(1+5)*n=(6n+12) ns"""

实际上统计算法的运行时间既不合理也不现实，(一)操作时间和特定运行平台绑定，(二)很难获知每种操作的运行时间。

统计时间增长趋势

# 算法A的时间复杂度：常数阶
def algorithm_A(n: int):
    print(0)

# 算法B的时间复杂度：线性阶
def algorithm_B(n: int):
    for _ in range(n):
        print(0)
    
# 算法C的时间复杂度：常数阶
def algorithm_C(n: int):
    for _ in range(1000000):
        print(0)

算法A只有1个打印操作，运行时间不随着n增大而增大，称此算法的时间复杂度为“常数阶”；算法B的打印操作需要循环n次，运行时间随着n增大呈线性增长，时间复杂度称为“线性阶”；算法C的打印操作需要循环1000000，虽然运行时间很长，但是与输入数据大小n无关，因此时间复杂度仍是“常数阶”。

时间复杂度(统计增长趋势)的特点

简单：操作时间和增长趋势无关，因此仅需统计操纵数量。
有效：只有n足够大，算法B一定会比算法C更慢。
局限：无法完全反映算法效率的优劣。

复杂度符号表示(O)

大O记号表示操作数量函数T(n)的渐近上界，复杂度分析实质上就是计算T(n)的渐近上界。

def algorithm(n: int):
    a = 1       # +1 ns
    a = a + 1   # +1 ns
    a = a * 2   # +1 ns
    # 循环n次
    for _ in range(n):  # +1 ns
        print(0)        # +1 ns
""" 操作数量T(n) = 3 + 2n -> 时间复杂度O(n)"""

操作数量函数的渐近上界如图所示

推算方法

一、统计操作数量

忽略T(n)中的常数项。操作数量函数T(n)中的常数项都与n无关，对时间复杂度不产生影响，都可以被忽略。
省略n的所有系数。如循环2n次、5n+1次等，都可以简化记为n次，因为n前面的系数对时间复杂度没有影响。
循环嵌套时使用乘法。总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用第1.点和第2.点的技巧。
例如

def algorithm(n: int):
    a = 1       # +0 (技巧1)
    a = a + n   # +0 (技巧1)
    # +n (技巧2)
    for i in range(5 * n + 1):  
        print(0)
    # +n*n (技巧3)      
    for i in range(2 * n):
        for j in range(n + 1):
            print(0)  
"""完整统计的T(n) = 2n(n+1)+(5n+1)+2；省略统计T(n) = n^2^ +n"""

二、判断渐近上界

时间复杂度由多项式T(n) 中最高阶的项来决定。当n趋于无穷大时，最高阶的项将发挥主导作用，其他项的影响都可以被忽略。

操作数量 T(n)	时间复杂度O(f(n))
100000	O(1)
3n+2	O(n)
2n² +3n+2	O(n²)
n³ +1000n²	O(n³)
2ⁿ +1000n¹⁰⁰⁰	O(2ⁿ)

常见类型

假设输入数据大小为n，常见的时间复杂度类型如图所示(按照从低到高的顺序排列)。
O(1)<O(log n)<O(n)<O(n log n)<O(n²)<O(2ⁿ)<O(n!)
常数阶<对数阶<线性阶<线性对数阶<平方阶<指数阶<阶乘阶

常数阶O(1)

常数阶的操作数量与输入数据大小n无关，即不随着n的变化而变化。如下例，尽管操作数量size很大，但是其与输入数据大小n无关，时间复杂度仍为O(1)。

def constant(n: int) -> int:
    """常数阶"""
    count=0
    size=100000
    for _ in range(size):
        count += 1
    return count

线性阶O(n)

操作数量相对于输入数据大小n以线性级别增长，通常出现在单层循环中；遍历数组和遍历链表等操作的时间复杂度均为O(n)，其中n为数组或链表的长度。输入数据大小n需根据输入数据的类型来具体确定。

def array_traversal(n: int) -> int:
    """线性阶"""
    count = 0
    for _ in range(n):
        count += 1
    return count

def array_traversal(nums: list[int])-> int:
    """线性阶(遍历数组)"""
    count = 0
    #循环次数与数组长度成正比
    for num in nums:
        count += 1
    return count

平方阶O(n²)

操作数量相对于输入数据大小n以平方级别增长，通常出现在嵌套循环中，外层循环和内存循环都为O(n)，因此总体为O(n²)。

def quadratic(n: int) -> int:
    """平方阶"""
    count = 0
    #循环次数与数据大小n成平方关系
    for i in range(n):
        for j in range(n):
            count += 1
    return count

常数阶、线性阶和平方阶的时间复杂度对比图。
三种时间复杂度
冒泡排序：外层循环执行n-1次，内层循环执行n-1、n-2、…、2、1次，平均为n/2次，因此时间复杂度为O((n-1)n/2)=O(n²)。

def bubble_sort(nums: list[int]) -> int:
    """平方阶(冒泡排序)"""
    count = 0 # 计数器
    # 外循环：未排序区间为[0, i]
    for i in range(len(nums) - 1, 0, -1):
        # 内循环：将未排序区间[0, i]中的最大元素交换至该区间的最右端
        for j in range(i):
            if nums[j] > nums[j+1]:
                # 交换nums[j]与nums[j+1]
                # nums[j], nums[j+1] = nums[j+1], nums[j]
                tmp: int = nums[j]
                nums[j] = nums[j+1]
                nums[j+1] = tmp
                count += 3 # 元素交换包含3个单元操作：赋值
    return count

指数阶O(2ⁿ)

生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为1个细胞，分裂一轮后变为2个，分裂两轮后变为4个，以此类推，分裂㼿轮后有2n个细胞，如下所示，时间复杂度为O(2ⁿ)。

def exponential(n: int) -> int:
    """指数阶(循环实现)"""    
    count = 0
    base = 1
    #细胞每轮一分为二，形成数列1,2,4,8,...,2^(n-1)
    for _ in range(n):
        for _ in range(base):
            count += 1
        base *= 2
    #count=1+2+4+8+..+2^(n-1)=2^n-1
    return count

指数阶的时间复杂度
也常出现于递归函数中。指数阶增长非常迅速，在穷举法（暴力搜索、回溯等）中比较常见。对于数据规模较大的问题，指数阶是不
可接受的，通常需要使用动态规划或贪心等算法来解决。

def exp_recur(n: int) -> int:
    """指数阶(递归实现)"""
    if n == 1:
        return 1
    return exp_recur(n-1) + exp_recur(n-1) + 1

对数阶O(log n)

对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为n，由于每轮缩减到一半，因此循环次数是log₂n，即2ⁿ的反函数。常出现于递归函数中。对数阶常出现于基于分治策略的算法中，体现了“一分为多”和“化繁为简”的算法思想。它增长缓慢，是仅次于常数阶的理想的时间复杂度。

如例所示，时间复杂度为对数阶O(log₂n)，简记为O(log n)。

def logarithmic(n: int) -> int:
    """对数阶(循环实现)"""
    count = 0
    while n > 1:
        n = n / 2
        count += 1
    return count

对数阶的时间复杂度

def log_recur(n: int) -> int:
    """对数阶(递归实现)"""
    if n <= 1:
        return 0
    return log_recur(n / 2) + 1

线性对数阶O(n log n)

常出现于嵌套循环中，两层循环的时间复杂度分别为O(log n)和O(n)。

def linear_log_recur(n: int) -> int:
    """线性对数阶"""
    if n <= 1:
        return 1
    count: int = linear_log_recur(n // 2) + linear_log_recur(n // 2)
    for _ in range(n):
        count += 1
        return count

下图展示了线性对数阶O(n log n)的生成方式。二叉树的每一次的操作总数都为n，树共有log₂n + 1层，时间复杂度为O(n log n)。主流排序算法的时间复杂度通常为O(n log n)，如快速排序、归并排序、堆排序等。
线性对数阶的时间复杂度

阶乘阶O(n!)

阶乘阶对应数学上的“全排列”问题。给定n个互不重复的元素，求其所有可能的排列方案为n!。阶乘通常使用递归实现。如例所示，第一次分裂出n个，第二层分裂出n-1个，以此类推，直至第n层时停止分裂，但当n>=4时恒有n!>2ⁿ，所有阶乘阶比指数阶增长更快，在n较大时也是不可接受的。

def factorial_recur(n: int) -> int:
    """阶乘阶(递归实现)"""
    if n == 0:
        return 1
    count = 0
    # 从1个分裂出n个
    for _ in range(n):
        count += factorial_recur(n - 1)
    return count

阶乘阶的时间复杂度

最差、最佳、平均时间复杂度

算法的时间效率往往不是固定的，而是与输入数据的分布有关。
例：假设输入一个长度为n的数组nums，其中nums由从1至n的数字组成，每个数字只出现一次；但元素顺序是随机打乱的，任务目标是返回元素1的索引。我们可以得出以下结论。

当nums=[?,?,…,1]，即当末尾元素是1时，需要完整遍历数组，达到最差时间复杂度O(n)。
当nums=[1,?,?,…]，即当首个元素为1时，无论数组多长都不需要继续遍历，达到最佳时间复杂度O(1)。
随机数据分布时，数组是打乱的，因此元素1出现在任意索引的概率都是相等的，那么算法的平均循环次数就是数组长度的一半n/2，平均时间复杂度为O(n/2)=O(n)。
在实际中很少使用最佳时间复杂度，因为通常只有在很小概率下才能达到，可能会带来一定的误导性。而最差时间复杂度更为实用，因为它给出了一个效率安全值，让我们可以放心地使用算法。平均时间复杂度可以体现算法在随机输入数据下的运行效率，但对于较为复杂的算法，计算平均时间复杂度往往是比较困难的，因为很难分析出在数据分布下的整体数学
期望。在这种情况下，我们通常使用最差时间复杂度作为算法效率的评判标准。

import random
def random_numbers(n: int) -> list[int]:
    """生成一个数组，元素为:1,2,...,n，顺序被打乱"""
    #生成数组nums=:1,2,3,...,n
    nums = [i for i in range(1, n + 1)]
    # 随机打乱数组元素
    random.shuffle(nums)
    return nums

def find_one(nums: list[int]) -> int:
    """查找数组nums中数字1所在索引"""
    for i in range(len(nums)):
        #当元素1在数组头部时，达到最佳时间复杂度O(1)
        #当元素1在数组尾部时，达到最差时间复杂度O(n)
        if nums[i] == 1:
            return i
    return -1  #元素1不存在于数组中

烟雨殇离

关注

7
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
《hello算法》之时间复杂度

算法C的打印操作需要循环1000000，虽然运行时间很长，但是与输入数据大小n无关，因此时间复杂度仍是“常数阶”。生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为1个细胞，分裂一轮后变为2个，分裂两轮后变为4个，以此类推，分裂㼿轮后有2n个细胞，如下所示，时间复杂度为O(2。、2、1次，平均为n/2次，因此时间复杂度为O((n-1)n/2)=O(n。n + 1层，时间复杂度为O(n log n)。如例所示，第一次分裂出n个，第二层分裂出n-1个，以此类推，直至第n层时停止分裂，但当n>=4时恒有n!
复制链接

扫一扫