线段树小结

最新推荐文章于 2023-05-02 16:38:24 发布
置顶 最新推荐文章于 2023-05-02 16:38:24 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： 学习小结 数据结构 - 线段树 文章标签： 线段树小结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lwt36/article/details/50255129
版权

线段树小结 A Summary for Segment Tree

0. Anouncement

本文部分图片以及部分内容来自互联网，内容过多就不一一注明出处了，冒犯之处还请海涵。
Some of the pictures and the content of the text come from the Internet.
Due to plenty of the content,there will be no quotation. If offended, please try to forgive me.

Ⅰ. 线段树

  • 什么是线段树？
    首先我们来看一个图， 线段树就是每个节点维护一个区间的树。
    可以常数倍空间复杂度的情况下高效的 维 护信息(维护一般指的是更新和查询) 。
    本文除特别题目外，区间以及根节点的下标均从 1 开始，线段树的维护信息均以数组的方法存储。
    线段树

  • 线段树的时空复杂度
    由上图我们可以发现: 线段树维护的区间在同一高度上是完全不相交的，并且恰好包含了所有的区间。
    图中红字所表示的是每个节点的所在的数组的下标
    我们可以发现每个节点的左儿子是父亲节点下标 * 2，右儿子是父亲节点下标 * 2 + 1
    并且我们也发现以这样的存储方式，仅仅开2倍的空间是不够的，4倍才是合适的
    至于为什么是4倍？详情可以看这里，点击查看
    由于线段树的二叉树形结构，更新和查询的时间复杂度操作都是O(logn)

Ⅱ. 线段树的代码模版

  • l,r,rt: 保存的区间信息，其中rt是这个区间信息所存的节点的下标
    L,R: 每次操作要更新的区间
    v: 更新的值
    HH风格的线段树，感谢HH大牛对于线段树学习的分享

  • 单点更新 区间查询(单点查询其实就是区间查询的特例)
    push_up 把儿子节点的信息更新到自己 

//以单点更新 区间查询的RMQ为例
const int N = 1e5 + 10;

#define root 1, n, 1
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

int maxv[N << 2];

void push_up(int rt) {
    maxv[rt] = max(maxv[rt << 1], maxv[rt << 1 | 1]);
}
void build(int l, int r, int rt) {
    if(l == r) {
        scanf("%d", &maxv[rt]);
        return;
    }
    int m = l + r >> 1;
    build(lson);
    build(rson);
    push_up(rt);
}
void update(int o, int v, int l, int r, int rt) {
    if(l == r) {
        maxv[rt] = v;
        return;
    }
    int m = l + r >> 1;
    if(o <= m) update(o, v, lson);
    else update(o, v, rson);
    push_up(rt);
}
int query(int L, int R, int l, int r, int rt) {
    if(L <= l && r <= R) return maxv[rt];
    int m = l + r >> 1;
    int ret = -INF;
    if(L <= m) ret = max(ret, query(L, R, lson));
    if(R > m) ret = max(ret, query(L, R, rson));
    return ret;
}
  • 区间更新 区间查询
    push_down 在更新或者查询到当前节点的左右儿子节点时，提前更新它的左右儿子节点，
    这就是懒惰操作lazy propagation
    这是一个坎，建议不要去看什么网上的讲解，代码就是最好的讲解，模拟几遍代码就懂了
//以区间更新 区间求和为例
const int N = 1e5 + 10;

#define root 1, n, 1
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

int sum[N << 2], add[N << 2];

void push_up(int rt) {
    sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
void push_down(int rt, int m) {
    if(add[rt]) {
        sum[rt << 1] += add[rt] * (m - (m >> 1));
        sum[rt << 1 | 1] += add[rt] * (m >> 1);
        add[rt << 1] += add[rt];
        add[rt << 1 | 1] += add[rt];
        add[rt] = 0;
    }
}
void update(int L, int R, int v, int l, int r, int rt) {
    if(L <= l && r <= R) {
        add[rt] += v;
        sum[rt] += v * (r - l + 1);
        return;
    }
    push_down(rt, r - l + 1);
    int m = l + r >> 1;
    if(L <= m) update(L, R, v, lson);
    if(R > m) update(L, R, v, rson);
    push_up(rt);
}
int query(int L, int R, int l, int r, int rt) {
    if(L <= l && r <= R) return sum[rt];
    push_down(rt, r - l + 1);
    int m = l + r >> 1, ret = 0;
    if(L <= m) ret += query(L, R, lson);
    if(R > m) ret += query(L, R, rson);
    return ret;
}

Ⅲ. 线段树的题目讲解

所有的题目不外乎都是这两种模型，但是题目也有一定的技巧，即使是区间更新也不一定要往下传递lazy标记，
我们将以具体的题目配合进行讲解

1. 单点更新 区间查询

//
//  Created by TaoSama on 2015-05-19
//  Copyright (c) 2015 TaoSama. All rights reserved.
//
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>

using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int N = 5e4 + 10;

#define root 1, n, 1
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

int n, sum[N << 2];

void push_up(int rt) {
    sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}

void build(int l, int r, int rt) {
    if(l == r) {
        scanf("%d", &sum[rt]);
        return;
    }
    int m = l + r >> 1;
    build(lson);
    build(rson);
    push_up(rt);
}

void update(int o, int v, int l, int r, int rt) {
    if(l == r) {
        sum[rt] += v;
        return;
    }
    int m = l + r >> 1;
    if(o <= m) update(o, v, lson);
    else update(o, v, rson);
    push_up(rt);
}

int query(int L, int R, int l, int r, int rt) {
    if(L <= l && r <= R) return sum[rt];
    int m = l + r >> 1;
    int ret = 0;
    if(L <= m) ret += query(L, R, lson);
    if(R > m) ret += query(L, R, rson);
    return ret;
}

int main() {
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
//  freopen("out.txt","w",stdout);
#endif
    ios_base::sync_with_stdio(0);

    int t; scanf("%d", &t);
    int kase = 0;
    while(t--) {
        printf("Case %d:\n", ++kase);
        scanf("%d", &n);
        build(root);
        char op[10]; int x, y;
        while(scanf("%s", op)) {
            if(op[0] == 'E') break;
            scanf("%d%d", &x, &y);
            if(op[0] == 'Q') printf("%d\n", query(x, y, root));
            else if(op[0] == 'A') update(x, y, root);
            else if(op[0] == 'S') update(x, -y, root);
        }
    }
    return 0;
}

//
//  Created by TaoSama on 2015-05-19
//  Copyright (c) 2015 TaoSama. All rights reserved.
//
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>

using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int N = 2e5 + 10;

#define root 1, n, 1
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
int n, q, maxv[N << 2];

void push_up(int rt) {
    maxv[rt] = max(maxv[rt << 1], maxv[rt << 1 | 1]);
}

void build(int l, int r, int rt) {
    if(l == r) {
        scanf("%d", &maxv[rt]);
        return;
    }
    int m = l + r >> 1;
    build(lson);
    build(rson);
    push_up(rt);
}

void update(int o, int v, int l, int r, int rt) {
    if(l == r) {
        maxv[rt] = v;
        return;
    }
    int m = l + r >> 1;
    if(o <= m) update(o, v, lson);
    else update(o, v, rson);
    push_up(rt);
}

int query(int L, int R, int l, int r, int rt) {
    if(L <= l && r <= R) return maxv[rt];
    int m = l + r >> 1;
    int ret = -INF;
    if(L <= m) ret = max(ret, query(L, R, lson));
    if(R > m) ret = max(ret, query(L, R, rson));
    return ret;
}

int main() {
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
//  freopen("out.txt","w",stdout);
#endif
    ios_base::sync_with_stdio(0);

    while(scanf("%d%d", &n, &q) == 2) {
        build(root);
        while(q--) {
            char op[2]; int x, y;
            scanf("%s%d%d", op, &x, &y);
            if(op[0] == 'Q') printf("%d\n", query(x, y, root));
            else update(x, y, root);
        }
    }
    return 0;
}

//
//  Created by TaoSama on 2015-05-21
//  Copyright (c) 2015 TaoSama. All rights reserved.
//
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>

using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int N = 5e4 + 10;

#define root 1, n, 1
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
int n, q, maxv[N << 2], minv[N << 2];

void push_up(int rt) {
    maxv[rt] = max(maxv[rt << 1], maxv[rt << 1 | 1]);
    minv[rt] = min(minv[rt << 1], minv[rt << 1 | 1]);
}

void build(int l, int r, int rt) {
    if(l == r) {
        int x; scanf("%d", &x);
        maxv[rt] = minv[rt] = x;
        return;
    }
    int m = l + r >> 1;
    build(lson);
    build(rson);
    push_up(rt);
}

int query(int op, int L, int R, int l, int r, int rt) {
    if(L <= l && r <= R) {
        return op ? maxv[rt] : minv[rt];
    }
    int Max = -INF, Min = INF;
    int m = l + r >> 1;
    if(op) {
        if(L <= m) Max = max(Max, query(op, L, R, lson));
        if(R > m) Max = max(Max, query(op, L, R, rson));
    } else {
        if(L <= m) Min = min(Min, query(op, L, R, lson));
        if(R > m) Min = min(Min, query(op, L, R, rson));
    }
    return op ? Max : Min;
}

int main() {
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
//  freopen("out.txt","w",stdout);
#endif
    ios_base::sync_with_stdio(0);

    while(scanf("%d%d", &n, &q) == 2) {
        build(root);
        while(q--) {
            int x, y; scanf("%d%d", &x, &y);
            int Max = query(1, x, y, root);
            int Min = query(0, x, y, root);
            printf("%d\n", Max - Min);
        }
    }
    return 0;
}

2. 区间更新 区间查询

//
//  Created by TaoSama on 2015-05-21
//  Copyright (c) 2015 TaoSama. All rights reserved.
//
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>

using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;

#define root 1, n, 1
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
int n, q, sum[N << 2], row[N << 2];

void push_up(int rt) {
    sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}

void push_down(int rt, int m) {
    if(row[rt]) {
        sum[rt << 1] = row[rt] * (m - (m >> 1));
        sum[rt << 1 | 1] = row[rt] * (m >> 1);
        row[rt << 1] = row[rt << 1 | 1] = row[rt];
        row[rt] = 0;
    }
}

void build(int l, int r, int rt) {
    row[rt] = 0;
    if(l == r) {
        sum[rt] = 1;
        return;
    }
    int m = l + r >> 1;
    build(lson);
    build(rson);
    push_up(rt);
}

void update(int L, int R, int v, int l, int r, int rt) {
    if(L <= l && r <= R) {
        sum[rt] = v * (r - l + 1);
        row[rt] = v;
        return;
    }
    push_down(rt, r - l + 1);
    int m = l + r >> 1;
    if(L <= m) update(L, R, v, lson);
    if(R > m) update(L, R, v, rson);
    push_up(rt);
}

int main() {
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
//  freopen("out.txt","w",stdout);
#endif
    ios_base::sync_with_stdio(0);

    int t; scanf("%d", &t);
    int kase = 0;
    while(t--) {
        scanf("%d%d", &n, &q);
        build(root);
        while(q--) {
            int x, y, z; scanf("%d%d%d", &x, &y, &z);
            update(x, y, z, root);
        }
        printf("Case %d: The total value of the hook is %d.\n",
               ++kase, sum[1]);
    }
    return 0;
}

//
//  Created by TaoSama on 2015-05-19
//  Copyright (c) 2015 TaoSama. All rights reserved.
//
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>

using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;

#define root 1, n, 1
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

typedef long long LL;
int n, q;
LL sum[N << 2], add[N << 2];

void push_up(int rt) {
    sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}

void push_down(int rt, int m) {
    if(add[rt]) {
        add[rt << 1] += add[rt];
        add[rt << 1 | 1] += add[rt];
        sum[rt << 1] += add[rt] * (m - (m >> 1));
        sum[rt << 1 | 1] += add[rt] * (m >> 1);
        add[rt] = 0;
    }
}

void build(int l, int r, int rt) {
    add[rt] = 0;
    if(l == r) {
        scanf("%lld", &sum[rt]);
        return;
    }
    int m = l + r >> 1;
    build(lson);
    build(rson);
    push_up(rt);
}

void update(int L, int R, int v, int l, int r, int rt) {
    if(L <= l && r <= R) {
        add[rt] += v;
        sum[rt] += (LL)v * (r - l + 1);
        return;
    }
    push_down(rt, r - l  + 1);
    int m = l + r >> 1;
    if(L <= m) update(L, R, v, lson);
    if(R > m)update(L, R, v, rson);
    push_up(rt);
}

LL query(int L, int R, int l, int r, int rt) {
    if(L <= l && r <= R) return sum[rt];
    push_down(rt, r - l + 1);
    int m = l + r >> 1;
    LL ret = 0;
    if(L <= m) ret += query(L, R, lson);
    if(R > m) ret += query(L, R, rson);
    return ret;
}

int main() {
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
//  freopen("out.txt","w",stdout);
#endif
    ios_base::sync_with_stdio(0);

    while(scanf("%d%d", &n, &q) == 2) {
        build(root);
        while(q--) {
            char op[2]; int x, y, z;
            scanf("%s%d%d", op, &x, &y);
            if(op[0] == 'Q') printf("%lld\n", query(x, y, root));
            else {
                scanf("%d", &z);
                update(x, y, z, root);
            }
        }
    }
    return 0;
}

题解戳这里

题解戳这里

题解戳这里

3. 线段树区间合并

题解戳这里

题解戳这里

题解戳这里

4. dfs序维护区间线段树

题解戳这里

5. 扫描线与线段树

  • HDU 1542 Atlantis
    矩形面积并 不用传递懒惰标记 模拟一下就懂了
    update:区间更新

  • POJ 1177 Picture
    矩形周长并 与上面那个题相似 两种做法
    第一种直接横着扫描一次再竖着扫描一次
    第二种在横着扫描的时候再同时维护 竖线的个数
    update:单点增减 query:区间求和

  • HDU 1255 覆盖的面积
    前面的与矩形面积并类似, 不同的是push_up的时候要考虑至少覆盖一次one和至少覆盖两次two的更新
    update:区间更新

扫描线与线段树经典三题，全部详细题解戳这里

6. 线段树求第K大(其实就是在线段树上二分)

题解戳这里

题解戳这里

7. 高维线段树与多颗线段树

题解戳这里

题解戳这里

8. 线段树维护信息举例

题解戳这里

题解戳这里
TaoSama
关注
专栏目录
线段树的入门与优化
mslddzm的博客
03-31 509
NOI 信息竞赛内容，数据结构，线段树专题
C++基础：线段树（基础）
Keven_11的博客
01-31 462
目录 声明 正文 区间问题和线段树 线段树的建立 线段树的单点更新 线段树的查询 单点查询 区间查询 声明 线段树理解起来不难，但是题灵活多变，难，建议学之后多刷题 正文 区间问题和线段树 有一类区间问题可以抽象成如下模型。 给定包含 n 个数的数组 a1​,a2​,⋯an​。有两种操作 查询区间[l,r]最小的数。 修改第ai​为x。 这里，为了解决这个问题，我们介绍一种灵活的数据结构——线段树。 我们用一棵二叉树来表示线段树，线段树...
线段树总结
Stubird_的专栏
08-06 633
线段树总结: 线段树的原理就是每一个区间都可以被分成若干个不相交连续区间(重要)   线段树维护的数据: 1.自身结构的数据(比如 左儿子 , 右儿子的编号) 2.懒惰标记 (整段区间都变成一个值,或者将要进行什么操作.根据每次操作的类型,把操作的区间分成若干个不连续的区间,然后把操作的标记赋值给相应的区间) 3.答案 (就是query的答案,比如区间的sum什么的)
【hdu3308 LCIS】【线段树】【pushup】【最长连续上升序列】
running_acmer的博客
10-16 499
【链接】 http://acm.hdu.edu.cn/showproblem.php?pid=3308 【题意】 给你n个数，m个操作。 操作有两种： 1.U x y 将数组第x位变为y   2. Q x y 问数组第x位到第y位连续最长子序列的长度 【思路】 满足区间可加。 线段树维护信息：区间最长连续上升序列，前缀最长上升序列，后缀最长上升序列。 pushup(p)修改的时...
【树】一步一步写线段树（三）——实战演练（二）PushUp的应用
IDDFS
02-24 613
查询最小值与修改一个值 题目：RMQ问题再临-线段树【HihoCoder-1077】 描述 上回说到：小Hi给小Ho出了这样一道问题：假设整个货架上从左到右摆放了NNN种商品，并且依次标号为1到NNN，每次小Hi都给出一段区间[L,R][L,R][L,R]，小Ho要做的是选出标号在这个区间内的所有商品重量最轻的一种，并且告诉小Hi这个商品的重量。但是在这个过程中，可能会因为其他人的各...
HDU 1540
utoppia is another word .
08-25 1076
Tunnel Warfare Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 3240    Accepted Submission(s): 1252 Problem Description During the
线段树Java实现-SegmentTree
最新发布
05-01
### 小结 本文详细介绍了如何使用Java实现线段树，并提供了具体的代码示例。线段树是一种强大的数据结构，它能够高效地解决区间查询和区间更新问题。通过理解上述代码，你可以轻松地在实际项目中应用线段树来优化...
解决动态统计问题的两把利刃---剖析线段树与矩形切割
12-05
##### 2.7 线段树小结 线段树是一种强大的数据结构，它可以高效地处理区间查询和更新问题。通过引入懒惰更新机制，可以进一步提高效率。 #### 三、矩形切割 矩形切割是一种解决二维空间中区域查询和更新问题的...
线段树的原理与模板
热门推荐
iwts
08-08 1万+
如果会树状数组的同学应该就很容易理解线段树了，在一定程度上，两者是有一点类似的。首先，了解一下我们为什么要使用线段树，以及线段树的主要作用。 区间求和问题-医院卖药 假设有一家医院，医院有卖药的地方，不同的药品有不同的数量。每次开药、进药都要在计算机里面记录数量变化，这样方便医院的管理。那么我们该如何实现这样的程序？当然，药品数量的储存用数组是比较合适的（真实的...
HDU 3308 LCIS 线段树 PushUp应用
Katapeltes
11-13 429
http://acm.hdu.edu.cn/showproblem.php?pid=3308#include<bits/stdc++.h> using namespace std; const int MAX=100005; int N,M,A[MAX];struct Node { int l,r,c; //l,r - 左右边界 c - 长度 int ln,rn;
【线段树】模板题pushup+pushdown操作
行码棋
09-20 1317
线段树pushup和pushdown操作的经典模板
最大数(线段树pushup操作)
名字不能相同
08-13 224
#include <iostream> #include <cstdio> using namespace std; const int N = 200007; int m, p; struct Node { int l, r; int v; }tr[N * 4]; void pushup(int u) { tr[u].v = max(tr[u<<1].v, tr[u<<1|1].v); } void build(int u, int l,
22/5/2
aidaqiudeaichao的博客
05-02 269
1，cf Game with Chips；2，acwing 243.一个简单的整数问题2（线段树）；3，亚特兰蒂斯（扫描线）；4，维护序列； 题意：给你n x m的棋盘，有k个芯片分布在棋盘上，操作是左右上下各平移一格，要求第i个芯片至少经过一次给定位置；芯片遇到墙后，若仍往墙的方向走，则会不动；多个芯片可以在同一格； 操作次数不超过2nm次； 输出操作序列和操作步数；没有序列输出-1； 思路：直接将所有的芯片先移动到（1，1）在带着整体一个个走，遍历一遍棋盘，必能完成要求； 而且不会超过2nm；
线段树
qq_47783181的博客
12-03 396
线段树 线段树是什么？ 线段树是一颗二叉搜索树，对于一个线段，用二叉树的形式表示。它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 线段树的作用 用来解决区间问题 最基本的用来单点修改，区间修改，单点查询，区间查询。 其中两个经典问题是维护某段长度的最大值最小值，某段区间和。 然后可以引申出求区间最大值和最小值之差。 线段树的操作 线段树有五个操作，pushup，pushdown，build，query，modify pushup 操作 这个操作的意思就是向上维护，如果修改了某一点或
ACM-ICPC 2018 徐州赛区网络预赛（线段树维护前缀和）注意！每次pushdown是否要相应的pushup
leekerian的博客
04-16 344
题意 a[l]×L+a[l+1]×(L−1)+⋯+a[r−1]×2+a[r](LLis the length of [ll,rr] that equals tor - l + 1r−l+1). 题解 将原式转化成：sum(1,l)+sum(1,l+1)+sum(1,l+2)....+sum(1,r)-(l-r+1)*sum(1,l-1) 用数组存储前缀和就可以 #inclu...
【算法】线段树
weixin_63896439的博客
05-02 332
第二次修改[5, 8]不能覆盖结点5，需要再向下搜到结点11:[5, 5]，从而破坏了tag[5]，此时原tag[5]记录的区间统一修改就不得不往它的子结点传递和执行了，传递后tag[5]失去了用途，需要清空。区间[L, R]是需要更新的区间。（1）左子树递归到结点5，即区间[4, 5]，完全包含在[4, 9]内，打标记tag[5] = 3，更新tree[5]为20，不再继续深入；（3）右子树递归到结点6，即区间[6, 8]，完全包含在[4, 9]内，打标记tag[6]=3，更新tree[6]为23。
一篇线段树 从入门到进阶 实现原理与代码模板
harry12138小白的博客
08-03 331
线段树是什么 线段树是啥，简单来说就是既方便我们求一个数组某区间的和，又方便我们修改数组的某个元素的一种数据结构。属于二叉搜索树。 对于一个普通数组来说，我们修改某一元素的时间复杂度是O(1)，但求某区间和的时间复杂度是O(n)。 若使用前缀和，我们求某区间和的复杂度是O(1)，但我们修改某一元素的复杂度是O(n)。 为了方便我们又修改又求和，我们就使用线段树来均衡这两个操作的复杂度，把他们都平均到O(logn)。 具体操作 我们通常用一个数组来模拟一棵满二叉树，该二叉树的根结点保存的是数组0-n所有元素的
线段树详解与应用
"线段树基础" 线段树是一种数据结构，主要用于处理区间或段上的数据查询和更新操作，常用于解决动态区间统计问题。它是由二叉树结构实现的，每个节点代表一个特定的区间，而这个区间在树的不同层级被不断细分。线段...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值