【数据结构】线段树原理解析 (Segment Tree)

线段树原理解析：分治处理区间问题

最新推荐文章于 2025-10-23 21:22:45 发布

原创最新推荐文章于 2025-10-23 21:22:45 发布 · 1k 阅读

24 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #算法

ACM 专栏收录该内容

42 篇文章

订阅专栏

线段树是一种基于分治思想的二叉树数据结构，用于高效处理区间查询和区间更新问题。

一、核心思想：分治与预处理

1. 为什么要用线段树？

考虑一个数组 A[0...n-1]，我们需要频繁进行：

区间查询：求 A[l...r] 的和/最大值/最小值
单点更新：修改 A[i] 的值

如果用朴素方法：

区间查询：O(n) 时间
单点更新：O(1) 时间

线段树的目标是将区间查询也优化到 O(log n)。

2. 分治策略

线段树的核心是递归二分区间：

原数组：[1, 3, 5, 7, 9, 11]

分治过程：
[0...5] → [0...2] + [3...5]
[0...2] → [0...1] + [2...2]  
[0...1] → [0...0] + [1...1]
[3...5] → [3...3] + [4...5]
[4...5] → [4...4] + [5...5]

二、结构原理

1. 树形结构构建

        [0...5] (根节点)
       /         \
  [0...2]       [3...5]
   /    \       /     \
[0...1] [2...2] [3...3] [4...5]
 /  \               /   \
[0] [1]           [4]   [5]

叶子节点：对应原数组的单个元素
内部节点：对应某个区间的统计信息（如和、最大值等）
二叉树性质：每个节点最多有两个子节点

2. 存储方式：数组模拟

使用完全二叉树的数组表示法：

节点编号：      1
            /     \
           2       3
          / \     / \
         4   5   6   7
        / \       / \
       8   9     10 11

对应区间：
1: [0...5]
2: [0...2], 3: [3...5]
4: [0...1], 5: [2...2], 6: [3...3], 7: [4...5]
8: [0...0], 9: [1...1], 10: [4...4], 11: [5...5]

父子节点关系：

节点 i 的左孩子：2*i
节点 i 的右孩子：2*i + 1
节点 i 的父节点：i/2

三、构建原理

1. 自底向上的信息聚合

void build(int node, int start, int end) {
    if (start == end) {
        // 叶子节点：直接取原数组值
        tree[node] = arr[start];
    } else {
        int mid = (start + end) / 2;
        // 递归构建左右子树
        build(left_child, start, mid);
        build(right_child, mid+1, end);
        // 父节点 = 左子树信息 ⊕ 右子树信息
        tree[node] = tree[left_child] + tree[right_child];
    }
}

关键点：父节点的信息由其两个子节点合并得到。

2. 信息合并的数学原理

线段树能工作的前提是：区间信息满足"可合并性"

设 f(l,r) 是区间 [l,r] 的某种统计值，需要满足：

f(l,r) = f(l,mid) ⊕ f(mid+1,r)

其中 ⊕ 是满足结合律的二元运算。

常见可合并操作：

求和：sum(l,r) = sum(l,mid) + sum(mid+1,r)
最大值：max(l,r) = max(max(l,mid), max(mid+1,r))
最小值：类似最大值
按位或/与/异或：满足结合律

四、查询原理

1. 区间分解策略

查询 [l,r] 时，将目标区间分解为树中已存储的若干不相交区间。

三种情况：

完全包含：当前节点区间 [start,end] 完全在 [l,r] 内
- 直接返回该节点的值
完全无关：当前节点区间与 [l,r] 无交集
- 返回中性元素（如求和为0，求最大值为-∞）
部分重叠：需要递归查询左右子树

2. 递归查询过程

int query(int node, int start, int end, int l, int r) {
    // 情况1：完全无关
    if (r < start || end < l) return 0;
    
    // 情况2：完全包含  
    if (l <= start && end <= r) return tree[node];
    
    // 情况3：部分重叠
    int mid = (start + end) / 2;
    int left_result = query(left_child, start, mid, l, r);
    int right_result = query(right_child, mid+1, end, l, r);
    return left_result + right_result;
}

正确性证明：由于线段树的区间是递归二分的，任何查询区间都可以被分解为 O(log n) 个树中节点的区间。

五、更新原理

1. 单点更新

从根节点开始，沿着路径找到对应的叶子节点，然后自底向上更新所有受影响的祖先节点。

void update(int node, int start, int end, int idx, int val) {
    if (start == end) {
        // 找到目标位置
        arr[idx] = val;
        tree[node] = val;
    } else {
        int mid = (start + end) / 2;
        if (idx <= mid) {
            update(left_child, start, mid, idx, val);
        } else {
            update(right_child, mid+1, end, idx, val);
        }
        // 更新父节点：重新合并子节点信息
        tree[node] = tree[left_child] + tree[right_child];
    }
}

路径长度：从根到叶子的路径长度为 O(log n)，所以更新复杂度为 O(log n)。

2. 懒惰标记原理（区间更新）

普通更新对区间更新效率低（O(n log n)）。懒惰标记解决此问题。

核心思想：延迟更新，只在必要时才向下传递更新。

实现机制：

维护一个 lazy[] 数组，记录每个节点的待处理更新
更新时，如果当前区间完全包含在更新范围内：
- 直接更新当前节点
- 在 lazy 数组中记录子节点需要更新
- 不立即更新子节点
查询或更新经过该节点时，才将 lazy 标记下传

void push(int node, int start, int end) {
    if (lazy[node] != 0) {
        // 应用懒标记到当前节点
        tree[node] += (end - start + 1) * lazy[node];
        
        // 如果不是叶子，传递给子节点
        if (start != end) {
            lazy[left_child] += lazy[node];
            lazy[right_child] += lazy[node];
        }
        
        // 清除当前节点的懒标记
        lazy[node] = 0;
    }
}