★线段树 (Segment Tree): 原理、实现和应用

已于 2024-01-21 12:54:27 修改
阅读量903 收藏 14
点赞数 18
分类专栏： 高级数据结构 文章标签： 算法 数据结构 c++
于 2024-01-20 22:15:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46664080/article/details/135716055
版权

引言

线段树是一种用于处理区间查询的数据结构，特别适用于需要高效支持区间修改和区间查询的场景。它将一个数组表示的区间划分为一系列小区间，并将每个小区间的信息存储在树中。本文将介绍线段树的基本原理、实现方法和一些常见应用。

基本原理

线段树是一种二叉树，每个节点代表一个区间。树的根节点表示整个数组，每个叶子节点表示数组中的一个元素，而每个中间节点表示数组的一个子区间。通过这种方式，线段树将数组分割为许多小区间，每个小区间都对应着树中的一个节点。

操作

  1. 构建（Build）： 将数组构建成线段树的过程。从树的叶子节点开始，每个节点的值表示对应区间的信息，中间节点的值通常由其子节点计算得到。

  2. 查询（Query）： 查询某个区间的信息。通过递归地访问线段树的节点，可以高效地获取整个区间的信息。

  3. 更新（Update）： 更新某个元素或区间的信息。通过递归地更新线段树的节点，可以保持树的信息与数组的一致性。

应用

线段树主要用于解决区间查询和区间更新问题。它是一种二叉树数据结构，用于存储对一个线性结构（如数组或列表）中某个范围的数据进行快速查询和更新。

主要问题包括：

  1. 区间查询（Range Query）： 求解给定区间内元素的某种属性，例如区间和、区间最小值、区间最大值等。

  2. 区间更新（Range Update）： 修改给定区间内元素的值，例如增加或减少某个值，或者将区间内的元素全部设为某个值。

线段树通过将整个区间递归地划分为更小的子区间，每个节点存储了对应区间的信息，从而实现了高效的区间查询和更新操作。

1、实现单点修改，区间查询的线段树

c++代码

#include <iostream>
#include <vector>

struct SegmentTreeNode {
    int start;
    int end;
    int sum;    //区间和 
    SegmentTreeNode* left;
    SegmentTreeNode* right;

    SegmentTreeNode(int start, int end) : start(start), end(end), sum(0), left(nullptr), right(nullptr) {}
};

class SegmentTree {
private:
    SegmentTreeNode* root;

    // 递归构建线段树
    SegmentTreeNode* buildTree(const std::vector<int>& nums, int start, int end) {
        if (start > end) {
            return nullptr;
        }

        SegmentTreeNode* node = new SegmentTreeNode(start, end);

        if (start == end) {   //叶节点 
            node->sum = nums[start];
        } else {
            int mid = (start + end) / 2;
            node->left = buildTree(nums, start, mid);
            node->right = buildTree(nums, mid + 1, end);
            node->sum = node->left->sum + node->right->sum;   //左右子树的和
        }

        return node;
    }

    // 区间查询
    int queryRange(SegmentTreeNode* node, int left, int right) {
        if (!node || left > node->end || right < node->start) {
            return 0;             // 区间不重叠，返回默认值
        }

        if (left <= node->start && right >= node->end) {
            return node->sum;    // 完全包含，返回当前节点的值
        }
		//如果 区间没有被完全包含，查找该区间的左/右子区间 
        int leftSum = queryRange(node->left, left, right);
        int rightSum = queryRange(node->right, left, right);
        return leftSum + rightSum;
    }

    // 单点更新
    void updateNode(SegmentTreeNode* node, int index, int value) {
        if (!node || index < node->start || index > node->end) {
            return;     //index超出索引范围 
        }

        if (node->start == node->end && node->start == index) {
            node->sum = value;
            return;
        }

        updateNode(node->left, index, value);
        updateNode(node->right, index, value);
        node->sum = node->left->sum + node->right->sum;   //更新父节点 
    }

public:
    SegmentTree(const std::vector<int>& nums) {
        int n = nums.size();   
        root = buildTree(nums, 0, n - 1);
    }

    // 区间查询接口
    int query(int left, int right) {
        return queryRange(root, left, right);
    }

    // 单点更新接口
    void update(int index, int value) {
        updateNode(root, index, value);
    }
};

int main() {
    std::vector<int> nums = {1, 3, 5, 7, 9, 11};
    SegmentTree segTree(nums);

    // 区间查询
    std::cout << "Sum in range [1, 4]: " << segTree.query(1, 4) << std::endl;

    // 单点更新
    segTree.update(2, 6);
    std::cout << "Updated sum in range [1, 4]: " << segTree.query(1, 4) << std::endl;

    return 0;
}

2、线段树进阶

当你读到此处也许会觉得用线段树来求区间和，并不是那么好用，代码又长、效率也一般。相对于用前缀和来求解区间求和问题可以更快更简洁的求解该问题，实时也确实如此吗？当涉及到需要多次对区间的元素进行单点或者区间范围内修改时，你还会这样认为吗？下面然我们来看一看线段树如何解决区间修改、区间查询问题的吧！

在讲解区间修改之前我们先来思考一下如何进行区间修改，首先想到的就是对一个[l,r]区间逐一的进行单点修改，这确实能够满足区间修改的要求。但是你仔细想想逐一进行修改的时间复杂度，能否让我们满意。答案当然是否定的。

于此，便提出了lazytage标记。
区间修改的时候，我们按照如下原则：
1、如果当前区间被完全覆盖在目标区间里，讲这个区间的 node->sum = node->sum+k*(node->end - node->start+1)
2、如果没有完全覆盖，则先下传懒标记
3、如果这个区间的左儿子和目标区间有交集，那么搜索左儿子
4、如果这个区间的右儿子和目标区间有交集，那么搜索右儿子

然后查询的时候，将这个懒标记下传就好了，下面图解一下：

如图，区间 1 ∼ 4 分别是 1 、 2 、 3 、 4 我们要把 1 ∼ 3 区间+1 。因为 1 ∼ 2 区间被完全覆盖，所以将其 + 2 ，并将紫色的 lazytage+1，3 区间同理。

在完成上述步骤之后任需要执行以下操作：node->sum = node->left->sum + node->right->sum;

void updateRange(SegmentTreeNode* node, int left, int right, int delta) {
        if (!node || left > node->end || right < node->start) {
            return;
        }
		if (left <= node->start && right >= node->end) {
			node->sum += (node->end - node->start + 1) * delta;    //更新sum 
            node->lz += delta;    // lazy累积 
            return;
        }
        // lazy下移 
        pushdown(node);

        updateRange(node->left.get(), left, right, delta);
        updateRange(node->right.get(), left, right, delta);

        node->sum = node->left->sum + node->right->sum;
    }

需要注意的是，在区间更新和区间查询之前需要先处理lazy，如果lazy不为0，需要将lazy不断下移到子节点中，然后将当前节点的lazy置为0。

其中的pushdown函数，就是把自己的lazy归零，并给自己的儿子加上，并让自己儿子的sum加上k*(r-l+1).

void pushdown(SegmentTreeNode* node) {
    	//如果lazy == 0 则返回 
        if (!node->lz) {
            return;
        }

        node->left->lz += node->lz;
        node->right->lz += node->lz;

        node->left->sum += (node->left->end - node->left->start + 1) * node->lz;
		node->right->sum += (node->right->end - node->left->start + 1) * node->lz;
        node->lz = 0;       //将当前节点的lazy置为0 
    }

区间修改、区间查询代码

#include <iostream>
#include <vector>
#include <memory>
using namespace std;
struct SegmentTreeNode {
    int start;
    int end;
    int sum;
    int lz;
    std::unique_ptr<SegmentTreeNode> left;
    std::unique_ptr<SegmentTreeNode> right;

    SegmentTreeNode(int start, int end) : start(start), end(end), sum(0), lz(0), left(nullptr), right(nullptr) {}
};

class SegmentTree {
private:
    SegmentTreeNode* root;
    // 递归构建线段树 
    SegmentTreeNode* buildTree(const std::vector<int>& nums, int start, int end) {
        if (start > end) {
            return nullptr;
        }
		SegmentTreeNode* node = new SegmentTreeNode(start, end);

        if (start == end) {
            node->sum = nums[start];
        } else {
            int mid = (start + end) / 2;
            node->left.reset(buildTree(nums, start, mid));
            node->right.reset(buildTree(nums, mid + 1, end));
            node->sum = node->left->sum + node->right->sum;
        }

        return node;
    }
	// pushdown函数，处理lazy 
    void pushdown(SegmentTreeNode* node) {
    	//如果lazy == 0 则返回 
        if (!node->lz) {
            return;
        }

        node->left->lz += node->lz;
        node->right->lz += node->lz;

        node->left->sum += (node->left->end - node->left->start + 1) * node->lz;
		node->right->sum += (node->right->end - node->left->start + 1) * node->lz;
        node->lz = 0;       //将当前节点的lazy置为0 
    }
	// 区间查询
    int queryRange(SegmentTreeNode* node, int left, int right) {
        if (!node || left > node->end || right < node->start) {
            return 0;
        }
 		if (left <= node->start && right >= node->end) {
            return node->sum;
        }
        // lazy下移 
        pushdown(node);
        int leftSum = queryRange(node->left.get(), left, right);
        int rightSum = queryRange(node->right.get(), left, right);
        return leftSum + rightSum;
    }
	// 区间更新
    void updateRange(SegmentTreeNode* node, int left, int right, int delta) {
        if (!node || left > node->end || right < node->start) {
            return;
        }
		if (left <= node->start && right >= node->end) {
			node->sum += (node->end - node->start + 1) * delta;    //更新sum 
            node->lz += delta;    // lazy累积 
            return;
        }
        // lazy下移 
        pushdown(node);

        updateRange(node->left.get(), left, right, delta);
        updateRange(node->right.get(), left, right, delta);

        node->sum = node->left->sum + node->right->sum;
    }

public:
    SegmentTree(const std::vector<int>& nums) {
        int n = nums.size();
        root = buildTree(nums, 0, n - 1);
    }
	// 区间查询接口
    int query(int left, int right) {
        return queryRange(root, left, right);
    }
	// 区间更新接口
    void update(int left, int right, int delta) {
        updateRange(root, left, right, delta);
    }
};

int main() {
    std::vector<int> nums = {1, 3, 5, 7, 9, 11};
    SegmentTree segTree(nums);

    // 区间查询
    std::cout << "Sum in range [1, 4]: " << segTree.query(1, 4) << std::endl;

    // 区间增加
    segTree.update(1, 2, 2);
    // 更新后的区间查询
    std::cout << "Updated sum in range [1, 4]: " << segTree.query(1, 4) << std::endl;

    return 0;
}
平常心-辉
关注
  • 18
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树（Segment Tree）
01-08
版权声明：本文为CSDN博主「Alex_McAvoy」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/u011815404/article/details/87277945 目录【概述】【基础操作实现】1.建树1）思路2）实现2.单点查询1）思路2）实现3.单点修改1）思路2）实现4.区间查询1）思路2）实现5.区间修改1）思路2）实现【模版】1.单点更新+区间查询2.区间更新+区间查询 【概述】 线段树是一种二叉搜索树，其存储的是一个区间的信息，每个结点以结构体的形式去存储，每个结构体包含三个元素：
线段树详解、常见应用与拓展
月巴虫丰博客
05-13 779
线段树的定义、基本结构、常见应用以及部分拓展（离散化、多lazy标记、dfs序、空间优化、区间合并、扫描线、主席树、RMQ和zkw）
线段树及其应用
最新发布
以太以北
10-05 208
线段树及其应用
算法数据结构——线段树（Segment Tree）精讲及python实现
学习中
08-25 965
算法数据结构——线段树（Segment Tree）精讲及python实现
线段树应用
Ma_tx
08-11 3509
下面给出线段树的几个应用： （1）有一列数，初始值全部为0。每次可以进行以下三种操作中的一种： a. 给指定区间的每个数加上一个特定值； b.将指定区间的所有数置成一个统一的值； c.询问一个区间上的最小值、最大值、所有数的和。 给出一系列a.b.操作后，输出c的结果。 [问题分析] 这个是典型的线段树的应用。在每个节点上维护一下几个变量：delta（区间增加值），same（区间被置
线段树详解 （原理，实现与应用）
热门推荐
岩之痕
09-09 14万+
线段树详解 By 岩之痕 一：综述 线段树是一种可以快速进行区间修改和区间查询的数据结构。点修改，区间修改和区间查询的复杂度都是O(log2(n)) 并且，线段树可以维护很多种类的信息。说到线段树就不得不提一下树状数组，树状数组维护的信息必须满足区间减法，因为树状数组只是维护1到X的信息，通过相减来得到区间信息，代码简单而且速度快，占用空间又少于线段树，所以一般情况下可以用树状数组的地方就
segment tree
07-22
### 线段树（Segment Tree）详解及实现 #### 引言 线段树（Segment Tree），作为数据结构中的一个重要组成部分，主要用于处理区间查询问题。它是一种高度平衡的二叉树，拥有静态结构，其节点对应不同的区间，并且...
Segment tree Beats!.pdf
08-05
### Segment Tree Beats! —— 深入探索高级线段树应用 #### 一、引言 在计算机科学领域，特别是在算法设计与分析方面...对于算法爱好者和竞赛选手而言，深入理解线段树及其变体的工作原理和应用场景是非常有价值的。
Java实现 LeetCode 699 掉落的方块（线段树？）
12-21
为了高效地解决这个问题，我们可以使用数据结构线段树（Segment Tree）。线段树是一种能够对区间进行快速查询和修改的数据结构，特别适合处理区间上的最大值、最小值等问题。在本题中，我们可以维护一个线段树，存储...
leetcode二维数组-segment-tree:段树
07-07
构造线段树的算法 段树理论 查找范围总和 有三种重叠类型 查找范围和流 查找范围和算法 更新操作 时间复杂度 比较 回顾段树 段树是二叉树 树底层的节点对应数组元素 其他节点包含处理范围查询所需的信息 最小范围...
线段树的应用
weixin_34327223的博客
08-26 371
线段树在信息学竞赛中是一种十分优秀的数据结构，具有维护区间信息，查询等操作，更有区间合并的种种的巧妙地性质，除了递归常数外，其复杂度是稳定在log 的。 蒟蒻初来乍到YL信息组的时候lg就开始教我们线段树,zkw线段树,主席树，划分树等神树，当时语言都没完全掌握好，自然听起来一头雾水。所以本人负责的建议，线段树学习还是在掌握好搜索和递归之后再来学，不然只能理解个大概，许多细节会...
数据结构与算法（十）线段树(Segment Tree)入门
Chiclaim
06-10 1万+
本文主要包括以下内容： 线段树的概念 线段树的基本操作 实现一个线段树 LeetCode相关线段树的问题 线段树的概念 线段树(Segment Tree)也是一棵树，只不过元素的值代表一个区间。 常用区间的 统计 操作，比如一个区间的最大值(max)，最小值(min)，和(sum)等等 如一个长度为10的数组，它对应的 求和 线段树，如下图所示(图中的数字表示索引)： 根节...
高级数据结构中，线段树在现实项目中有用到吗？　都是用在哪些方便啊
xdlove_的博客
05-19 410
高级数据结构中，线段树在现实项目中有用到吗？　都是用在哪些方便啊
高级数据结构 - 线段树（1）
算法的设计与应用研究
02-15 814
线段树是一种高级数据结构，用于解决区间的动态求最值与求和问题。举个例子，线段树能够解决的问题是像这样的：给出一个序列A，序列A一开始有一个统一的初值S，现要求编写一个程序，能够维护这个序列已达成以下的操作：1、改变一段数，将从Begin到End的所有值全部修改成同一个数Bi；2、求一段数的和，从Begin到End。数据范围：序列的长度 这一道题如果用直接的模拟，代码不会很长，但是效率也是够低的。假
线段树(segment tree)
weixin_33979203的博客
04-22 316
线段树在一些acm题目中经常见到，这种数据结构主要应用在计算几何和地理信息系统中。下图就为一个线段树： (PS：可能你见过线段树的不同表示方式，但是都大同小异，根据自己的需要来建就行。) 1.线段树基本性质和操作 线段树是一棵二叉树，记为T(a, b)，参数a,b表示区间[a,b]，其中b-a称为区间的长度，记为L。 线段树T(a,b)也可递归定义为： 若L&gt;1 : [a...
线段树的实际应用（少见的）
dingrong5409的博客
08-22 496
1.维护数列离某一项最近的特殊点 （不定期更新） 转载于:https://www.cnblogs.com/zrqlj/p/11396860.html
线段树的应用举例
nowting的博客
08-13 195
这里面的应用举例比较好，有时间搞搞：https://wenku.baidu.com/view/437ad3bec77da26925c5b0ba.html
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值