线段树是一种二叉搜索树 ，与区间树 相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点 ---- 百度百科
说真的，线段树真的是个超级超级棒的数据结构(๑•̀ㅂ•́)و✧真的相当好用，理解难度低应用广泛还代码好写，初期可能代码上有点难度，但是熟练后就会发现她的美！
进入正题，本期重点：
1、线段树建树
2、单点查询
3、单点修改
4、区间查询
一、线段树建树
先来说说什么是线段树，线段树就是一个二叉树，它的每一个子节点的范围都是半个父节点所占的范围，而且左右儿子的范围之和就是父节点所占的范围
举个例子吧
1，2，3，4，5，6，7，8，9，10是给定的一串数字，以它为根节点建线段树
首先以给定数字作为根节点，如果把这是个数存在数组a里，在这里就是a[n]=n(我存数组喜欢从1开始)，那么根节点的范围就是1<=n<=10
然后我们把这十个数分成两份----1，2，3，4，5和6，7，8，9，10，分别作为根节点的左儿子和右儿子，即根节点包含1~10，那么它的左儿子就是1~5，右儿子是6~10，即可得到如下图
以此类推我们继续往下分
最后就可以完成整个二叉树的建树了
用左边界和右边界来表示范围，如图
这样看就可以更直观的发现一个节点的区间为m,n;那么他的左儿子节点区间就是[m，(m+n)/2];右儿子节点区间就是[（m+n)/2+1,n];
来个例子看看吧？
我输入一行数，以他们的和建线段树
这是一个线段树建树的模板
来看看
先来看看节点怎么存
1 const int mm=100005;
2 struct tree{ 3 int l,r; //左边界和右边界（left，right） 4 int sum; //存的是l，r这个区间的和 5 }a[mm*4];
每个节点三个元素，左边界(l)，右边界(r)，和在这个区域内的和(sum)，节点a[n]的左右儿子就为a[n*2]和a[n*2+1]
接下来来看建树
我们先将一堆数字录入到in[mm]中
我们建树也是要一个节点一个节点建的，从根节点开始，
1 void build(int l,int r,int num) //l是左区间，r是右区间，num是节点编号
如果有不熟悉递归框架的朋友可以看这里：0基础算法基础学算法 第六弹 递归 - 球君 - 博客园 (cnblogs.com)
因为num的左右节点就是l和r了，所以。。。
void build(int l,int r,int num)
{
a[num].l=l; a[num].r=r; }
直接把l和r装上
当l和r相等之时，就不能在往下分了，而满足这个条件的num的sum就是in[l];
于是有了如下代码
void build(int l,int r,int num)
{
a[num].l=l; a[num].r=r; if(l==r) { a[num].sum=in[l]; return ; } }
那如果这一节点还可以再往下分，那就再分两半，一个区间为[l,(l+r)/2]另一个区间为[(l+r)/2+1,r]，往下递归
1 void build(int l,int r,int num)
2 { 3 a[num].l=l; 4 a[num].r=r; 5 if(l==r) 6 { 7 a[num].sum=in[l]; 8 return ; 9 } 10 int mid=(l+r)/2; 11 build(l,mid,num*2); 12 build(mid+1,r,num*2+1); 13 }
通过这个图，我们可以看出，一个父亲节点的sum就是两个儿子节点的sum之和
即如下代码
1 void build(int l,int r,int num)
2 { 3 a[num].l=l; 4 a[num].r=r; 5 if(l==r) 6 { 7 a[num].sum=in[l]; 8 return ; 9 } 10 int mid=(l+r)/2; 11 build(l,mid,num*2); 12 build(mid+1,r,num*2+1); 13 a[num].sum=a[num*2].sum+a[num*2+1].sum; 14 }
以上就是建树部分的代码了，这时候我们再加上主函数进行录入，和存线段树用的结构体
1 #include<bits/stdc++.h>
2 using namespace std;
3 const int mm=100005; 4 int in[mm]; 5 struct tree{ 6 int l,r; 7 int sum; 8 }a[mm*4]; 9 void build(int l,int r,int num) 10 { 11 a[num].l=l; 12 a[num].r=r; 13 if(l==r) 14 { 15 a[num].sum=in[l]; 16 return ; 17 } 18 int mid=(l+r)/2; 19 build(l,mid,num*2); 20 build(mid+1,r,num*2+1); 21 a[num].sum=a[num*2].sum+a[num*2+1].sum; 22 } 23 int main(){ 24 //freopen("in.txt","r",stdin); 25 //freopen("out.txt","w",stdout); 26 for(int i=1;i<=10;i++) 27 { 28 cin>>in[i]; 29 } 30 build(1,m,1); 31 return 0; 32 }
就是完整的线段树建树部分的代码了
再加一行代码调试一下
1 #include<bits/stdc++.h>
2 using namespace std;
3 const int mm=100005; 4 int in[mm]; 5 struct tree{ 6 int l,r; 7 int sum; 8 }a[mm*4]; 9 void build(int l,int r,int num) 10 { 11 a[num].l=l; 12 a[num].r=r; 13 if(l==r) 14 { 15 a[num].sum=in[l]; 16 return ; 17 } 18 int mid=(l+r)/2; 19 build(l,mid,num*2); 20 build(mid+1,r,num*2+1); 21 a[num].sum=a[num*2].sum+a[num*2+1].sum; 22 } 23 int main(){ 24 //freopen("in.txt","r",stdin); 25 //freopen("out.txt","w",stdout); 26 for(int i=1;i<=10;i++) 27 { 28 cin>>in[i]; 29 } 30 build(1,10,1); 31 cout<<a[1].sum; 32 return 0; 33 }
结果如下
正常输出
来看下面一道题目，先只用完成建树的部分
P1816 忠诚 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)
这里的建树和标准的建树几乎一模一样，只是每次建树时的sum改成存这个节点区间内的最小值minn就好
前面这段除了改变了sum变成minn以外没有区别
1 void build(int l,int r,int num)
2 { 3 a[num].l=l; 4 a[num].r=r; 5 if(l==r) 6 { 7 a[num].minn=in[l]; 8 return ; 9 } 10 int mid=(l+r)/2; 11 build(l,mid,num*2); 12 build(mid+1,r,num*2+1); 13 }
只是最后父亲节点不再是将两个儿子节点的sum累加了，而是选取两个minn中的最小值
即完整建树
void build(int l,int r,int num)
{
a[num].l=l; a[num].r=r; if(l==r) { a[num].minn=in[l]; return ; } int mid=(l+r)/2; build(l,mid,num*2); build(mid+1,r,num*2+1); a[num].minn=min(a[num*2].minn,a[num*2+1].minn) ; }
暂时就是这些了，接下来的部分等一会再细讲
二、线段树单点查询
线段树是递归建树的，单点查询也是由递归完成的
大致思想就是从根节点开始，如果儿子节点的区间包含要查询的元素，就往下递归
在刚刚建树的基础上输入一个k，查询输入的第k个数是啥
来分析一下，在线段树中查询一个元素，就需要从根节点开始，哪边儿子包含这个元素就往他那里走，当这个节点就是原来要查询的节点时，输出值，返回
先来看看当这个节点完全等于要查询的元素下标时候
1 void search(int l,int r,int num,int res)//目前区间，目前编号，目标位置
2 {
3 if(r==res&&l==res) 4 { 5 cout<<a[num].sum; 6 return ; 7 } 8 }
直接输出，然后立刻返回
为了方便后边调用，我们设置两个变量
int mid=(l+r)/2;
tree an1=a[num*2];
然后就是十分重要的判断----判断左右儿子哪一个的区间包含查询的目的位置
判断条件很容易写，即儿子的左区间小于等于这个下标，右区间大于等于这个下标，如果不满足则就往另一儿子处走
即
1 if(an1.l<=res&&an1.r>=res)
2 { 3 search(l,mid,num*2,res); 4 } 5 else 6 { 7 search(mid+1,r,num*2+1,res); 8 }
这里可以看到我们只判断一边的儿子是否包含下标是因为，开始的时候，根节点包含所有录入的数，可以保证能包含此下标，然后后面的每一步都是在包含这个下标的区域去递归，所以就形成了一个非黑即白的场面
看看完整代码
#include<bits/stdc++.h>
using namespace std;
const int mm=100005; int in[mm]; int n,m; struct tree{ int l,r; int sum; }a[mm*4]; void build(int l,int r,int num) { a[num].l=l; a[num].r=r; if(l==r) { a[num].sum=in[l]; return ; } int mid=(l+r)/2; build(l,mid,num*2); build(mid+1,r,num*2+1); a[num].sum=a[num*2].sum+a[num*2+1].sum; } void search(int l,int r,int num,int res)//目前区间，目前编号，目标位置 { if(r==res&&l==res) { cout<<a[num].sum; return ; } int mid=(l+r)/2; tree an1=a[num*2]; if(an1.l<=res&&an1.r>=res) { search(l,mid,num*2,res); } else { search(mid+1,r,num*2+1,res); } return ; } int main(){ //freopen("in.txt","r",stdin); //freopen("out.txt","w",stdout); cin>>n; for(int i=1;i<=n;i++) { cin>>in[i]; } build(1,n,1); cout<<a[1].sum<<endl; cin>>m; search(1,n,1,m); return 0; }
n是你要输入的元素个数，in是输入的元素，m是要查询的下标，输出的第一行是你输入的元素之和，第二行是你所查询的下标的元素
很多人可能看到这里会像，这不是多此一举吗？直接cout<<in[n];不好吗？那么，接下来的单点查询就要用到这个思路了
三，单点修改
设想一下，对线段树底部的一个元素进行修改，是不是他的爸爸，爷爷，祖先都要发生更改？
因此，所有区间内包含了这个元素的节点都要进行改变。
如果从根节点开始递归，那就按照“单点查询”路线将走过的所有节点都改一遍。
比如我们此时在输入一个数s，表示在输入数组in中的下标，把他改成d，那么沿途所有节点的sum都得增加(d-in[s])
1 void reload(int l,int r,int num,int res,int exc)//新增的一个元素是要改成的数值
2 {
3 if(r==res&&l==res) 4 { 5 return ; 6 } 7 int mid=(l+r)/2; 8 tree an1=a[num*2]; 9 if(an1.l<=res&&an1.r>=res) 10 { 11 reload(l,mid,num*2,res,exc); 12 } 13 else 14 { 15 reload(mid+1,r,num*2+1,res,exc); 16 } 17 return ; 18 }
首先大体上与查询一样，新增了一个变量exc，然后去掉了查询时的输出
接下来再加上一句灵性的
a[num].sum+=exc-in[res];
看看完整效果
1 #include<bits/stdc++.h>
2 using namespace std;
3 const int mm=100005; 4 int in[mm]; 5 int n,m,s,d; 6 struct tree{ 7 int l,r; 8 int sum; 9 }a[mm*4]; 10 void build(int l,int r,int num) 11 { 12 a[num].l=l; 13 a[num].r=r; 14 if(l==r) 15 { 16 a[num].sum=in[l]; 17 return ; 18 } 19 int mid=(l+r)/2; 20 build(l,mid,num*2); 21 build(mid+1,r,num*2+1); 22 a[num].sum=a[num*2].sum+a[num*2+1].sum; 23 } 24 void search(int l,int r,int num,int res)//目前区间，目前编号，目标位置 25 { 26 if(r==res&&l==res) 27 { 28 cout<<a[num].sum<<endl; 29 return ; 30 } 31 int mid=(l+r)/2; 32 tree an1=a[num*2]; 33 if(an1.l<=res&&an1.r>=res) 34 { 35 search(l,mid,num*2,res); 36 } 37 else 38 { 39 search(mid+1,r,num*2+1,res); 40 } 41 return ; 42 } 43 void reload(int l,int r,int num,int res,int exc)//新增的一个元素是要改成的数值 44 { 45 a[num].sum+=exc-in[res]; 46 if(r==res&&l==res) 47 { 48 return ; 49 } 50 int mid=(l+r)/2; 51 tree an1=a[num*2]; 52 if(an1.l<=res&&an1.r>=res) 53 { 54 reload(l,mid,num*2,res,exc); 55 } 56 else 57 { 58 reload(mid+1,r,num*2+1,res,exc); 59 } 60 return ; 61 } 62 int main(){ 63 freopen("in.txt","r",stdin); 64 freopen("out.txt","w",stdout); 65 cin>>n; 66 for(int i=1;i<=n;i++) 67 { 68 cin>>in[i]; 69 } 70 build(1,n,1); 71 cout<<a[1].sum<<endl; 72 cin>>m; 73 search(1,n,1,m); 74 cin>>s>>d; 75 reload(1,n,1,s,d); 76 cout<<a[1].sum<<endl; 77 return 0; 78 }
以上代码就是关于建树，单点查改的全部内容了😵
四，区间查询
区间查询和单点查询是有点相似的，只不过这里并不需要一查到底，倘若某节点的区间在查询区间以内，就将该节点的区间拿出来累加，如果只有一部分在，那就继续向下走
区间查询要求：输入两个数，求出in中下标为两个数间的和；
我们来重新搬出这幅图
比如，我们要查询区间为[3，7]内的数字之和
[1，10]的范围大了，完全包含了[3，7]，而且要查询的区间的左边界比[1，10]区间的中点小，因此向左儿子递归，而要查询的区间的右边界比[1，10]区间的中点大，所以还可以向右儿子递归
再看到左儿子那里，查询区间的左边界比它的中点大因此不用往左儿子递归了，往右儿子递归；至于右儿子那边，左边界比mid小，右边界也比mid小所以往左儿子继续递归
如图
因为[3,5]，[6,7]节点都完全被查询区间盖满了，所以就不必再往下递归，最后的结果便是这两的sum之和
来看看代码怎么写
这次查找我们带入5个变量，分别是该节点编号，查询区间，目前节点区间
void found(int num,int l,int r,int ll,int rr)
当该节点区间被查询区间完全覆盖时，就说明这是所需要查询的一部分，用ans累加
当该节点左右的区间不足触碰到查询区间边界时，说明走过头了，得回去
回溯部分
1 void found(int num,int l,int r,int ll,int rr)
2 { 3 if(a[num].l>=l&&a[num].r<=r) 4 { 5 ans+=a[num].sum; 6 return ; 7 } 8 if(a[num].r<l||a[num].l>r) 9 { 10 return ; 11 } 12 }
就像我之前一样，为了方便我们再定义一个mid
int mid=(a[num].l+a[num].r)/2;
按照我们前文讨论的思路，当l<=mid时就往左儿子递归，当r>mid时就往右儿子递归
看看整体效果
1 void found(int num,int l,int r,int ll,int rr)
2 { 3 if(a[num].l>=l&&a[num].r<=r) 4 { 5 ans+=a[num].sum; 6 return ; 7 } 8 if(a[num].r<l||a[num].l>r) 9 { 10 return ; 11 } 12 int mid=(a[num].l+a[num].r)/2; 13 if(l<=mid) 14 { 15 found(2*num,l,r,ll,mid); 16 } 17 if(r>mid) 18 { 19 found(2*num+1,l,r,mid+1,rr); 20 } 21 return ; 22 }
这样就可以实现区间查询了，最后再带上主函数以及前面讲的内容
1 #include<bits/stdc++.h>
2 using namespace std;
3 const int mm=100005; 4 int in[mm]; 5 int n,m,s,d,a1,b1; 6 int ans; 7 struct tree{ 8 int l,r; 9 int sum; 10 }a[mm*4]; 11 void build(int l,int r,int num) 12 { 13 a[num].l=l; 14 a[num].r=r; 15 if(l==r) 16 { 17 a[num].sum=in[l]; 18 return ; 19 } 20 int mid=(l+r)/2; 21 build(l,mid,num*2); 22 build(mid+1,r,num*2+1); 23 a[num].sum=a[num*2].sum+a[num*2+1].sum; 24 } 25 void search(int l,int r,int num,int res)//目前区间，目前编号，目标位置 26 { 27 if(r==res&&l==res) 28 { 29 cout<<a[num].sum<<endl; 30 return ; 31 } 32 int mid=(l+r)/2; 33 tree an1=a[num*2]; 34 if(an1.l<=res&&an1.r>=res) 35 { 36 search(l,mid,num*2,res); 37 } 38 else 39 { 40 search(mid+1,r,num*2+1,res); 41 } 42 return ; 43 } 44 void reload(int l,int r,int num,int res,int exc)//新增的一个元素是要改成的数值 45 { 46 a[num].sum+=exc-in[res]; 47 if(r==res&&l==res) 48 { 49 return ; 50 } 51 int mid=(l+r)/2; 52 tree an1=a[num*2]; 53 if(an1.l<=res&&an1.r>=res) 54 { 55 reload(l,mid,num*2,res,exc); 56 } 57 else 58 { 59 reload(mid+1,r,num*2+1,res,exc); 60 } 61 return ; 62 } 63 void found(int num,int l,int r,int ll,int rr) 64 { 65 if(a[num].l>=l&&a[num].r<=r) 66 { 67 ans+=a[num].sum; 68 return ; 69 } 70 if(a[num].r<l||a[num].l>r) 71 { 72 return ; 73 } 74 int mid=(a[num].l+a[num].r)/2; 75 if(l<=mid) 76 { 77 found(2*num,l,r,ll,mid); 78 } 79 if(r>mid) 80 { 81 found(2*num+1,l,r,mid+1,rr); 82 } 83 return ; 84 } 85 int main(){ 86 //freopen("in.txt","r",stdin); 87 //freopen("out.txt","w",stdout); 88 cin>>n; 89 for(int i=1;i<=n;i++) 90 { 91 cin>>in[i]; 92 } 93 build(1,n,1); 94 cout<<a[1].sum<<endl; 95 cin>>m; 96 search(1,n,1,m); 97 cin>>s>>d; 98 reload(1,n,1,s,d); 99 cout<<a[1].sum<<endl; 100 /*reload(1,n,1,s,d); 101 cout<<a[1].sum<<endl;*///可以用作把改过的改回来 102 cin>>a1>>b1; 103 found(1,a1,b1,1,n); 104 cout<<ans<<endl; 105 return 0; 106 }
以上就是本讲的建树，单点查询，单点修改和区间查询的全部内容了，代码在这↑，很快我应该就会更新带懒操作的线段树查改了，敬请期待！
如果您感觉本文对您有帮助，千万不要吝啬手上的赞和关注，最后，感谢您的访问，再会！