线段树基础（详细）

已于 2024-05-28 20:43:30 修改
阅读量279 收藏 4
点赞数 10
分类专栏： 提高组 数据结构 文章标签： 算法 c++ 数据结构 学习
于 2024-05-26 22:12:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q17312319193/article/details/139221983
版权

简介

线段树是算法竞赛中常用的用来维护 区间信息 的数据结构。
线段树可以在 O(log N) 的时间复杂度内实现单点修改、区间修改、区间查询（区间求和，求区间最大值，求区间最小值）等操作。，本文就来分别讲一下这些基本操作

建树

读入后建树，则有以下操作：

  1. 从根节点往下走，每个结点的区间分为两段继续往下走

  2. 每个节点找他的两个儿子，继续向下分别到他的两个儿子节点上继续建树

  3. 走到叶子节点时先赋初值后回溯，往回累加

建树代码

inline void pushup(int x){
	sum[x]=sum[x<<1]+sum[x<<1+1];//向上回溯累加，一个节点加上他儿子节点的和 
}
void build(int l,int r,int x){//x为节点编号,l、r为区间开头和结尾 
	if(l==r){
		sum[x]=a[l];//赋初值 
		return; 
	} 
//	 #define lson l,mid,x<<1
//	 #define rson mid+1,r,(x<<1)+1
	int mid=(l+r)/2;//分成两端区间 
	build(lson);//lson,rson,分别为左儿子右儿子节点定义见上 
	build(rson);
	pushup(x); 
}
//build(1,n,1)

单点修改（单点查询涵盖在内）

若修改a[i],则有以下步骤：

  1. 从根节点开始寻找下标为i的节点（也为单点查询）

  2. 修改后向上传递（相当于回溯）

单点修改代码

void dxg(int pos,int va,int l,int r,int x){//将a[pos]改为va 
	if (l==r){//到了叶子节点，改变返回 
		sum[x]=va;
		return;
	}
	int mid=(l+r)>>1;//同上，分为两个区间 
	//左区间[l,mid]  右区间[mid+1,r] 
//	 #define lson l,mid,x<<1
//	 #define rson mid+1,r,(x<<1)+1
	if (pos<=mid){//要修改的点在左边 
		dxg(pos,va,lson);
	}
	else{
		dxg(pos,va,rson);//在右边 
	}
	pushup(x);//向上回溯，修改 
}

区间查询

若查询i~j的和,则有以下步骤：

  1. 从根节点开始寻找依次向左边的节点和右边的节点走，接下来要分情况：

    • 此节点的区间，被完全包含，则向上传递，把此段的和加回去

    • 若此节点的未被完全包含，则继续往下搜，搜左边或右边，直至被完全包含为止，向上传递加和

  2. 以此类推，传递回根节点后，即为此区间的和

区间查询代码

ll qs(int L,int R,int l,int r,int x){//求[L,R]区间和 
	if (L<=l&&r<=R){//被完全包含的情况，直接回溯加回去 
		return sum[x];
	}
	int mid=(l+r)>>1;//与建树同理，分为两个小区间 
	//左区间[l,mid]  右区间[mid+1,r] 
//	 #define lson l,mid,x<<1
//	 #define rson mid+1,r,(x<<1)+1
	ll res=0;
	if (L<=mid){//要求的区间在左节点上 
		res+=qs(L,R,lson);
	}
	if (R>mid){//要求的区间在右节点上 
		res+=qs(L,R,rson);
	} 
	return res;//回溯相加 
}

区间修改

若要统一将a[L,R]加上x，通过线段树维护，则有以下两种方法完成此操作

一、最简单的方法（此处无代码）：

  1. 从根节点往下寻找[L,R]所对应的区间

  2. 走到对应区间内每个节点进行修改

  3. 向上回溯，重新更新每个节点对应的数值，从而达到区间修改效果

tips:此方法类似于进行L-R+1次单点修改
二、优化（引入lazy标记，此方法思想与区间查询有稍微相似处）

lazy标记定义如下：
可临时存放此节点的子节点要修改的数，在要往下遍历修改时，再下放（即把子节点分别加上此前存放在父节点lazy标记里的数）
有了lazy标记后就可以进行区间修改操作的优化方法了，具体步骤如下

  1. 从根节点开始寻找依次向左边的节点和右边的节点走，接下来要分情况：

    • 此节点的区间，被完全包含，则在此下标处打上lazy标记，将此节点代表的区间的数加上（此区间数的个数*要加上的数x），向上回溯

    • 若此节点的未被完全包含，则继续往下搜，搜左边或右边，直至被完全包含为止，执行（一）操作

区间修改代码

inline void pushdown(ll x,ll ln,ll rn){//ln，rn分别为左、右儿子区间含的数的个数
	if (lazy[x]){//此处有lazy标记 
		lazy[x<<1]+=lazy[x];//他的左儿子继承lazy标记 
		lazy[(x<<1)+1]+=lazy[x];//他的右儿子继承lazy标记  
		sum[x<<1]+=lazy[x]*ln;//左儿子修改操作（+=此处lazy标记所存的数*左儿子区间含的数的个数） 
		sum[(x<<1)+1]+=lazy[x]*rn;//与左儿子同理 
		lazy[x]=0;//以下放完毕，清空 
	}
}
void qxg(ll L,ll R,ll va,ll l,ll r,ll x){//将[l~r]+=va 
	if (L<=l&&r<=R){//被完全包含的情况 
		lazy[x]+=va;//打lazy标记 
		sum[x]+=1ll*(r-l+1)*va;//修改操作，将此点对应区间加上区间内包含数的个数*加上的va 
		return;
	}
	ll mid=(l+r)>>1;//同上，分为两个区间 
	//左区间[l,mid]  右区间[mid+1,r] 
//	 #define lson l,mid,x<<1
//	 #define rson mid+1,r,(x<<1)+1
	pushdown(x,mid-l+1,r-mid);//要修改的区间未被完全包含，下放标记，开始向下寻找 
	if (L<=mid){//要修改的区间有在左侧的部分 
		qxg(L,R,va,lson);
	} 
	if (R>mid){//要修改的区间有在左侧的部分 
		qxg(L,R,va,rson);
	}
	pushup(x);//向上回溯，修改 
}

此外区间修改后的区间查询要有一点微调：在往下寻找对应区间前要先下放lazy标记

微调后区间查询代码如下：

ll qs(ll L,ll R,ll l,ll r,ll x){//求[L,R]区间和 
	if (L<=l&&r<=R){//被完全包含的情况，直接回溯加回去 
		return sum[x];
	}
	ll mid=(l+r)>>1;//与建树同理，分为两个小区间 
	//左区间[l,mid]  右区间[mid+1,r] 
	//	 #define lson l,mid,x<<1
	//	 #define rson mid+1,r,x<<1+1
	pushdown(x,mid-l+1,r-mid);
	ll res=0;
	if (L<=mid){//要求的区间在左节点上 
		res+=qs(L,R,lson);
	}
	if (R>mid){//要求的区间在右节点上 
		res+=qs(L,R,rson);
	} 
	pushup(x);
	return res;//回溯相加 
}

综合以上操作，即可得到以下模版

1.单点修改，区间查询

#include<bits/stdc++.h>
#define ll long long
#define lson l,mid,x<<1
#define rson mid+1,r,(x<<1)+1
using namespace std;
const int N=1e6+9;
ll sum[N<<2];
int a[N],n,q;
inline void pushup(int x){
	sum[x]=sum[x<<1]+sum[(x<<1)+1];//向上回溯累加，一个节点加上他儿子节点的和 
}
void build(int l,int r,int x){//x为节点编号,l、r为区间开头和结尾 
	if(l==r){
		sum[x]=a[l];//赋初值 
		return; 
	} 
//	 #define lson l,mid,x<<1
//	 #define rson mid+1,r,x<<1+1
	int mid=(l+r)/2;//分成两端区间 
	build(lson);//lson,rson,分别为左儿子右儿子节点定义见上 
	build(rson);
	pushup(x); 
}
ll qs(int L,int R,int l,int r,int x){//求[L,R]区间和 
	if (L<=l&&r<=R){//被完全包含的情况，直接回溯加回去 
		return sum[x];
	}
	int mid=(l+r)>>1;//与建树同理，分为两个小区间 
	//左区间[l,mid]  右区间[mid+1,r] 
	//	 #define lson l,mid,x<<1
	//	 #define rson mid+1,r,x<<1+1
	ll res=0;
	if (L<=mid){//要求的区间在左节点上 
		res+=qs(L,R,lson);
	}
	if (R>mid){//要求的区间在右节点上 
		res+=qs(L,R,rson);
	} 
	return res;//回溯相加 
} 
void dxg(int pos,int va,int l,int r,int x){//将a[pos]改为va 
	if (l==r){//到了叶子节点，改变返回 
		sum[x]+=va;
		return;
	}
	int mid=(l+r)>>1;//同上，分为两个区间 
	//左区间[l,mid]  右区间[mid+1,r] 
	if (pos<=mid){//要修改的点在左边 
		dxg(pos,va,lson);
	}
	else{
		dxg(pos,va,rson);//在右边 
	}
	pushup(x);//向上回溯，修改 
}
int main(){
	scanf("%d %d",&n,&q);
	for (int i=1;i<=n;i++){
		scanf("%d",&a[i]);
	}
	build(1,n,1); 
	while(q--){
		int op;
		scanf("%d",&op);
		if (op==1){
			int pos,va;
			scanf("%d%d",&pos,&va);
			dxg(pos,va,1,n,1);
		}
		else{
			int l,r;
			scanf("%d%d",&l,&r);
			printf("%lld\n",qs(l,r,1,n,1));
		}
	}
	return 0;
}

2.区间利用差分、前缀和修改，单点查询

#include<bits/stdc++.h>
#define ll long long
#define lson l,mid,x<<1
#define rson mid+1,r,(x<<1)+1
using namespace std;
const int N=1e6+9;
ll sum[N<<2];
int a[N],b[N],n,q;
inline void pushup(int x){
	sum[x]=sum[x<<1]+sum[(x<<1)+1];//向上回溯累加，一个节点加上他儿子节点的和 
}
void build(int l,int r,int x){//x为节点编号,l、r为区间开头和结尾 
	if(l==r){
		sum[x]=a[l];//赋初值 
		return; 
	} 
//	 #define lson l,mid,x<<1
//	 #define rson mid+1,r,x<<1+1
	int mid=(l+r)/2;//分成两端区间 
	build(lson);//lson,rson,分别为左儿子右儿子节点定义见上 
	build(rson);
	pushup(x); 
}
ll qs(int L,int R,int l,int r,int x){//求[L,R]区间和 
	if (L<=l&&r<=R){//被完全包含的情况，直接回溯加回去 
		return sum[x];
	}
	int mid=(l+r)>>1;//与建树同理，分为两个小区间 
	//左区间[l,mid]  右区间[mid+1,r] 
	//	 #define lson l,mid,x<<1
	//	 #define rson mid+1,r,x<<1+1
	ll res=0;
	if (L<=mid){//要求的区间在左节点上 
		res+=qs(L,R,lson);
	}
	if (R>mid){//要求的区间在右节点上 
		res+=qs(L,R,rson);
	} 
	return res;//回溯相加 
} 
void dxg(int pos,int va,int l,int r,int x){//将a[pos]改为va 
	if (pos<0||pos>n) return;
	if (l==r){//到了叶子节点，改变返回 
		sum[x]+=va;
		return;
	}
	int mid=(l+r)>>1;//同上，分为两个区间 
	//左区间[l,mid]  右区间[mid+1,r] 
	if (pos<=mid){//要修改的点在左边 
		dxg(pos,va,lson);
	}
	else{
		dxg(pos,va,rson);//在右边 
	}
	pushup(x);//向上回溯，修改 
}
int main(){
	scanf("%d %d",&n,&q);
	for (int i=1;i<=n;i++){
		scanf("%d",&b[i]);
	}
	build(1,n,1); 
	while(q--){
		int op;
		scanf("%d",&op);
		if (op==1){
			int l,r,x;
			scanf("%d%d%d",&l,&r,&x);
			dxg(l,x,1,n,1);
			dxg(r+1,-x,1,n,1);
		}
		else{
			int pos;
			scanf("%d",&pos);
			printf("%lld\n",qs(1,pos,1,n,1)+b[pos]);
		}
	}
	return 0;
}

3.区间修改，区间查询

#include<bits/stdc++.h>
#define ll long long
#define lson l,mid,x<<1
#define rson mid+1,r,(x<<1)+1
using namespace std;
const ll N=1e6+9;
ll sum[N<<2],lazy[N<<2];     
ll a[N],n,q;
inline void pushup(ll x){
	sum[x]=sum[x<<1]+sum[(x<<1)+1];//向上回溯累加，一个节点加上他儿子节点的和 
}
inline void pushdown(ll x,ll ln,ll rn){//ln，rn分别为左、右儿子区间含的数的个数
	if (lazy[x]){//此处有lazy标记 
		lazy[x<<1]+=lazy[x];//他的左儿子继承lazy标记 
		lazy[(x<<1)+1]+=lazy[x];//他的右儿子继承lazy标记  
		sum[x<<1]+=lazy[x]*ln;//左儿子修改操作（+=此处lazy标记所存的数*左儿子区间含的数的个数） 
		sum[(x<<1)+1]+=lazy[x]*rn;//与左儿子同理 
		lazy[x]=0;//以下放完毕，清空 
	}
}
void build(ll l,ll r,ll x){//x为节点编号,l、r为区间开头和结尾 
	if(l==r){
		sum[x]=a[l];//赋初值 
		return; 
	} 
//	 #define lson l,mid,x<<1
//	 #define rson mid+1,r,x<<1+1
	ll mid=(l+r)/2;//分成两端区间 
	build(lson);//lson,rson,分别为左儿子右儿子节点定义见上 
	build(rson);
	pushup(x); 
}
ll qs(ll L,ll R,ll l,ll r,ll x){//求[L,R]区间和 
	if (L<=l&&r<=R){//被完全包含的情况，直接回溯加回去 
		return sum[x];
	}
	ll mid=(l+r)>>1;//与建树同理，分为两个小区间 
	//左区间[l,mid]  右区间[mid+1,r] 
	//	 #define lson l,mid,x<<1
	//	 #define rson mid+1,r,x<<1+1
	pushdown(x,mid-l+1,r-mid);
	ll res=0;
	if (L<=mid){//要求的区间在左节点上 
		res+=qs(L,R,lson);
	}
	if (R>mid){//要求的区间在右节点上 
		res+=qs(L,R,rson);
	} 
	pushup(x);
	return res;//回溯相加 
} 

void qxg(ll L,ll R,ll va,ll l,ll r,ll x){//将[l~r]+=va 
	if (L<=l&&r<=R){//被完全包含的情况 
		lazy[x]+=va;//打lazy标记 
		sum[x]+=1ll*(r-l+1)*va;//修改操作，将此点对应区间加上区间内包含数的个数*加上的va 
		return;
	}
	ll mid=(l+r)>>1;//同上，分为两个区间 
	//左区间[l,mid]  右区间[mid+1,r] 
//	 #define lson l,mid,x<<1
//	 #define rson mid+1,r,(x<<1)+1
	pushdown(x,mid-l+1,r-mid);//要修改的区间未被完全包含，下放标记，开始向下寻找 
	if (L<=mid){//要修改的区间有在左侧的部分 
		qxg(L,R,va,lson);
	} 
	if (R>mid){//要修改的区间有在左侧的部分 
		qxg(L,R,va,rson);
	}
	pushup(x);//向上回溯，修改 
}
int main(){
	scanf("%lld %lld",&n,&q);
	for (ll i=1;i<=n;i++){
		scanf("%lld",&a[i]);
	}
	build(1,n,1); 
	while(q--){
		ll op;
		scanf("%lld",&op);
		if (op==1){
			ll l,r,x;
			scanf("%lld%lld%lld",&l,&r,&x);
			qxg(l,r,x,1,n,1);
		}
		else{
			ll l,r;
			scanf("%lld%lld",&l,&r);
			printf("%lld\n",qs(l,r,1,n,1));
		}
	}
	return 0;
}

例题：洛谷 P3372,P3373

此文完

玉龙不是小初生
关注
  • 10
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树乘法模板（从基础线段树扩展）
04-22
线段树乘法是一种线段树的扩展应用，它允许对区间内的元素进行乘法运算。以下是针对标题为“完整的线段树模板，基础模板”的资源描述，但特别强调了线段... 构建方法：详细讲解线段树的构建过程，包括时间复杂度分析。
浅谈线段树——基础篇
jay_zai的博客
07-24 309
本文先讲解线段树的基础知识及其运用，更多进阶内容以后有时间再写（等我学会了再说 ）
【算法】线段树详解
热门推荐
_Alexander_的博客
08-20 5万+
线段树，是一种二叉搜索树。它功能强大，支持区间求和，区间最大值，区间修改，单点修改等操作。 它的时间复杂度是O(nlogn)的。 十分良心，欢迎阅读！
完整的线段树模板，基础模板
04-22
本资源提供了一个完整的线段树基础模板，旨在帮助开发者快速掌握并应用线段树解决实际问题。 特点： 基础性：适合初学者和有一定基础的开发者，从零开始理解线段树的构建和运作原理。 完整性：包含了线段树的构建...
NOIP算法大纲1
08-08
* Zkw 线段树：Zkw 线段树是一种变种的线段树，用于实现高效的区间查询操作。 * 权值线段树：权值线段树是一种变种的线段树，用于实现高效的区间查询操作。 七、基础数据结构 * 桶队列：桶队列是一种基础数据结构...
9、省选＋NOI-第九部分 博弈论_2020.08.29.pdf
11-25
* 线段树、树状数组 * 字典树 * 分块 动态规划 * 背包 DP * 树形 DP * 记忆化搜索 * 递推区间 DP * 序列 DP * DP 优化（不涉及斜率优化、四边形不等式等等） 搜索 * 暴搜（DFS、BFS） * 搜索的剪枝 * 启发式搜索...
15届蓝桥杯知识点大纲
01-17
蓝桥杯知识点大纲 ...22. 数据结构：包括树链剖分、二维/动态开点线段树、平衡树、可持久化数据结构、树套树、动态树等高级数据结构。 需要注意的是，本大纲仅供参考，实际比赛内容不限于大纲列举内容。
【代码随想录】【算法训练营】【第35天】[134]加油站 [135]分发糖果 [860]柠檬水找零 [406]根据身高重建队列
weixin_54954007的博客
06-11 299
思路及算法思维，指路。题目来自。day 35，连休两天~
指针和数组
2301_77634163的博客
06-10 431
有3个指针，中间是一个数组arr，有个指针指向中间,其他两个指向两边，一个指向前面，一个人指向后面。虽然简化好，但是我们C语言要求是不允许这样写的,虽然大部分编译器是可以允许我这样写的。下面那个用数组名也是可以用的，因为他也表示一个地址，加1就会找后面那个元素的地址。我们C语言编译器中说指针允许往后比较大小，但不允许往前比面的指针比较大小。地址向后移，指针相比较，指针减减就是减去一个整数。同一指针相减的绝对值得到的是之间元素的个数。数组和指针的地址是一样的，说明是可以的。地址加地址，指针加指针没有意义。
力扣136. 只出现一次的数字
最新发布
LNsupermali的博客
06-15 381
力扣136. 只出现一次的数字
二叉树顺序结构——堆的结构与实现
qq3304968099的博客
06-10 877
二叉树顺序结构——堆的结构与源代码实现
C语言中数组和指针的关系
2402_85246552的博客
06-12 580
因此，在函数内部，你无法知道数组的大小（除非作为另一个参数传递），但你可以通过指针访问数组的元素。对于数组，如果越界访问（访问数组索引超出其实际大小的元素），可能会导致未定义的行为，包括访问到无效的内存地址或覆盖其他变量的值。对于指针，如果指针指向了无效的内存地址（如未初始化的指针、已释放的内存或不存在的内存地址），解引用该指针也会导致未定义的行为。数组的大小在编译时是固定的，而指针可以指向任意大小的内存区域（只要该区域已被分配且指针已正确初始化）。），这会得到整个数组的地址或指向下一个元素的指针。
洛谷 P5043 【模板】树同构（[BJOI2015]树的同构）题解 树哈希 树的重心
一只摸鱼的bbc
06-09 1324
树哈希 树的重心 异或哈希 洛谷题解 C++代码 附注释
[力扣题解] 236. 二叉树的最近公共祖先
东皇太一在此的博客
06-10 420
用深度搜索的思想（好吧，前序、中序、后序都是深搜思想），保存寻找路径，看看找到2个节点的路径的重合部分，就可以找到最近公共祖先；
(第31天)【leetcode题解】404、左叶子之和
m0_73755059的博客
06-10 325
给定二叉树的根节点 root ，返回所有左叶子之和。
算法day25
2202_76101487的博客
06-11 362
正值少年的日常打卡
312. 戳气球
qq_35085273的博客
06-09 1017
240609-1 每日一题
算法：位运算题目练习
一名还在努力学习技术的程序员的博客
06-10 662
本篇博客是关于滑动窗口算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
牛客网刷题 | BC120 争夺前五名
m0_64000959的博客
06-09 442
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！期中考试开始了，大家都想取得好成绩，争夺前五名。从键盘输入 n 个学生成绩，输出每组排在前五高的成绩。数据范围： 5≤𝑛≤50 5≤n≤50 ，成绩采取百分制并不会出现负数两行，第一行输入一个整数，表示n个学生（>=5），第二行输入n个学生成绩（整数表示，范围0~100），用空格分隔。一行，输出成绩最
给我详细介绍一下线段树
02-06
线段树是一种数据结构，它用于维护一个序列的信息，并支持对序列中某个区间的信息进行快速查询和修改。 线段树的每个节点都存储着一个区间的信息，如区间的最小值、最大值、区间和等。线段树的每个节点都有两个子...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值