线段树（Segment Tree）详解：从原理到Java实现

已于 2025-03-29 16:57:24 修改
阅读量441 收藏 9
点赞数 6
文章标签： java 算法
于 2025-03-29 16:57:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_72190053/article/details/146696741
版权

线段树（Segment Tree）详解：从原理到Java实现

一、什么是线段树？

线段树是一种二叉树数据结构，用于高效处理区间查询（如区间求和、区间最大值等）和区间更新操作。它能够在O(log n)时间复杂度内完成这些操作，比朴素的O(n)方法高效得多。

典型应用场景：

  • 游戏开发中的区域属性批量更新
  • 数据分析中的区间统计
  • 图形处理中的区域像素计算

二、线段树的核心原理

1. 基本结构

线段树将原始数组递归地划分为半区间的二叉树：

  • 每个叶子节点存储原始数组的一个元素
  • 每个非叶子节点存储其子节点信息的聚合（如子节点值的和）

对于长度为n的数组，线段树需要约4n的空间（完全二叉树最坏情况）。

2. 惰性传播（Lazy Propagation）

这是线段树的关键优化技术：

  • 当进行区间更新时，并不立即更新所有子节点
  • 而是将更新操作"暂存"在惰性标记（lazy tag）中
  • 只有当真正需要访问子节点时，才将更新"下推"

这种延迟更新的策略大幅减少了不必要的操作。

三、Java实现详解

以下是完整的线段树实现，支持区间加值和区间求和：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class Main{
    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static PrintWriter pw = new PrintWriter((System.out));

    public static void main(String[] args) throws IOException {
        int[] arr = {1,2,3,2,4,5,6,7,8,0,9,8,5};
        SegmentTree tree = new SegmentTree(arr);
        tree.show();
        while(true) {
            String[] l = br.readLine().split(" ");
            if("a".equals(l[0])) {//a 99 0 将索引为0的元素加上99
                tree.add(Integer.parseInt(l[1]), Integer.parseInt(l[2]));

            }else if("A".equals(l[0])) {//A 99 2 8 将索引为[2,8]的元素加上99
                tree.add(Integer.parseInt(l[1]), Integer.parseInt(l[2]), Integer.parseInt(l[3]));

            }else if("q".equals(l[0])) {//q 1 6 查询索引[1,6]的元素和
                int res = tree.query(Integer.parseInt(l[1]), Integer.parseInt(l[2]));
                tree.show();
                pw.println("答案：" + res);
                pw.flush();
            }else {
                break;
            }
        }

        pw.flush();
        pw.close();
        br.close();
    }

    static class SegmentTree{
        int[] tree;
        int[] lazy;
        int n;
        public SegmentTree(int[] arr) {
            this.n = arr.length;
            tree = new int[n<<2];
            lazy = new int[n<<2];
            build(arr, 0, n-1, 0);//构建线段树
        }
        public void build(int[] arr, int left, int right, int index) {
            if(left == right) {
                tree[index] = arr[left];
                return;
            }
            int mid = left + ((right - left) >> 1);
            int l_kid = (index << 1) + 1;
            int r_kid = l_kid + 1;
            build(arr, left, mid, l_kid);
            build(arr, mid+1, right, r_kid);
//            tree[index] = Math.max(tree[l_kid] , tree[r_kid]);
            tree[index] = tree[l_kid] + tree[r_kid];
        }
        public void add(int derta, int aim) {
            add(derta, aim, aim);
        }
        public void add(int derta, int l, int r) {
            add(derta, l, r, 0, n-1, 0);
        }
        public void add(int derta, int l, int r, int l_node, int r_node, int index) {
            /*递归终止条件：目标区间与结点区间匹配或异常情况*/
            if(l > r || l_node > r_node) return;
            if(l == l_node && r == r_node) {
                tree[index] += derta * (r_node - l_node + 1);	//更新求和的结果，要考虑当前区间下有多少个元素
                lazy[index] += derta;							//设置当前结点的懒标记
                return;											//终止递归一定要记得return!
            }

            /*下发与分割：下发懒标记到子结点，并更新子节点的数据*/
            int mid = l_node + ((r_node - l_node) >> 1);
            int l_kid = (index << 1) + 1;
            int r_kid = l_kid + 1;
            pushDown(l_node, r_node, index, l_kid, mid, r_kid);

            int[] AB;											//记录分割后新的目标区间[l,r] = [AB[0], AB[1]]
            /*继续递归：继续操作含目标区间的子结点*/
            if((AB = getAB(l, r, l_node, mid)) != null) add(derta, AB[0], AB[1], l_node, mid, l_kid);
            if((AB = getAB(l, r, mid+1, r_node)) != null) add(derta, AB[0], AB[1], mid+1, r_node, r_kid);

            /*回溯：子树完成修改后，更新当前结点的值*/
            tree[index] = tree[l_kid] + tree[r_kid];
        }
        private int[] getAB(int l, int r, int l_node, int r_node) {
            int[] AB = new int[2];// 3 3 0 6
            AB[0] = Math.max(l, l_node);
            AB[1] = Math.min(r, r_node);
            return AB[0] > AB[1] ? null : AB;
        }
        public int query(int l, int r) {
            return query(l, r, 0, n-1, 0);
        }
        public int query(int l, int r, int l_node, int r_node, int index) {
            /*递归终止条件：目标区间与结点区间匹配或异常情况*/
            if(l > r || l_node > r_node) return 0 /*Integer.MIN_VALUE*/;
            if(l == l_node && r == r_node) return tree[index];

            /*下发与分割：下发懒标记到子结点，并更新子节点的数据*/
            int mid = l_node + ((r_node - l_node) >> 1);
            int l_kid = (index << 1) + 1;
            int r_kid = l_kid + 1;
            pushDown(l_kid, r_kid, index, l_kid, mid, r_kid);

            int[] AB;
            /*继续递归：继续操作含目标区间的子结点*/
            int a = ((AB = getAB(l, r, l_node, mid)) != null) ? query(AB[0], AB[1], l_node, mid, l_kid) : 0/*Integer.MIN_VALUE*/;
            int b = ((AB = getAB(l, r, mid+1, r_node)) != null) ? query(AB[0], AB[1], mid+1, r_node, r_kid) : 0/*Integer.MIN_VALUE*/;

            /*回溯：子树完成修改后，更新当前结点的值*/
            tree[index] = tree[l_kid] + tree[r_kid];
            return a + b;
        }
        public void show() {
            show(0, n-1, 0);
            pw.println();
            pw.flush();
        }
        public void show(int l_node, int r_node, int index) {
            if(l_node == r_node) {
                pw.print(tree[index] + " ");
                return;
            }
            int mid = l_node + ((r_node - l_node) >> 1);
            int l_kid = (index << 1) + 1;
            int r_kid = l_kid + 1;
            pushDown(l_node, r_node, index, l_kid, mid, r_kid);
            show(l_node, mid, l_kid);
            show(mid+1, r_node, r_kid);
        }

        /**
         * 将懒标记下发到子节点，用于区间更新
         * 此方法主要目的是解决如何高效地将对某一区间的所有元素进行相同的操作（如加、减某个值）
         * 通过懒标记，可以延迟实际的更新操作，直到需要访问具体节点时才进行更新，从而提高效率
         *
         * @param l_node 当前节点覆盖的左边界
         * @param r_node 当前节点覆盖的右边界
         * @param index 当前节点在数组中的索引
         * @param l_kid 左子节点在数组中的索引
         * @param mid 当前节点覆盖区间的中点
         * @param r_kid 右子节点在数组中的索引
         */
        private void pushDown(int l_node, int r_node, int index, int l_kid, int mid, int r_kid) {
            if(lazy[index] != 0) {								//更新子节点的数据：值和懒标记都要更新
                tree[l_kid] += lazy[index] * (mid - l_node + 1);//更新求和值
                tree[r_kid] += lazy[index] * (r_node - mid);
                lazy[l_kid] += lazy[index];
                lazy[r_kid] += lazy[index];
                lazy[index] = 0;
            }
        }
    }
}

四、关键点解析

  1. 空间分配：线段树需要4n的空间确保足够存储
  2. 惰性标记下推：在访问子节点前必须处理惰性标记
  3. 区间分割：通过计算交集确定需要处理的子区间
  4. 回溯更新：子节点修改后要更新父节点的值

五、常见问题

  1. 为什么需要4n空间？

    • 考虑最坏情况下线段树是完全二叉树
    • 对于n个叶子节点，需要2n-1个节点
    • 但线段树不一定是完全二叉树，所以需要额外空间

  2. 如何处理其他区间操作？

    • 区间最大值：修改聚合方式和惰性传播逻辑
    • 区间乘法：额外处理乘法和加法的混合运算就可以了

  3. 为什么查询时也要下推标记？

    • 确保查询到的数据是最新的
    • 未下推的标记意味着该区间的子节点尚未更新

六、性能分析

操作时间复杂度说明
构建O(n)需要初始化所有节点
单点更新O(log n)相当于长度为1的区间更新
区间更新O(log n)惰性传播是关键优化
区间查询O(log n)与区间更新类似
狮587
关注
线段树(segment tree)详解
WilsonSong1024的博客
09-02 2494
segment tree(线段树)详解 什么是线段树 线段树是一棵平衡搜索树，但是不是完全二叉树，其实也是一棵二分搜索树，它储存的是一个区间的信息。 每个节点以结构体的方式存储，结构体包含以下几个信息： 区间左端点、右端点；（这两者必有） 区间内要维护的信息（实际情况而定，数目不等）。 一个具体的线段树如下所示，这里是一数组作为底层数据结构来阐述线段树，所以就简单的将线段树看为满二...
线段树(Java)
悦悦的狗子
02-05 783
线段树 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。 这不是一棵完全二叉树，也不是满二叉树，是一棵平衡二叉树，如果将这棵树的最后一层不存在的节点定...
线段树(segment tree)
weixin_33979203的博客
04-22 437
线段树在一些acm题目中经常见到，这种数据结构主要应用在计算几何和地理信息系统中。下图就为一个线段树： (PS：可能你见过线段树的不同表示方式，但是都大同小异，根据自己的需要来建就行。) 1.线段树基本性质和操作 线段树是一棵二叉树，记为T(a, b)，参数a,b表示区间[a,b]，其中b-a称为区间的长度，记为L。 线段树T(a,b)也可递归定义为： 若L&gt;1 : [a...
Java 线段树
最新发布
h860818的博客
03-04 379
另外，还有一个懒惰方法可以优化更新的方法，即将更新的值暂存，需要答案时再进行更新，这样可以节省资源。
线段树（java）
lpls1
10-15 198
1.相关时间复杂度： 因为总结点个数为2n，因此： 初始化：O(n) 因为不论哪种操作，对于每个深度都最多访问常数个结点，因此： 每次更新：O(logn) 每次求值：O(logn) 2.线段树结构： 线段树结点下标和元素范围下标均从0记。那么： 每个结点存着[l,r)范围内的值。 第0个结点维护[0,n)范围的值。 下标为k的元素的值对应线段树结点下标为n-1+k。 每个结点k的左右叶子结点下标分...
Java代码实现线段树结构示例详解
构建树的方法使用了递归，从数组的开始到结束构建出整个线段树的结构。更新方法允许我们改变一个节点的值，并更新其父节点以反映这一改变。查询方法sumRange允许我们查询任意区间内的总和，这也是利用递归进行的。 ...
线段树详解：操作与推广实例分析
线段树是一种高效的数据结构，特别适用于处理区间范围内的各种计算问题，如区间...这篇文章不仅深入讲解了线段树的基础原理，还提供了实际问题中的应用场景，是IT专业人士和竞赛参与者理解并运用线段树的重要参考文献。
线段树与树状数组：Java数据处理的高级技巧
在计算机科学中，线段树（Segment Tree）和树状数组（Binary Indexed Tree，简称BIT）是两种强大的数据结构，它们用于处理区间查询和动态更新问题。这两种结构特别适合用于那些需要频繁对大量数据进行高效查询和更新...
线段树详解：数据结构与算法应用
"线段树是一种数据结构，用于高效处理线性序列上的区间查询和修改。这份讲义详细介绍了线段树的...通过学习这份讲义，我们可以深入理解线段树的原理，掌握如何设计和实现线段树，从而在实际问题中高效地运用这一技术。
线段树
03-26
NULL 博文链接：https://xhyelinzhi-163-com.iteye.com/blog/1165432
线段树（Java）
weixin_45036949的博客
04-18 308
1.懒数组2.懒更新。
线段树 JAVA
weixin_49725604的博客
04-05 1004
class SegmentTree { int[] arr; int[] sign; int len; //建一棵空树 public SegmentTree( int len ) { this.len = len; len *= 4; this.sign = new int[len]; this.arr = new int[len]; } //由一个已知数组来建树 pub.
java 线段树
qq_43649937的博客
04-05 794
java
java,线段树
weixin_30951231的博客
05-01 391
线段树： 　　你可以理解成：线段组成的树，很多人问我，线段树到底有何用处，其实这个问题，你可以自己去刷题，然后总结出检验。 线段的具体理解，我看到一篇很好的博客，我就不展开了。博客地址：https://blog.youkuaiyun.com/iwts_24/article/details/81484561 基础题目： hdu1166敌兵布阵： 如果我们没有学过线段树，我们肯定是用模拟+暴...
java线段树
tomorrow_shoe的博客
05-24 1093
class SegmentTree { //原数组 int[] arr; //线段树数组 int[] tree; public SegmentTree(int[] arr) { this.arr = arr; tree = new int[arr.length * 4]; buildTree(0, 0, arr.length - 1); } private void buildTree(int cur
线段树 java_Java线段树
weixin_39746241的博客
02-12 202
线段树不是完全二叉树，是平衡二叉树堆也是平衡二叉树堆满二叉树：h层，一共有2^h-1个节点(大约是2^h)最后一层(h-1层)有2^(h-1)个节点最后一层的节点数大致等于前面所有层节点之和如果区间有n个元素，数组表示需要4n的空间不考虑添加元素，使用4n的静态空间即可接口：public interface Merger {E merge(E a, E b);}public class Segme...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值