线段树算法详解：从原理到实现

线段树算法详解：从原理到实现

【免费下载链接】LeetCode-Py ⛽️「算法通关手册」：超详细的「算法与数据结构」基础讲解教程，从零基础开始学习算法知识，800+ 道「LeetCode 题目」详细解析，200 道「大厂面试热门题目」。 项目地址: https://gitcode.com/gh_mirrors/le/LeetCode-Py

线段树（Segment Tree）是一种非常重要的数据结构，广泛应用于解决各种区间查询和更新问题。本文将全面介绍线段树的原理、实现方式以及常见应用场景。

1. 线段树基础概念

1.1 什么是线段树

线段树是一种基于分治思想的二叉树结构，主要用于高效处理区间查询和更新操作。它的每个节点都代表一个特定的区间，叶子节点代表单个元素，而非叶子节点则代表其子节点区间的合并。

线段树的主要特点包括：

• 每个节点维护一个区间信息
• 采用完全二叉树结构存储
• 支持高效的区间查询和更新操作
• 时间复杂度通常为O(logN)

1.2 线段树的结构特性

线段树的结构具有以下特性：

1. 平衡二叉树结构，保证操作效率
2. 对于包含n个元素的区间，线段树的高度为⌈log₂n⌉
3. 每个内部节点的区间是其子节点区间的并集
4. 叶子节点对应单个元素区间

THE 0TH POSITION OF THE ORIGINAL IMAGE

2. 线段树的实现方式

2.1 存储结构选择

线段树可以采用两种存储方式：

1. 链式存储：使用节点对象和指针连接
2. 顺序存储：使用数组模拟二叉树结构

由于线段树近似完全二叉树，通常采用顺序存储更为高效。数组存储的关键点：

• 根节点索引为0
• 节点i的左子节点索引为2i+1
• 节点i的右子节点索引为2i+2
• 节点i的父节点索引为⌊(i-1)/2⌋

2.2 空间复杂度分析

线段树的空间需求：

• 理想情况下需要2n空间
• 最坏情况下需要4n空间
• 实际应用中通常分配4n大小的数组

3. 线段树的核心操作

3.1 构建线段树

构建线段树的过程采用递归分治策略：

class SegmentTree:
    def __init__(self, nums, function):
        self.size = len(nums)
        self.tree = [TreeNode() for _ in range(4 * self.size)]
        self.nums = nums
        self.function = function  # 聚合函数（如sum, max, min等）
        if self.size > 0:
            self.__build(0, 0, self.size - 1)
    
    def __build(self, index, left, right):
        self.tree[index].left = left
        self.tree[index].right = right
        if left == right:  # 叶子节点
            self.tree[index].val = self.nums[left]
            return
        
        mid = left + (right - left) // 2
        left_index = index * 2 + 1
        right_index = index * 2 + 2
        self.__build(left_index, left, mid)
        self.__build(right_index, mid + 1, right)
        self.__pushup(index)  # 向上更新节点值

3.2 单点更新操作

单点更新修改指定位置的元素值：

def update_point(self, i, val):
    self.nums[i] = val
    self.__update_point(i, val, 0, 0, self.size - 1)

def __update_point(self, i, val, index, left, right):
    if left == right:  # 找到目标叶子节点
        self.tree[index].val = val
        return
    
    mid = left + (right - left) // 2
    if i <= mid:
        self.__update_point(i, val, index*2+1, left, mid)
    else:
        self.__update_point(i, val, index*2+2, mid+1, right)
    self.__pushup(index)  # 更新父节点

3.3 区间查询操作

区间查询获取指定范围内的聚合结果：

def query_interval(self, q_left, q_right):
    return self.__query_interval(q_left, q_right, 0, 0, self.size - 1)

def __query_interval(self, q_left, q_right, index, left, right):
    if left >= q_left and right <= q_right:  # 完全包含
        return self.tree[index].val
    if right < q_left or left > q_right:    # 无交集
        return 0
    
    self.__pushdown(index)  # 处理延迟标记
    
    mid = left + (right - left) // 2
    res_left = res_right = 0
    if q_left <= mid:
        res_left = self.__query_interval(q_left, q_right, index*2+1, left, mid)
    if q_right > mid:
        res_right = self.__query_interval(q_left, q_right, index*2+2, mid+1, right)
    return self.function(res_left, res_right)

3.4 区间更新与延迟标记

区间更新是线段树的难点，引入延迟标记(Lazy Tag)优化：

def update_interval(self, q_left, q_right, val):
    self.__update_interval(q_left, q_right, val, 0, 0, self.size - 1)

def __update_interval(self, q_left, q_right, val, index, left, right):
    if left >= q_left and right <= q_right:  # 完全包含
        self.tree[index].val = (right-left+1)*val
        self.tree[index].lazy_tag = val
        return
    
    self.__pushdown(index)  # 处理现有延迟标记
    
    mid = left + (right - left) // 2
    if q_left <= mid:
        self.__update_interval(q_left, q_right, val, index*2+1, left, mid)
    if q_right > mid:
        self.__update_interval(q_left, q_right, val, index*2+2, mid+1, right)
    self.__pushup(index)

def __pushdown(self, index):
    if not self.tree[index].lazy_tag:
        return
    
    left_index = index * 2 + 1
    right_index = index * 2 + 2
    
    # 更新子节点值和延迟标记
    self.tree[left_index].val = (self.tree[left_index].right - self.tree[left_index].left + 1) * self.tree[index].lazy_tag
    self.tree[left_index].lazy_tag = self.tree[index].lazy_tag
    
    self.tree[right_index].val = (self.tree[right_index].right - self.tree[right_index].left + 1) * self.tree[index].lazy_tag
    self.tree[right_index].lazy_tag = self.tree[index].lazy_tag
    
    self.tree[index].lazy_tag = None  # 清除当前标记

4. 线段树的高级应用

4.1 动态开点线段树

对于超大区间问题，可以使用动态开点技术：

class DynamicSegmentTree:
    def __init__(self, function):
        self.root = TreeNode(0, int(1e9))
        self.function = function
    
    def update_point(self, i, val):
        self.__update_point(i, val, self.root)
    
    def __update_point(self, i, val, node):
        if node.left == node.right:
            node.val = val
            return
        
        if i <= node.mid:
            if not node.leftNode:
                node.leftNode = TreeNode(node.left, node.mid)
            self.__update_point(i, val, node.leftNode)
        else:
            if not node.rightNode:
                node.rightNode = TreeNode(node.mid+1, node.right)
            self.__update_point(i, val, node.rightNode)
        self.__pushup(node)

4.2 常见问题类型

1. RMQ问题：区间最大值/最小值查询
2. 区间和问题：支持区间求和及更新
3. 区间合并：统计满足条件的连续区间
4. 扫描线算法：解决平面图形相关问题

5. 总结

线段树是一种功能强大的数据结构，特别适合处理各种区间操作问题。掌握线段树需要理解：

• 分治思想的应用
• 延迟标记的优化原理
• 不同应用场景的适配

通过合理使用线段树，可以高效解决许多复杂的区间查询和更新问题，是算法竞赛和实际工程中的重要工具。

【免费下载链接】LeetCode-Py ⛽️「算法通关手册」：超详细的「算法与数据结构」基础讲解教程，从零基础开始学习算法知识，800+ 道「LeetCode 题目」详细解析，200 道「大厂面试热门题目」。 项目地址: https://gitcode.com/gh_mirrors/le/LeetCode-Py