线段树学习记录

最新推荐文章于 2026-06-24 23:29:20 发布

原创最新推荐文章于 2026-06-24 23:29:20 发布 · 1k 阅读

23 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#学习 #算法 #java

前言：最近主播在学习线段树，遇到了许多问题，通过查阅很多资料，思考后，一一解决了，于是便想整理一篇文章。一是为了自己加强理解，二是为了帮助大家少走一些弯路。

闲言少叙，书归正传，让我们开始奇妙的线段树之旅吧！

一、线段树是什么，为什么要用线段树，它的好处是什么？

线段树是什么？
一棵二叉树状的数据结构，每个节点管理数组的一段区间，节点里存储该区间的统计信息，并且通过递归将区间二分，支持高效的区间查询和区间更新。

为什么要用线段树？
当仅用前缀和、差分、树状数组等手段无法同时满足「区间修改」和「区间查询」的高效性需求时，线段树提供了一种通用、可扩展的解法。它可以在 O(log n) 时间内完成各种复杂的区间操作。

线段树的好处是什么？

时间复杂度稳定而且对大规模数据友好；
支持多种区间数据的维护与更新（求和、最值、翻转、赋值、乘法等）；
空间开销在可接受范围内；
可以与其他数据结构结合，灵活拓展以应对更复杂的场景。

二、线段树常见的函数有哪些？

线段树常见的函数有：build（建树）、pushup（上传）、pushdown（下传）、update（修改区间）、query（查询区间）。

1. build（建树）

功能：将原数组或初始数据映射到线段树的各个节点上，为后续的查询和修改做准备。

典型模板：

void build(int p, int l, int r) {
    tr[p].l = l;
    tr[p].r = r;
    // 初始化当前节点的信息
    if (l == r) {
        tr[p].sum = a[l];   // 或者把 a[l] 拆成多位赋给 sum[k]
        return;
    }
    int mid = (l + r) >> 1;
    build(p<<1, l, mid);
    build(p<<1|1, mid+1, r);
    pushup(p);
}

最坏时间复杂度：O(n)
- 虽然线段树数组大小配置为 4n，但 build 递归只会访问每个节点一次，节点总数约为 2·n−1，故整体时间是线性 O(n)。

2. pushup（合并／上传）

功能：将左右子节点的统计信息合并到父节点上，保证父节点始终保存的是最新版统计结果。

典型模板（以“区间和”为例）：

void pushup(int p) {
    tr[p].sum = tr[p<<1].sum + tr[p<<1|1].sum;
    // 如果还维护其他信息（如区间最值、每个位上 1 的计数等），都在这里进行并行合并
}

最坏时间复杂度：O(1)
- 一次 pushup 仅仅是把左右孩子保存的几个标量（或长度固定的数组）相加/合并，耗时与区间长度无关，常数级。

3. pushdown（下传懒标记）

功能：将当前节点（父节点）上保存的“懒标记”下发给它的左右孩子，保证在孩子节点被访问或修改之前，它们也先执行该更新；最后清除或复位当前节点的标记。

典型模板（以“区间加常数”或“按位翻转”场景为例）：

void pushdown(int p) {
    // 假设 tr[p].lazy 表示“当前节点需要把某操作下传给左右孩子”
    if (tr[p].lazy != 0) {
        apply(p<<1, tr[p].lazy);
        apply(p<<1|1, tr[p].lazy);
        tr[p].lazy = 0;
    }
}

void apply(int p, int v) {
    int len = tr[p].r - tr[p].l + 1;
    tr[p].sum += 1LL * v * len;  // 更新区间和
    tr[p].lazy += v;             // 把“要加 v”记在懒标记里
}

或者以“按位异或”举例，假设对第 k 位打标记：

void apply_flip(int p, int k) {
    int len = tr[p].r - tr[p].l + 1;
    int old_cnt = tr[p].sum_bit[k];
    int new_cnt = len - old_cnt;
    tr[p].sum_bit[k] = new_cnt;
    tr[p].tot += (long long)(new_cnt - old_cnt) << k;
    tr[p].add_bit[k] ^= 1;
}

void pushdown(int p) {
    for (int k = 0; k <= 20; k++) {
        if (tr[p].add_bit[k]) {
            apply_flip(p<<1, k);
            apply_flip(p<<1|1, k);
            tr[p].add_bit[k] = 0;
        }
    }
}

最坏时间复杂度：O(1)
- 虽然以“按位异或”为例时，pushdown 里会遍历 21 个二进制位，但常数 21 可视为 O(1)。任何情形下，pushdown 只对父节点一次性把懒标记传给左右孩子，并完成常数项的更新。

4. update（区间修改）

功能：在数组的某个子区间 [L,R] 上执行“批量修改”操作，比如：
- 区间加常数、区间赋值
- 区间按位异或（XOR）、区间取模
- ……
  并通过懒标记保证最坏情况下仍然是 O(log n) 级别的复杂度。

典型模板（以“区间加常数 addv”为例）：

void update(int p, int L, int R, int addv) {
    int l = tr[p].l, r = tr[p].r;
    if (L <= l && r <= R) {
        // 当前节点区间 [l,r] 完全被覆盖
        apply(p, addv);   // 直接打懒标记并更新 sum
        return;
    }
    pushdown(p);          // 先下传懒标记，保证左右子节点信息最新
    int mid = (l + r) >> 1;
    if (L <= mid) update(p<<1, L, R, addv);
    if (mid < R)  update(p<<1|1, L, R, addv);
    pushup(p);            // 左右更新完后合并到父节点
}

最坏时间复杂度：O(log n)
- 每次 update 最多沿树的一条根到叶子的路径向下递归，路径长度 ≈ O(log n)。
- 在每个节点访问时，最坏会调用一次 pushdown（O(1)）和一次 pushup（O(1)），并按需递归左右孩子。
- 因此总时间为 O(log n)。

补充说明

如果是“单点修改”（L==R），也等价于 update(1, idx, idx, newVal)，依然是 O(log n)。
如果要对每个位分别调用一次 update(p, L, R, 1<<k)（如老版本按 21 次循环），则复杂度是 21×O(log n)，常数 21 可视为 O(1)，整体仍算 O(log n)。

5. query（区间查询）

功能：获取数组某个子区间 [L,R] 上的统计结果，比如：
- 区间和
- 区间最小值 / 最大值
- 区间逆序对数
- 区间每个位上“1 的个数”
- ……
  并保证最坏情况下的时间复杂度是 O(log n)。

典型模板（以“区间和查询”为例）：

long long query(int p, int L, int R) {
    int l = tr[p].l, r = tr[p].r;
    if (L <= l && r <= R) {
        // 当前节点区间完全包含在查询范围内
        return tr[p].sum;
    }
    pushdown(p);  // 部分重叠时先下传懒标记
    int mid = (l + r) >> 1;
    long long ans = 0;
    if (L <= mid)   ans += query(p<<1, L, R);
    if (mid < R)    ans += query(p<<1|1, L, R);
    return ans;
}