数据结构 - 时间空间复杂度(一)

一、算法时间复杂度

算法时间复杂度 以算法 中基本操作重复执行的次数 (简称为频度)作为算法的时间度量 。一般不必要精确计算出算法的时间复杂度,只要大致计算出相应的数量级即可

常见复杂度效率排序

按照算法执行效率从高到低排列,主流的时间复杂度顺序为:

er 三条规则:

则名称 规则内容 对应大O复杂度的本质
乘法规则 多项相乘都保留,并将系数化为1 嵌套代码的复杂度等于内外层复杂度的乘积,相乘后直接丢弃所有系数,仅保留量级本身。 例:O(2n) * O(3n) → 保留量级相乘结果n*n,系数置1,最终得到O(n²)
混合运算规则 先小括号、再乘法规则、最后加法规则 复杂度运算优先级和普通数学运算完全对齐:先计算括号内代码的复杂度,再处理嵌套/相乘的复杂度,最后合并所有并行代码段的复杂度。
加法规则 多项相加,保留最高阶项,并将系数化为1 多段并行代码的复杂度相加时,直接丢弃所有低阶项、常量项,仅保留增长速度最快的最高阶项,系数置1。 例:O(100) + O(5n) + O(3n²) → 丢弃低阶项,最终得到O(n²)

二、时间复杂度

1、非递归

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

‌特征 ‌:无论输入数据量 N 多大,算法的执行次数是固定的,不随 N 变化。

‌典型场景‌:数组索引访问、哈希表(HashMap)查找、固定次数的运算。

java 复制代码
public class ConstantTimeExample {
    // 示例 1:数组随机访问
    public static int getFirstElement(int[] arr) {
        if (arr == null || arr.length == 0) return -1;
        return arr[0]; // 无论数组长度是 10 还是 100万,只执行一次访问
    }

    // 示例 2:HashMap 查找
    public static String getValue(java.util.HashMap<String, String> map, String key) {
        return map.get(key); // 理想情况下,哈希查找耗时为常数
    }
}
2). 对数时间复杂度 O(log₂n)

‌特征 ‌:每次迭代将问题规模缩小为原来的一半(或其他固定比例)。

‌典型场景‌:二分查找、二叉搜索树(BST)查找。

java 复制代码
        int i=1;
        while(i<=n){
            System.out.print(i+"\t");
            i*=2;
        }

假设循环次数是x。

i = 1, 2, 4, 8, 16 ,i = 2^x

条件:i<=n

因此:2^x<=n

所以x<=1og2^n一共执行循环体1og2n次,所以复杂度是O(1og2^n)

3). 线性时间复杂度 O(N)

‌特征 ‌:算法执行次数与输入规模 N成正比。

‌典型场景‌:单层循环遍历数组、链表遍历、线性查找。

java 复制代码
public class LinearTimeExample {
    // 示例 1:遍历求和
    public static long sumArray(int[] arr) {
        long sum = 0;
        for (int num : arr) { // 循环 N 次
            sum += num;
        }
        return sum;
    }

    // 示例 2:线性查找最大值
    public static int findMax(int[] arr) {
        if (arr == null || arr.length == 0) throw new IllegalArgumentException();
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) { // 循环 N-1 次
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

‌分析‌:循环体内的基本操作执行了 N 次(或 N−1 次),忽略常数项后,时间复杂度为 O(N)。

4). 线性对数时间复杂度 O(Nlog⁡N)

‌特征 ‌:在规模为 N 的问题中,进行了 logN 层处理,每层处理耗时 O(N);或者对 N个元素各进行了一次 O(logN) 的操作。

‌典型场景‌:高效排序算法(快速排序、归并排序、堆排序)。

java 复制代码
      for (int k = 0; k <=n ; k++) {
            int i=1;
            while(i<=n){
                System.out.print(i+"\t");
                i*=2;
            }
            System.out.println();
        }

分析:

外部循环,时间复杂度为O(n)

内部循环,时间复杂度为O(log₂n)

要执行n次,时间复杂度为O(log₂n)*O(n)=O(nlog₂n)

时间复杂度 = O(nlog₂n) + O(n) = O(nlog₂n)

5). 平方时间复杂度 O(N²)

‌特征 ‌:嵌套循环,内层循环次数与外层循环规模相关。

‌典型场景‌:冒泡排序、选择排序、插入排序、双重循环比较所有元素对。

java 复制代码
        int x=1;
        for (int k = 1; k <=n; k++) {
            for (int i = 1; i <=n ; i++) {
                x++;
                System.out.println(x);
            }
        }
5). 立平方时间复杂 O(N³)
java 复制代码
        int x=1;
        for (int a = 1; a <=n; a++) {
            for (int k = 1; k <= n; k++) {
                for (int i = 1; i <= n; i++) {
                    x++;
                    System.out.println(x);
                }
            }
        }

2、递归-(展开式求复杂度)

递归的次数 × 每次递归的时间复杂度(适用于每次递归时间复杂度不变的情况)

(1)递归时间复杂度不变的情况

(2)递归时间复杂度变的情况

三、空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小 的一个量度,同样反映的是一个趋势,我们用 S(n) 来定义。空间复杂度比较常用的有:O(1)、O(n)、O(n²),我们下面来看看:

1)非递归

1、空间复杂度 O(1)

如果算法执行所需要的临时空间不随着某个变量n的大小而变化,即此算法空间复杂度为一个常量,可表示为 O(1)

java 复制代码
int i = 1;
int j = 2;
++i;
j++;

分析:

代码中的 i、j、m所分配的空间都不随着处理数据量变化,因此它的空间复杂度 S(n) = O(1)

2、空间复杂度 O(n)

java 复制代码
int[] m = new int[n]
for(i=1; i<=n; ++i)
{
   j = i;
   j++;
}

分析:

第一行new了一个数组出来,这个数据占用的大小为n,这段代码的2-6行,虽然有循环,但没有再分配新的空间,因此,这段代码的空间复杂度主要看第一行即可,即 S(n) = O(n)

3、空间复杂度 O(n²)

java 复制代码
        int n=10;
        int[][] x=new int[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++) {
                x[i][j] = j;
            }
        }

分析:

  • 代码执行了 int[][] x = new int[n][n];。
  • 这创建了一个 n×n 的二维整型数组。
  • 循环变量 i、j 以及常量 n 仅占用常数级别的内存空间,即 ‌**O(1)**‌。
  • 相比于数组占用的 n^2 空间,这些变量的空间消耗可以忽略不计。
  • 总空间需求 S(n)=O(n^2)+O(1)=O(n²)

2)递归(展开式求复杂度)

递归的次数 × 每次递归的空间复杂度(适用于每次递归空间复杂度不变的情况)

1、空间复杂度 O(1)

java 复制代码
   int f(int n){
        if(n==1) return 1;
        return n*f(n-1);
    }

分析:前提条件(不存在递归空间复杂度不变的情况)

触发终止条件n==1后,才会逐层弹出栈帧完成计算,将空间复杂度降为O(1)。

2、空间复杂度 O(n)

java 复制代码
 int f(int n){
        int a=1;
        if(n==1) return 1;
        return n*f(n-1);
    }

分析:

  • 函数内定义的局部变量a=1是固定占用的栈空间,和输入规模n无关,属于O(1)的常数空间开销。
  • 执行n次,有n个O(1),因此空间复杂度为O(n)

3、 对数空间复杂度 O(log₂n)

java 复制代码
  int f(int n){
        int a=1;
        if(n==1) return 1;
        return n*f(n/2);
    }

分析:

  • 初始输入为n,每次递归参数变为n/2,直到参数缩小到1时停止递归。
  • 递归的总层数满足 2^k≈n,解得递归深度 k=log⁡2^n,也就是深度为对数级。
  • 空间复杂度O(1)* O(log₂n )=O(log₂n)。

四、时间复杂度和空间复杂度区别

在于衡量维度完全不同 ‌:时间复杂度关注算法的运行快慢 ,空间复杂度关注算法运行时占用的额外内存大小 ,二者是评估算法性能的两个独立核心指标。

**核心区别:**时间复杂度看算法跑得多快,空间复杂度看算法占多少内存。

  • 时间复杂度:统计代码要执行多少次操作,次数越多跑得越慢
  • 空间复杂度:统计代码要额外申请多少内存,内存越多占的空间越大
  • 二者都用大O表示法,只看随输入规模增长的趋势,忽略常数细节

典型场景差异:

相关题目:

分析:A

  1. ‌时间复杂度分析 ‌:
    算法分为两个核心阶段:第一阶段是遍历整个数组一次,统计-1、0、1三类元素的个数,该操作的执行次数与数组长度n成正比,时间开销为O(n);第二阶段是根据统计得到的计数结果,直接在原数组上按顺序完成赋值填充,总赋值操作的次数恰好为n,时间开销同样为O(n)。两个线性级操作相加后,忽略常数系数,总时间复杂度为O(n),不存在嵌套循环等平方级的时间开销。
  2. ‌空间复杂度分析 ‌:
    算法仅需要定义3个固定的计数变量n1、n2、n3来存储三类元素的数量,全程直接在输入的原数组上完成修改,没有申请任何与输入规模n成正比的额外辅助空间,额外内存开销是固定的常数,因此空间复杂度为O(1)。

分析:C

  1. ‌时间复杂度分析 ‌:
    算法使用两个指针i从数组头部向右扫描,j从数组尾部向左扫描。指针i只会不断右移,指针j只会不断左移,两个指针的移动总次数不会超过数组的总元素个数n,所有比较操作的总次数和n呈线性关系,即使在最坏情况(数组全为正或全为负)下,总操作次数也为n量级,因此时间复杂度为O(n)。
  2. ‌空间复杂度分析 ‌:
    该算法属于原地重排算法,仅使用了固定数量的辅助变量i、j,以及交换元素时用到的临时变量,额外空间的大小和输入数组的规模n无关,仅需要常数级别的额外空间,因此空间复杂度为O(1)。

分析:D

根据上图来判断

  • 接下来是分数次幂的多项式n2/3,它属于O(n2/3),增长速度慢于线性阶的函数。
  • 1000n是线性阶,对应渐近复杂度O(n),常数系数不影响渐近阶的判断,它的增长速度比n2/3更快。
相关推荐
Pniubi44 分钟前
力扣2 . 两数相加
算法·leetcode·职场和发展
戴·菲瑜1 小时前
为什么PPO难以做出顶级棋类引擎
算法·博弈论·rl·ppo
在所不辞兄3 小时前
为什么数字孪生驱动的产线标定需要在线更新机制,而不能一次标定后长期沿用?
人工智能·神经网络·其他·算法·机器学习
郝学胜-神的一滴7 小时前
Effective Python 条款36:优雅拼装迭代器与生成器
开发语言·数据结构·人工智能·python·numpy·scikit-learn
AvocadoZeroOneOI8 小时前
B4500 [GESP202603 三级] 凯撒密码 详细解题报告
c++·算法
cjz389910 小时前
双指针技巧:覆盖式双指针(原地覆盖)
算法
梯度下降者10 小时前
GPT-5.6学会写代码来调工具了,Agent的架构正在被重写
软件工程·ai编程·工具调用·效率提升·架构重写
console.log('npc')12 小时前
Python 学习教程 · 第4课:数据结构
数据结构·python·学习
橘子1313 小时前
【高级数据库】关系代数基本概念
算法