Java 数据结构与算法：时间空间复杂度 从入门到实战全解

🏠个人主页：黎雁

🎬作者简介：C/C++/JAVA后端开发学习者

❄️个人专栏：C语言、数据结构（C语言）、EasyX、JAVA、数据结构与算法（JAVA）、游戏、规划、程序人生

✨ 从来绝巘须孤往，万里同尘即玉京

文章目录

• [Java 数据结构与算法：时间空间复杂度 从入门到实战全解 🚀](#Java 数据结构与算法：时间空间复杂度 从入门到实战全解 🚀)
• • [📝 文章摘要](#📝 文章摘要)
  • [🧠 前置知识回顾](#🧠 前置知识回顾)
• [一、数据结构与算法基础认知 📚](#一、数据结构与算法基础认知 📚)
• • [1. 什么是数据结构？](#1. 什么是数据结构？)
  • [2. 数据库 ≠ 数据结构（一定要分清）](#2. 数据库 ≠ 数据结构（一定要分清）)
  • [3. 数据结构与算法的关系](#3. 数据结构与算法的关系)
  • [4. 最实用的学习路线（直接照做）](#4. 最实用的学习路线（直接照做）)
• [二、算法复杂度：评价算法好坏的唯一标准 ⚖️](#二、算法复杂度：评价算法好坏的唯一标准 ⚖️)
• • [1. 两个核心概念](#1. 两个核心概念)
  • • [① 时间复杂度 ⏱️](#① 时间复杂度 ⏱️)
    • [② 空间复杂度 📦](#② 空间复杂度 📦)
    • [③ 时间 vs 空间：怎么取舍？](#③ 时间 vs 空间：怎么取舍？)
• [三、大O表示法：复杂度的统一语言 🧮](#三、大O表示法：复杂度的统一语言 🧮)
• • [Java 代码示例：简单复杂度分析](#Java 代码示例：简单复杂度分析)
• 四、三种情况：最好、最坏、平均
• 五、常见复杂度从快到慢排序（必须背）
• 六、空间复杂度（比时间简单）
• [七、LeetCode 经典实战（Java 版）✨](#七、LeetCode 经典实战（Java 版）✨)
• • [例题1：268. 丢失的数字](#例题1：268. 丢失的数字)
  • • 思路1：数学求和法（最优）
    • 思路2：异或法（更稳，不溢出）
  • [例题2：189. 旋转数组](#例题2：189. 旋转数组)
  • • 最优解：三次翻转法
• [📌 全篇核心干货总结](#📌 全篇核心干货总结)
• • [✍️ 写在最后](#✍️ 写在最后)

Java 数据结构与算法：时间空间复杂度 从入门到实战全解 🚀

算法入门第一课，吃透复杂度，刷题少走90%弯路！

📝 文章摘要

• 阅读时长：12 分钟
• 适合人群 ：
  1. Java 算法零基础初学者 → 重点看：数据结构概念、学习路线、复杂度定义与大O推导
  2. 准备开始刷力扣/剑指Offer 的同学 → 重点看：复杂度分析、实战例题、最优解判断
  3. 面试复习算法基础 → 重点看：复杂度对比、大O规则、时间/空间取舍思想
  4. 写技术博客/做知识复盘 → 重点看：结构逻辑、知识点梳理、表述规范
• 本文内容 ：全覆盖数据结构基础认知、算法学习方法、Java 版时间复杂度与空间复杂度、大O表示法、常见复杂度对比，并搭配两道经典 LeetCode 题进行复杂度实战分析，全程 Java 代码、图文清晰、全是干货。

---

🧠 前置知识回顾

在正式进入数据结构与算法之前，我们已经掌握：

1. Java 基础语法、数组、循环、方法
2. Java 集合框架（List、ArrayList 等）
3. 面向对象、继承、多态、泛型
4. 简单的代码编写与调试能力

而今天要学习的 数据结构与算法 + 复杂度分析 ，是所有进阶知识、框架源码、面试算法的基石。

---

一、数据结构与算法基础认知 📚

1. 什么是数据结构？

• 数据结构（Data Structure） ：计算机存储、组织和描述数据的方式。
• 简单理解：数据怎么放、怎么取、怎么查最高效。
• 在 Java 中：很多常用数据结构已经被 JDK 封装好，就是我们常用的 集合类（ArrayList、LinkedList、HashMap、TreeSet 等）。

2. 数据库 ≠ 数据结构（一定要分清）

• 数据库 ：用来持久化存储数据的软件（MySQL、Oracle 等）。
• 数据结构：数据在内存中的组织方式。
• 关系：数据库在底层存储数据时，会大量使用数据结构（如索引用 B+ 树）。

3. 数据结构与算法的关系

它们是相辅相成、不可分割的：

• 数据结构：数据怎么存
• 算法：数据怎么处理
• 好算法 + 好结构 = 高效程序

4. 最实用的学习路线（直接照做）

1. 手写代码 + 画图理解逻辑
2. IDEA 断点调试，看每一步变化
3. 写 CSDN 博客总结
4. 定期复盘巩固
5. 刷题提升
   • 《剑指 Offer 第2版 + 专项突破版》
   • LeetCode 热题 Hot100
   • 各类高频面试题

不刷题、不复盘，算法永远学不会！

---

二、算法复杂度：评价算法好坏的唯一标准 ⚖️

我们写代码，不只要能跑通，还要：

• 跑得够快（时间）
• 占内存够小（空间）

衡量这两点的，就是 时间复杂度 和 空间复杂度。

1. 两个核心概念

① 时间复杂度 ⏱️

• 定义：随着输入数据规模 n 增大，代码执行次数的增长趋势。
• 关注：数据量变大后，代码会不会"崩"。
• 和运行时间无关：不同机器速度不同，只看执行次数。

② 空间复杂度 📦

• 定义：算法运行时，临时占用的额外存储空间 随 n 的增长趋势。
• 注意：只算临时开辟的空间，不算输入/输出本身占用的空间。

③ 时间 vs 空间：怎么取舍？

• 早年内存贵：以时间换空间
• 现在内存充足：以空间换时间（更常用）
• 企业开发优先：时间效率 > 空间效率

---

三、大O表示法：复杂度的统一语言 🧮

大O表示法只看增长趋势，不看精确次数，规则只有三句：

1. 常数项直接去掉
   3 → O(1)
2. 只保留最高次项
   n² + 5n + 10 → O(n²)
3. 最高次项系数去掉
   3n² → O(n²)

一句话：只看量级，不看细节！

Java 代码示例：简单复杂度分析

public class Demo {
    public static void main(String[] args) {
        int n = 100;
        int sum = 0;        // 1次

        for (int i = 0; i < n; i++) {
            sum += i;       // n次
        }

        System.out.println(sum); // 1次
    }
}

总次数：1 + n + 1 = n + 2

按规则简化 → O(n)

---

四、三种情况：最好、最坏、平均

以在数组中找一个数为例：

• 最好情况：第一个就找到 → O(1)
• 最坏情况：遍历到最后才找到 → O(n)
• 平均情况：平均查找 n/2 次 → O(n)

✅ 默认都看最坏情况

因为它能给程序性能兜底：再差也不会比这个慢。

---

五、常见复杂度从快到慢排序（必须背）

复杂度	名称	速度	典型场景
O(1)	常数阶	极快	取值、运算、赋值
O(log n)	对数阶	极快	二分查找
O(n)	线性阶	快	单层循环、遍历
O(n log n)	线性对数阶	较快	快排、归并排序
O(n²)	平方阶	慢	双层循环、冒泡排序
O(2ⁿ)	指数阶	极慢	暴力递归斐波那契
O(n!)	阶乘阶	最慢	暴力全排列

增长速度：

O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ) < O(n!)

---

六、空间复杂度（比时间简单）

只看额外开辟的临时空间：

• O(1)：几个固定变量
• O(n)：长度为 n 的数组/集合
• O(log n)：递归深度（如二分递归）
• O(n²)：n×n 二维数组

示例：

// 空间 O(1)
int a = 10;
int b = 20;

// 空间 O(n)
int[] arr = new int[n];

---

七、LeetCode 经典实战（Java 版）✨

例题1：268. 丢失的数字

题目 ：给定 [0,n] 中的 n 个数，找缺失的那个数。
要求：时间 O(n)，空间 O(1)

思路1：数学求和法（最优）

public int missingNumber(int[] nums) {
    int n = nums.length;
    int sum = n * (n + 1) / 2;

    int realSum = 0;
    for (int num : nums) {
        realSum += num;
    }

    return sum - realSum;
}

• 时间：O(n)
• 空间：O(1)

思路2：异或法（更稳，不溢出）

public int missingNumber(int[] nums) {
    int res = nums.length;
    for (int i = 0; i < nums.length; i++) {
        res ^= i ^ nums[i];
    }
    return res;
}

• 时间：O(n)
• 空间：O(1)

---

例题2：189. 旋转数组

题目 ：将数组向右旋转 k 位，原地修改，空间 O(1)

最优解：三次翻转法

public void rotate(int[] nums, int k) {
    int n = nums.length;
    k %= n;

    reverse(nums, 0, n - 1);
    reverse(nums, 0, k - 1);
    reverse(nums, k, n - 1);
}

private void reverse(int[] nums, int left, int right) {
    while (left < right) {
        int temp = nums[left];
        nums[left] = nums[right];
        nums[right] = temp;
        left++;
        right--;
    }
}

• 时间：O(n)
• 空间：O(1)

---

📌 全篇核心干货总结

1. 数据结构：数据的存储组织方式，Java 中体现为集合类。
2. 学习路线：写代码 + 画图 + 调试 + 博客 + 复盘 + 刷题（剑指Offer + Hot100）。
3. 时间复杂度：执行次数的增长趋势。
4. 空间复杂度：临时额外占用空间的增长趋势。
5. 大O规则：去常数、去系数、留最高次项。
6. 复杂度速度 ：
   O(1) > O(log n) > O(n) > O(n log n) > O(n²) > O(2ⁿ)
7. 企业原则：优先时间，空间换时间。
8. 两道经典题 ：
   • 丢失的数字：求和法 / 异或法
   • 旋转数组：三次翻转（原地最优）

---

✍️ 写在最后

数据结构与算法，是程序员的内功 。

而复杂度分析 ，是判断你代码优不优秀的第一把尺子。

从今天开始，写每一段代码都问自己三句：

• 时间复杂度是多少？
• 空间复杂度是多少？
• 还能不能更优？

坚持下去，你会越来越接近"一眼看出最优解"的境界。

本篇是算法系列的开篇奠基之作，下一篇我们正式进入：
线性表 ------ 数组、链表、栈、队列 从原理到手写

觉得这篇文章清晰、干货、适合 Java 学习者，欢迎 点赞 👍 收藏 💾 评论 + 关注，持续更新高质量算法博客！