线段树详解：建树、区间操作与懒惰标记-优快云博客

线段树是一种数据结构，能以O(log n)时间复杂度实现区间修改和查询。文章介绍了线段树的结构、建树过程，包括区间查询和单点修改，并详细讲解了懒惰标记的概念，用于优化区间修改操作。最后提供了单点更新和区间更新的模板题链接。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

线段树(Segment Tree)
线段树可在O(log n)的时间复杂度内实现单点修改、区间修改、区间查询（区间和，区间最大/最小值）等操作

线段树的结构和建树

线段树建树
区间查询（区间求和）
单点修改

线段树把一整个线段划分成一个树形结构，将每个长度不为1的区间划分成左右两个区间递归求解。

设用数组st[ ] 来保存线段树, st[i] 为线段树上编号为i的结点的值
（st[i]表示编号为i的结点所管理的区间的和）
在这里插入图片描述
st[1] = a[1] + a[2] + a[3] + a[4]
st[2] = a[1] + a[2]
st[4] = a[1]

st[i] 的左儿子结点是st[2*i], 右儿子结点是st[2* i + 1]
假设st[i]管理的区间是[l, r], 则它左儿子管理的区间是[l, (l + r) / 2],它右儿子管理的区间是[(l + r)/2 + 1, r]

继续观察，当区间大小为1的话，那么s[i]管理的区间[l, r]一定有 l==r, 这就是线段树的递归边界

线段树建树

void push_up(int root)
{
    st[root] = st[root << 1] + st[root << 1 | 1];  // 左儿子和右儿子管理的区间和
    // st[root] = max(st[root << 1] , st[root << 1 | 1]);  // 左儿子和右儿子中的最大值
    // st[root] = min(st[root << 1] , st[root << 1 | 1]);  // 最小值
}

//建树
void build(int root, int l, int r)  
{
    if(l == r)  // 边界
    {
        cin >> st[root];
        return;
    }
    int mid = l + (r - l) / 2;
    build(root << 1, l, mid);  // 建root结点的左树
    build(root << 1 | 1, mid + 1, r);  // 建右树
    push_up(root);  // 向上更新 区间和
}

区间查询
查询区间[l, r]的和，即查询a[l] + a[l + 1] + a[l + 2] + …… + a[r] 的值(或查询[l,r]的最大/最小值)

见上图，
如要查询区间[1, 4]的和，那么直接取st[1]的值。
如要查询区间[1, 3]的和，此时不能直接获取区间和的值，但是[1, 3]可以拆成区间[1, 2]和区间[3,3]，将这两个区间和相加即可。

int query(int root, int ql, int qr, int l, int r)  // root为当前结点，[ql, qr]为要查询的区间，[l,r]为当前结点所包含区间
{
    if(ql <= l && qr >= r)  // 当前区间为要查询的区间的子区间时，直接返回当前区间的和
    {
        return st[root];
    }
    int mid = l + (r - l) / 2;
    int ans = 0;
    if(ql <= mid) ans += query(root << 1, ql, qr, l, mid);  // 查询左儿子
    if(qr > mid) ans += query(root << 1 | 1, ql, qr, mid + 1, r); // 查询右儿子
    return ans;
}

单点修改

// 将a[pos]的值加上val
void update(int root, int pos, int val, int l, int r)  // root为当前结点， [r, l]为当前结点所包含的区间
{
    if(l == r)  // 找到pos的位置
    {
        st[root] += val;
        return ;
    }
    int mid = l + (r - l) / 2;
    if(pos <= mid) update(root << 1, pos, val, l, mid);  // pos在区间[l, mid]内
    else if(pos > mid) update(root << 1 | 1, pos, val, mid + 1, r); // pos在区间[mid + 1, r]内
    push_up(root);  // 修改完了记得要向上更新和
}

线段树的区间修改与懒惰标记

如果要修改区间[l, r],把区间[l, r]中所有的结点都遍历一遍，时间复杂度可能无法承受，于是引入一个叫“懒惰标记”的东西。

设一个数组tmp[]， tmp[i] 为结点 i 的懒惰标记， tmp[i]的作用是什么呢，就是为st[i] 暂时保存要加在st[i]所包含的区间的值，
比如说，要使区间[l, r]上的所有数都加上val，而st[i]管理的区间恰好是[l, r], 那么此时不会遍历[l, r]把所有的结点都加上val，而是把val暂存在tmp[i]中，等到st[]需要更新的时候，再向tmp[]数组取对应的值，向下更新，把区间给更新完。

那么加入了懒惰标记区间查询要怎么做呢（比如求区间和）?
很简单，st[i] 所包含的区间[l, r]中的所有数都加上了一个值val，那么此时st[i] 就要加上val * (r - l + 1)，也就是tmp[i] * (r - l + 1)
当需要向下更新的时候：
1.要把tmp[i]的左右儿子分别更新
2.要把st[i]的左右儿子分别更新

tmp[root << 1] += tmp[root];
tmp[root << 1 | 1] += tmp[root];
st[root << 1] += tmp[root] * (len - len / 2); // len为区间[l, r]的长度
st[root << 1 | 1] += tmp[root] * (len / 2);

向下更新

void push_down(int root, int len)
{
    if(tmp[root])
    {
        tmp[root << 1] += tmp[root];
        tmp[root << 1 | 1] += tmp[root];
        st[root << 1] += tmp[root] * (len - len / 2);
        st[root << 1 | 1] += tmp[root] * (len / 2);
        tmp[root] = 0;
    }
}

区间更新

void add(int root, int l, int r, int add_l, int add_r, int val)
{
    if(add_l <= l && add_r >= r)
    {
        tmp[root] += val;
        st[root] += val*(r - l + 1);
        return ;
    }
    int mid = l + (r - l) / 2;
    push_down(root, r - l + 1);

    if(add_l <= mid) add(root << 1, l, mid, add_l, add_r, val);
    if(add_r > mid) add(root << 1 | 1, mid + 1, r, add_l, add_r, val);
    push_up(root);
}

区间查询

ll query(int root, int l, int r, int ql, int qr)
{
    if(ql <= l && qr >= r)
    {
        return st[root];
    }

    int mid = l + (r - l) / 2;
    push_down(root, r - l + 1);
    ll ans = 0;
    if(ql <= mid) ans += query(root << 1, l, mid, ql, qr);
    if(qr > mid) ans += query(root << 1 | 1, mid + 1, r, ql, qr);
    return ans;
}