线段树C++实现

最新推荐文章于 2024-04-28 14:00:13 发布
原创 最新推荐文章于 2024-04-28 14:00:13 发布 · 917 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

一、本题线段树数组数据和结构

        data[]={1,2,-3,5,6,-2,7,1,12,30,-10}，11个元素。

 二、各个函数和结构

（一）线段树结构

        创建线段树的结构， l、r为左边界和右边界，maxV和minV为最大值和最小值，sum为和，tag为lazyTag。

typedef struct SegNode{
    int l,r,maxV,minV,sum,tag;
    struct SegNode *pL, *pR;
}SegNode, *SegTree;

#define OK 1
#define ERROR 0

（二）线段树创建

        创建一个线段树，要改变指针变量的值就要传指针变量SegTree的地址进去，由于双重指针代表的是指针的指针（地址的地址），故我们这里使用双重指针用*SegTree指向SegTree的地址。

        递归创建，出口为递归到左边界=有边界时。

void BuildSegTree(SegTree* root, int l, int r, int data[]){
    //当l == r时，左右边界为相同位置，递归结束
    if(l == r){
        (*root) = new SegNode;
        (*root)->sum = data[l]; //只有一个数，所以和就是这个数
        (*root)->maxV = data[l]; //同上
        (*root)->minV = data[l]; //同上
        (*root)->tag = 0; //新结点没有“欠债”
        (*root)->l = l;
        (*root)->r = r;
        (*root)->pL = NULL; //左右子树为空
        (*root)->pR = NULL;
        return;
    }
    //左右边界不相同时，创建该结点后，分成左右两个子树继续递归
    else{
        (*root) = new SegNode;
        (*root)->l = l;
        (*root)->r = r;
        (*root)->tag = 0;
        int mid = l + (r-l)/2; //求中间位置
        //递归调用该函数创建左右子树
        BuildSegTree(&((*root)->pL), l, mid, data);
        BuildSegTree(&((*root)->pR),mid+1, r, data);
        (*root)->sum = (*root)->pL->sum + (*root)->pR->sum; //通过两个子树的和求该树的和
        (*root)->maxV = max((*root)->pL->maxV, (*root)->pR->maxV); //通过两个子树的最大值比较求该树的最大值
        (*root)->minV = min((*root)->pL->minV,(*root)->pR->minV); //通过两个子树的最小值比较求该树的最小值
    }
}

（三）清算懒标记

        清算懒标记“债务”的函数，懒标记是可以大幅度提升效率的操作，用法是在每次更改一定范围数据的值时，先只更改当前结点，并且将要改变的值存在当前节点的懒标记中，等以后调用其他方法需要递归到下层节点时，再将懒标记传到子树中并且更改子树的值。

//清算懒标记“债务”的函数
void LateUpdate(SegTree root){
    //没债务返回就行
    if(root->tag == 0)
        return;
    //左子树不为空，把债务传递给左子树，并且更改左子树的值
    if(root->pL != NULL){
        root->pL->tag += root->tag;
        root->pL->sum += (root->pL->r - root->pL->l+1)*root->tag;
        root->pL->maxV += (root->tag);
        root->pL->minV += (root->tag);
    }
    //右子树同上
    if(root->pR != NULL){
        root->pR->tag = root->tag;
        root->pR->sum = (root->pL->r - root->pL->l+1)*root->tag;
        root->pR->maxV += (root->tag);
        root->pR->minV += (root->tag);
    }
    root->tag = 0; //债务结算完清空
}

（三）查询操作

        查询范围内的最大值、最小值、和。递归操作，出口为查询范围刚好与当前root范围相等。递归过程右三种情况：1.在mid左侧。2.在mid右侧。3.两边都有。

//查询操作
int query(SegTree root, int l, int r, int *tsum, int *tmax, int *tmin){
    //如果要查询的左边界范围大于右边界或者相反，返回
    if(r < root->l || l > root->r)
        return ERROR;
    //如果刚好查询的范围与当前root的范围相等
    if(l == root->l && r == root->r){
        *tsum = root->sum;
        *tmax = root->maxV;
        *tmin = root->minV;
        return OK;
    }
    LateUpdate(root); //运行到这说明要向子树递归，所以先将债务传递给子树
    int mid = root->l + (root->r - root->l)/2;
    //整个在mid左边的情况
    if(r<=mid){
        query(root->pL, l, r, tsum, tmax, tmin);
        return OK;
    }
    //整个在mid右边的情况
    else if(l >= mid+1){
        query(root->pR, l, r, tsum, tmax,tmin);
        return OK;
    }
    //被mid从中间分开的情况
    else{
        int lsum, rsum, lmax,rmax, lmin, rmin;
        query(root->pL, l, mid, &lsum, &lmax, &lmin);
        query(root->pR, mid+1, r, &rsum, &rmax, &rmin);
        *tsum = lsum+rsum;      //计算左右子树和
        *tmax = max(lmax,rmax); //从左右子树中找最大值
        *tmin = min(lmin,rmin); //从左右子树中找最小值
        return OK;
    }
}

（四）将范围内的每个数增加value

//在一个范围内将每个数增加value
void Add(int tl, int tr, SegTree root, int Value){
    //判断是否越界
    if(tl > root->r || tr < root->l){
        return;
    }
    //如果包含在内了，就把所有的值修改，并给tag写上债务
    if(tl <= root->l && tr >= root->r){
        root->sum += (root->r - root->l+1)*Value;
        root->maxV += Value;
        root->minV += Value;
        root->tag += Value;
        return;
    }
    //如果没包含，那就先将债务传递到子树，然后递归
    LateUpdate(root);
    int mid = root->l+(root->r-root->l)/2;
    //都在左侧的情况
    if(tr <= mid)
        Add(tl, tr, root->pL, Value);
    //都在右侧的情况
    else if(tl >= mid+1)
        Add(tl, tr, root->pR, Value);
    //两边都有
    else{
        Add(tl, mid, root->pL, Value);
        Add(mid+1, tr, root->pR, Value);
    }
    //计算各值
    root->sum = root->pL->sum + root->pR->sum;
    root->maxV = max(root->pL->maxV, root->pR->maxV);
    root->minV = min(root->pL->minV, root->pR->minV);
}

（五）销毁线段树

void DestroySegTree(SegTree *root){
    if(*root == NULL){
        return;
    }
    if((*root)->pL == NULL && (*root)->pR == NULL){
        delete *root;
        *root = NULL;
    }
    else{
        if((*root)->pL != NULL){
            DestroySegTree(&((*root)->pL));
        }
        if((*root)->pR != NULL){
            DestroySegTree(&((*root)->pR));
        }
        delete(*root);
    }
}

三、全部代码

#include <iostream>
#include <map>
#include <math.h>
#include <cctype>
using namespace std;

//创建线段树的结构， l、r为左边界和右边界，maxV和minV为最大值和最小值，sum为和，tag为lazyTag
typedef struct SegNode{
    int l,r,maxV,minV,sum,tag;
    struct SegNode *pL, *pR;
}SegNode, *SegTree;

#define OK 1
#define ERROR 0
//创建一个线段树,segTreesh
void BuildSegTree(SegTree* root, int l, int r, int data[]){
    //当l == r时，左右边界为相同位置，递归结束
    if(l == r){
        (*root) = new SegNode;
        (*root)->sum = data[l]; //只有一个数，所以和就是这个数
        (*root)->maxV = data[l]; //同上
        (*root)->minV = data[l]; //同上
        (*root)->tag = 0; //新结点没有“欠债”
        (*root)->l = l;
        (*root)->r = r;
        (*root)->pL = NULL; //左右子树为空
        (*root)->pR = NULL;
        return;
    }
    //左右边界不相同时，创建该结点后，分成左右两个子树继续递归
    else{
        (*root) = new SegNode;
        (*root)->l = l;
        (*root)->r = r;
        (*root)->tag = 0;
        int mid = l + (r-l)/2; //求中间位置
        //递归调用该函数创建左右子树
        BuildSegTree(&((*root)->pL), l, mid, data);
        BuildSegTree(&((*root)->pR),mid+1, r, data);
        (*root)->sum = (*root)->pL->sum + (*root)->pR->sum; //通过两个子树的和求该树的和
        (*root)->maxV = max((*root)->pL->maxV, (*root)->pR->maxV); //通过两个子树的最大值比较求该树的最大值
        (*root)->minV = min((*root)->pL->minV,(*root)->pR->minV); //通过两个子树的最小值比较求该树的最小值
    }
}

//先序遍历输出测试
void preOrder(SegTree root){
    if(root == NULL){
        return;
    }
    cout << "(" << root->l << "->" << root->r << ") sum: " << root->sum << " maxV: " << root->maxV << " minV: " << root->minV << ' ' <<endl;
    preOrder(root->pL);
    preOrder(root->pR);
}

//清算懒标记“债务”的函数
void LateUpdate(SegTree root){
    //没债务返回就行
    if(root->tag == 0)
        return;
    //左子树不为空，把债务传递给左子树，并且更改左子树的值
    if(root->pL != NULL){
        root->pL->tag += root->tag;
        root->pL->sum += (root->pL->r - root->pL->l+1)*root->tag;
        root->pL->maxV += (root->tag);
        root->pL->minV += (root->tag);
    }
    //右子树同上
    if(root->pR != NULL){
        root->pR->tag = root->tag;
        root->pR->sum = (root->pL->r - root->pL->l+1)*root->tag;
        root->pR->maxV += (root->tag);
        root->pR->minV += (root->tag);
    }
    root->tag = 0; //债务结算完清空
}

//查询操作
int query(SegTree root, int l, int r, int *tsum, int *tmax, int *tmin){
    //如果要查询的左边界范围大于右边界或者相反，返回
    if(r < root->l || l > root->r)
        return ERROR;
    //如果刚好查询的范围与当前root的范围相等
    if(l == root->l && r == root->r){
        *tsum = root->sum;
        *tmax = root->maxV;
        *tmin = root->minV;
        return OK;
    }
    LateUpdate(root); //运行到这说明要向子树递归，所以先将债务传递给子树
    int mid = root->l + (root->r - root->l)/2;
    //整个在mid左边的情况
    if(r<=mid){
        query(root->pL, l, r, tsum, tmax, tmin);
        return OK;
    }
    //整个在mid右边的情况
    else if(l >= mid+1){
        query(root->pR, l, r, tsum, tmax,tmin);
        return OK;
    }
    //被mid从中间分开的情况
    else{
        int lsum, rsum, lmax,rmax, lmin, rmin;
        query(root->pL, l, mid, &lsum, &lmax, &lmin);
        query(root->pR, mid+1, r, &rsum, &rmax, &rmin);
        *tsum = lsum+rsum;      //计算左右子树和
        *tmax = max(lmax,rmax); //从左右子树中找最大值
        *tmin = min(lmin,rmin); //从左右子树中找最小值
        return OK;
    }
}

//在一个范围内将每个数增加value
void Add(int tl, int tr, SegTree root, int Value){
    //判断是否越界
    if(tl > root->r || tr < root->l){
        return;
    }
    //如果包含在内了，就把所有的值修改，并给tag写上债务
    if(tl <= root->l && tr >= root->r){
        root->sum += (root->r - root->l+1)*Value;
        root->maxV += Value;
        root->minV += Value;
        root->tag += Value;
        return;
    }
    //如果没包含，那就先将债务传递到子树，然后递归
    LateUpdate(root);
    int mid = root->l+(root->r-root->l)/2;
    //都在左侧的情况
    if(tr <= mid)
        Add(tl, tr, root->pL, Value);
    //都在右侧的情况
    else if(tl >= mid+1)
        Add(tl, tr, root->pR, Value);
    //两边都有
    else{
        Add(tl, mid, root->pL, Value);
        Add(mid+1, tr, root->pR, Value);
    }
    //计算各值
    root->sum = root->pL->sum + root->pR->sum;
    root->maxV = max(root->pL->maxV, root->pR->maxV);
    root->minV = min(root->pL->minV, root->pR->minV);
}

//销毁线段树
void DestroySegTree(SegTree *root){
    if(*root == NULL){
        return;
    }
    if((*root)->pL == NULL && (*root)->pR == NULL){
        delete *root;
        *root = NULL;
    }
    else{
        if((*root)->pL != NULL){
            DestroySegTree(&((*root)->pL));
        }
        if((*root)->pR != NULL){
            DestroySegTree(&((*root)->pR));
        }
        delete(*root);
    }
}

int main(){
    SegTree root = NULL; //创建线段树
    int data[]={1,2,-3,5,6,-2,7,1,12,30,-10}; //输入一些数据
    int ssum, smax, smin;
    BuildSegTree(&root, 0, 10, data);  //构建线段树
    preOrder(root);  //先序遍历测试

    query(root, 0, 7, &ssum, &smax, &smin); //求0~7的和
    cout << endl << "0~7的和为：" << ssum << ' ' << smax << ' ' << smin << endl << endl;

    Add(0, 7, root, 3); //给0~7增加3
    query(root, 0, 7, &ssum, &smax, &smin); //求0~7的和
    preOrder(root);
    cout << endl << "加3后，0~7的和为：" << ssum << ' ' << smax << ' ' << smin << endl;

    return 0;
}

四、运行结果

 

线段树【C++实现】
qq_46496417的博客
03-15 584
线段树是一种基于分治的数据结构，用来进行快速的区间查询、单点修改操作；线段树中每个结点都用于存储一段区间相关的信息（如区间和、区间最值等）；
算法——线段树C/C++
2401_86771711的博客
09-03 2672
首先，我们需要定义线段树的节点结构体，通常包含区间的起始和结束位置，以及该区间的汇总信息。// 假设存储的是和。
线段树 c++实现
zh的csnd
08-16 501
#include<cstdio> #include<iostream> using namespace std; #define MAXSIZE 1000 void build_tree(int arr[], int tree[], int node, int start, int end){ if(start == end){ tree[node] = arr[start]; }else{ int mid = (start +
线段树（C++）
追梦丶
09-15 2222
线段树 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。   开原数组4倍大的空间 区间查询：询问某段区间的某些性质（极值，求和，etc） ...
C++ 线段树
struct_GS的博客
10-12 4214
线段树基本常识 线段树是一种二叉搜索树（即每个节点最多有两颗子树），与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 如下图，就是一颗 [1，10] 的线段树的分解过程： 由图可得出一个结论，线段树的最大深度不超过，且每一颗线段树需要 4*n 的辅助空间，如果没有开到 4*n ，那就完美 RE 了！！！ 线段树的的存储 线段树采用的是堆式储存法，即编号为 k 的节点的做儿子为 k...
线段树入门
Tizzi的博客
08-24 432
一、引入 有一类区间问题可以抽象成如下模型。 给定包含 n个数的数组 a1,a2,⋯an​。有两种操作 查询区间 [l,r] 最小的数。 修改第 ai为 x。 这里，为了解决这个问题，我们介绍一种灵活的数据结构——线段树。 我们用一棵二叉树来表示线段树，线段树中的每个结点都表示一个区间。每个非叶子结点都有左右两棵子树，分别对应区间的 “左半” 和 “右半”。为了方便起见，我们给根结点编号为 1...
线段树的一种实现
12-25
标题“线段树的一种实现”暗示了我们将探讨线段树的基本构建和操作方法。这个实现可能是用C++、Java或Python等编程语言完成的，它强调的是简单性和功能完备性，意味着它可能包含了基本的区间查询、区间更新以及可能...
免费线段树c++简短式模板
最新发布
08-11
下面是一个C++精简式线段树模板的简要实现步骤，以供参考： ```cpp // 线段树节点定义 struct Node { int sum; // 以该节点为根的区间的和 // 可根据需要添加其他信息，如区间最大值、最小值等 }; // 线段树的...
线段树.pdf
12-05
首先，线段树的实现基础是二叉树结构。每个节点代表一个区间，树的叶子节点对应实际数据中的单个元素。非叶子节点可以看作是其子节点区间的合并。在线段树中，每个节点都有两个子节点，通常称为左儿子（lson）和右...
C++线段树
闻缺陷则喜何志丹
04-18 1544
线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。 区间更新（查询）的时间复杂度是O(logn)，使用懒惰法只会影响以下四类节点，每类节点数量都不超过logn。一，左边界及其祖先。二，右边界及其祖先。三，第一类的兄弟节点。四，第二类的兄弟节点。
线段树初步（C++）
11-18
讲解线段树基本应用，适合初学者下载使用！
c++ 线段树
KonjakuLAF的博客
05-09 331
关于线段树 线段数是一种区间树 可以看出：叶子即为输入的数 假设一个节点为 x ，则其左儿子为 2x 右儿子为 2x+1 操作解析 约定 变量名 意义 input[] 输入的数 t[] 线段树 其中 t[] 是个结构体，包含左边界 l ，右边界 r 和区间和 sum sum 并不是必须有的，这些维护的值需要根据题目要求增多、减少 基本操作 卡常必备 左儿子与右儿子#def...
XOR的艺术 洛谷P2574 线段树
DaoCaoRen___的博客
01-10 2039
题目描述 AKN 觉得第一题太水了，不屑于写第一题，所以他又玩起了新的游戏。在游戏中，他发现，这个游戏的伤害计算有一个规律，规律如下 拥有一个伤害串，是一个长度为nn的只含字符0和字符1的字符串。规定这个字符串的首字符是第一个字符，即下标从11开始。 给定一个范围[l,~r][l,r]，伤害为伤害串的这个范围内中字符1的个数 会修改伤害串中的数值，修改的方法是把[l,~r][l,r]中所有原来的字符0变成1，将1变成0。 AKN 想知...
【C++】线段树
cout0
12-08 1475
简介 线段树是一种特殊的数据结构，他适用于进行区间RMQ问题。线段树的逻辑结构是一颗二叉树，叶子节点统计的是端点信息，而其余父节点统计的是所有子结点的信息，父结点也就构成了一个个统计区间，这些区间就像是线段，线段树因此得名。 首先，线段树是一颗平衡二叉树，因此搜索效率极高。通常，线段树是一颗普通的平衡二叉树，这种二叉树实现较为复杂，如下图所示： （图片来自网络，侵删） zkw大佬在《统计的力量》PPT中介绍了一种更易于实现的线段树，这种线段树一般也被称为zkw线段树。zkw线段树是一颗满二叉树，可以直接
【线段树 C++】
qq_44763629的博客
01-20 1162
线段树 C++ C++实现线段树 对于一给定的数组a，若要计算「长度为n的连续元素和：a[i+1] + …+a[i+n] 」时间复杂度为O(n)；若要修改某一位上的元素值，时间复杂度为O(1)。 若创建一个新数组b记录「前n位的累加和」，则查询「给定长度的元素和：a[i+1] + …+a[i+n] = b[i+n] - b[i]」的时间复杂度为O(1);修改某一位的元素值的时间复杂度变为O(n)。 当需要频繁进行两种操作时，时间开销较大。因此我们希望有一个平均时间复杂度较低的算法/数据结构来实现。 事实上
c++实现线段树结构
togolife的博客
01-07 894
c++ 线段树
线段树(C/C++)
2301_77710891的博客
04-28 436
用数组的方式表示树结构其实就是树的静态存储方式，它受限于数组的大小，需要提前确定好数组的大小，而节点链式存储是树的动态存储，其存储大小不受限，当然静态存储时以牺牲空间来换取时间的方法。如果我们有很多数据保存在一个数组中，而我们要对这个数组进行一些操作，那么使用传统的循环来控制的话，时间复杂度太大，特别是一些算法题很容易超时，这时候线段树可以帮我们解决，将复杂度降为nlog(n)，在此说明：线段树的应用通常是一些区间求和，区间修改，区间最大值、最小值等操作。进行区间修改时，采用lazy标记，传递修改信息。
线段树区间更新延迟标记
Grit_ICPC的博客
02-26 707
A Simple Problem with Integers Time Limit : 10000/5000ms (Java/Other) Memory Limit : 262144/131072K (Java/Other)Total Submission(s) : 50 Accepted Submission(s) : 23Problem Description You have N
c++ 数据结构之 线段树
hanzhen7541的博客
02-17 2057
线段树是一种数据结构，是一种二叉树。线段树将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。线段树对于区间求和等区间操作能够实现复杂度为O(logn)的操作，故得以广泛利用。修改一个值的操作也是O(logn)。 线段树是建立在线段基础上，每个结点都代表了一条线段[a,b]。长度为1的线段称为元线段。非元线段都有两个子结点，左结点代表的线段为[a,...
线段树c++
07-12
### 线段树的实现与应用 线段树是一种常用的数据结构，尤其在处理区间查询和更新问题时表现出色。其基本思想是将一个区间划分成若干个子区间，并通过递归的方式构建一棵二叉树。每个节点代表一个区间，叶子节点表示单个元素，而内部节点则存储其子区间的合并结果。 #### 线段树的基本操作 线段树的核心操作包括**构建、查询和更新**。这些操作通常基于递归实现，适用于静态数组或动态数组的场景。 ##### 构建线段树 线段树的构建过程是一个递归过程。以求和为例，假设原始数组为`arr`，线段树的每个节点保存对应区间的总和。构建函数如下： ```cpp void build(int node, int start, int end) { if (start == end) { tree[node] = arr[start]; } else { int mid = (start + end) / 2; build(2 * node, start, mid); build(2 * node + 1, mid + 1, end); tree[node] = tree[2 * node] + tree[2 * node + 1]; } } ``` ##### 查询操作 查询操作用于获取某个区间`[l, r]`的总和或最大值等信息。该函数需要判断当前节点的区间是否完全包含在查询区间内，部分重叠时需要递归查询左右子树。 ```cpp int query(int node, int start, int end, int l, int r) { if (r < start || end < l) { return 0; // 区间不相交，返回0 } if (l <= start && end <= r) { return tree[node]; // 完全包含，直接返回 } int mid = (start + end) / 2; int left_sum = query(2 * node, start, mid, l, r); int right_sum = query(2 * node + 1, mid + 1, end, l, r); return left_sum + right_sum; } ``` ##### 更新操作 更新操作用于修改数组中的某个元素，并同步更新线段树中的相关节点。 ```cpp void update(int node, int start, int end, int idx, int value) { if (start == end) { arr[idx] = value; tree[node] = value; } else { int mid = (start + end) / 2; if (idx <= mid) { update(2 * node, start, mid, idx, value); } else { update(2 * node + 1, mid + 1, end, idx, value); } tree[node] = tree[2 * node] + tree[2 * node + 1]; } } ``` #### 延迟标记（Lazy Propagation） 对于区间更新操作，延迟标记技术可以显著优化性能。当对一个区间进行更新时，延迟标记会将更新操作暂时保存在父节点中，直到后续查询需要访问子节点时才下推标记。 ```cpp void update_range(int node, int start, int end, int l, int r, int value) { if (lazy[node] != 0) { tree[node] += (end - start + 1) * lazy[node]; if (start != end) { lazy[2 * node] += lazy[node]; lazy[2 * node + 1] += lazy[node]; } lazy[node] = 0; } if (r < start || end < l) { return; } if (l <= start && end <= r) { lazy[node] += value; tree[node] += (end - start + 1) * value; return; } int mid = (start + end) / 2; update_range(2 * node, start, mid, l, r, value); update_range(2 * node + 1, mid + 1, end, l, r, value); tree[node] = tree[2 * node] + tree[2 * node + 1]; } ``` #### 动态线段树 在某些情况下，线段树的节点可能需要动态创建。例如，在稀疏更新或大规模数据场景中，动态线段树可以节省内存。 ```cpp struct Node { int left_bound, right_bound; Node* left_child = nullptr; Node* right_child = nullptr; int sum = 0; Node(int l, int r) : left_bound(l), right_bound(r) {} }; class SegmentTree { private: Node* root; void update(Node* node, int idx, int value) { if (node->left_bound == node->right_bound) { node->sum = value; } else { int mid = (node->left_bound + node->right_bound) / 2; if (idx <= mid) { if (!node->left_child) { node->left_child = new Node(node->left_bound, mid); } update(node->left_child, idx, value); } else { if (!node->right_child) { node->right_child = new Node(mid + 1, node->right_bound); } update(node->right_child, idx, value); } node->sum = 0; if (node->left_child) node->sum += node->left_child->sum; if (node->right_child) node->sum += node->right_child->sum; } } public: SegmentTree(int n) { root = new Node(1, n); } void update(int idx, int value) { update(root, idx, value); } int query(Node* node, int l, int r) { if (node->right_bound < l || node->left_bound > r) { return 0; } if (l <= node->left_bound && node->right_bound <= r) { return node->sum; } int res = 0; if (node->left_child) { res += query(node->left_child, l, r); } if (node->right_child) { res += query(node->right_child, l, r); } return res; } int query(int l, int r) { return query(root, l, r); } }; ``` #### 进阶线段树 进阶线段树包括**乘法线段树**和**根号线段树**。这些变种线段树通过调整合并函数来支持不同的运算需求。例如，乘法线段树的合并函数返回两个子区间的乘积，而根号线段树则返回子区间的平方根。 ```cpp // 乘法线段树的合并函数示例 tree[node] = tree[2 * node] * tree[2 * node + 1]; // 根号线段树的合并函数示例 tree[node] = sqrt(tree[2 * node] + tree[2 * node + 1]); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

百年bd

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值