C++ 线段树概念详解及模板

前言

当你遇到有一些类似线性查找的题的时候，刚好数据特别大的时候，那么线段树这个东西就很好用了，但是线段树的概念就是学习线段树的一大难点，要想学好线段树，就要先了解线段树。

---

线段树的概念

1. 线段树是一棵二叉树，其节点表示的是一个区间 [ x , y ]

2. 每一个叶子节点表示了一个单位区间，根节点表示的是“整体”的区间。

3. 每个非叶子节点的区间 [ x , y ]

        其左儿子节点的区间 [ x , ( x + y ) / 2 ]

        其右儿子节点的区间 [ ( x + y ) / 2 +１，ｙ]

---

线段树的特点

线段树的每个节点上往往都增加了一些其他的域。在这些域中保存了某种动态维护的信息，视不同情况而定。这些域使得线段树具有极大的灵活性，可以适应不同的需求。

---

线段树的建立

这个就要用递归来完成了

​
void build( int i , int l , int r )
{
    int mid = ( l + r ) / 2 ;
    Tree[i].l = l ;
    Tree[i].r = r ;
    Tree[i].cv = 0 ;//线段树的域
    if( l == r )//无法再分，返回
        return ;
    build( i * 2 , l , mid );
    build( i * 2 + 1 , mid + 1 , r );
}

​

build( i * 2 , l , mid )，建立左儿子
build( i * 2 + 1 , mid + 1 , r )，建立右儿子

ｃｖ就是一个域

---

线段树的插入

第一个判定语句判定要插入的线段与当前线段是否相交

如果刚好相等，就改变维护的信息

否则，检索一遍左右儿子

​
void iinsert(int i , int  l , int r )
{
    if( r < Tree[i].l || l > Tree[i].r )//左右端点不在这个区间
        return ;
    if( l <= Tree[i].l && r >= Tree[i].r )//包含这个区间
    {
        Tree[i].cv = 1;
        return ;
    }
    iinsert( 2 * i , l , r );
    iinsert( 2 * i + 1 , l , r );
}

​

---

线段树求和

遍历一遍线段树，提取出需要的元素

int sum(int i)
{
    if(Tree[i].cv == 1 )
        return Tree[i].r - Tree[i].l + 1 ;
    else
    {
        if( Tree[i].l == Tree[i].r )
            return 0;
        else
        {
            return sum(i * 2) + sum(i * 2 + 1); 
        }
    }
}

---

调用

​
int main()
{
    scanf("%d%d%d", &L , &R , &n );
    if( L < 0 )
        m = - L ;
    L += m ;
    R += m ;
    build( 1 , L , R - 1 );
    for(int i = 1 ; i <= n ; ++ i)
    {
        int ll , rr;
        scanf("%d%d", &ll , &rr );
        ll += m ;
        rr += m ;
        iinsert( 1 , ll , rr - 1  );
    }
    ans = sum(1);
    printf("%d", ans );
}

​

---

大体模板

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
 
int n , L , R , ans , m ;
 
struct node{
    int l , r ;
    bool  cv;
};
 
node Tree[1600005];
 
void build( int i , int l , int r )
{
    int mid = ( l + r ) / 2 ;
    Tree[i].l = l ;
    Tree[i].r = r ;
    Tree[i].cv = 0 ;
    if( l == r )
        return ;
    build( i * 2 , l , mid );
    build( i * 2 + 1 , mid + 1 , r );
}
 
void iinsert(int i , int  l , int r )
{
    if( r < Tree[i].l || l > Tree[i].r )
        return ;
    if( l <= Tree[i].l && r >= Tree[i].r )
    {
        Tree[i].cv = 1;
        return ;
    }
    iinsert( 2 * i , l , r );
    iinsert( 2 * i + 1 , l , r );
}
 
int sum(int i)
{
    if(Tree[i].cv == 1 )
        return Tree[i].r - Tree[i].l + 1 ;
    else
    {
        if( Tree[i].l == Tree[i].r )
            return 0;
        else
        {
            return sum(i * 2) + sum(i * 2 + 1); 
        }
    }
}
 
int main()
{
    scanf("%d%d%d", &L , &R , &n );
    if( L < 0 )
        m = - L ;
    L += m ;
    R += m ;
    build( 1 , L , R - 1 );
    for(int i = 1 ; i <= n ; ++ i)
    {
        int ll , rr;
        scanf("%d%d", &ll , &rr );
        ll += m ;
        rr += m ;
        iinsert( 1 , ll , rr - 1  );
    }
    ans = sum(1);
    printf("%d", ans );
}

---

带区间修改模板

struct node {
	int l , r , sum ;
	int lazy ;
} Tree[4*N] ;

void pushup( int x ) {//更新
	int lson = 2*x , rson = 2*x+1 ;
	Tree[x].sum = Tree[lson].sum + Tree[rson].sum ;
}

void pushdown( int x ) {//下放懒标记
	if( Tree[x].lazy == 1 ) {
		Tree[x].lazy = 0 ;
		Tree[x*2].sum = Tree[x*2].r-Tree[x*2].l+1 ;
		Tree[x*2+1].sum = Tree[x*2+1].r-Tree[x*2+1].l+1 ;//更新左右儿子
		Tree[x*2].lazy = Tree[x*2+1].lazy = 1 ;
		return ;
	}
	if( Tree[x].lazy == 2 ) {
		Tree[x].lazy = 0 ;
		Tree[x*2].sum = Tree[x*2+1].sum = 0 ;//更新左右儿子
		Tree[x*2].lazy = Tree[x*2+1].lazy = 2 ;
	}
}

void build( int l, int r , int x ) {//建线段树
	if( l == r ) {
		Tree[x].lazy = 0 ;
		Tree[x].l = Tree[x].r = l ;
		Tree[x].sum = 0 ;
		return ;
	}
	Tree[x].sum = 0 , Tree[x].lazy = 0 ;
	Tree[x].l = l , Tree[x].r = r ;
	int mid = (l+r)/2 ;
	build(l,mid,x*2);
	build(mid+1,r,x*2+1);
	pushup(x) ;
}

int quary1( int l , int r , int x ) {
	if( l > r )
		swap(l,r) ;
	if( l <= Tree[x].l && r >= Tree[x].r ) {
		int sum = Tree[x].sum ;
		Tree[x].sum = Tree[x].r-Tree[x].l+1 ;
		Tree[x].lazy = 1 ;
		return sum ;
	}
	int mid = (Tree[x].l+Tree[x].r)/2 ;
	pushdown(x) ;//下放懒标记
	int sum = 0 ;
	if( l <= mid )
		sum += quary1(l,r,x*2) ;
	if( r >= mid+1 )
		sum += quary1(l,r,2*x+1) ;
	pushup(x) ;//更新
	return sum ;
}

int quary2( int l , int r , int x ) {
	if( l > r )
		swap(l,r) ;
	if( l <= Tree[x].l && r >= Tree[x].r ) {
		int sum = Tree[x].sum ;
		Tree[x].sum = 0 ;
		Tree[x].lazy = 2 ;//懒标记
		return sum ;
	}
	int mid = (Tree[x].l+Tree[x].r)/2 ;
	pushdown(x);//下放懒标记
	int sum = 0 ;
	if( l <= mid )
		sum += quary2(l,r,x*2) ;
	if( r >= mid+1 )
		sum += quary2(l,r,2*x+1) ;
	pushup(x) ;//更新
	return sum ;
}

#include<cstdio>
#include<iostream>
#include<cmath>
#define LL long long 
using namespace std;

struct node {
	int l , r ;
	LL sum , lazy ;	
	node() {
		lazy = 0 ;
	}
};

struct node Tree[100009*4] ;//为什么乘4———— 
int m , n ;//考虑n，有log2(n)层，1+2+4+8+...+2的log2(n) 次方，则总共约有2*n-1，仅对于n为2的次方时成立 
LL a[100009] ;//若n=6,第一层 l=3,l=3
//第二层 ，l=1 , l=2 , l=1 , l=2  
//第三层 ，l=1 , l=1  

inline void build( int i , int l , int r ) {//建树 
	if( l == r ) {
		Tree[i].l = Tree[i].r = l ;
		Tree[i].sum = a[l] ;
		return ;
	}
	LL mid = (l+r) >> 1 ;//二进制位移处理，节省时间 
	Tree[i].l = l , Tree[i].r = r ;
	build( i<<1 , l , mid );
	build( i<<1|1 , mid+1 , r );
	Tree[i].sum = Tree[i<<1].sum + Tree[i<<1|1].sum ;
	return ;
}

inline void pushdown( int i ) {//懒坐标下放 
	if( Tree[i].lazy != 0 ) {//判断是否有懒坐标 
		Tree[i<<1].lazy += Tree[i].lazy ;
		Tree[i<<1|1].lazy += Tree[i].lazy ;
		Tree[i<<1].sum += ( Tree[i].lazy *( Tree[i<<1].r-Tree[i<<1].l+1 ) );
		Tree[i<<1|1].sum += ( Tree[i].lazy *( Tree[i<<1|1].r-Tree[i<<1|1].l+1 ) );
		Tree[i].lazy = 0 ;
	}
	return ;
}

inline void add( int i , int l , int r , LL k ) {//区间加法 
	if( l > Tree[i].r || r < Tree[i].l )//不在目标区间 
		return ;
	if( Tree[i].l >= l && Tree[i].r <= r ) {//包含目标区间 
		Tree[i].lazy += k ;
		Tree[i].sum += ( Tree[i].r-Tree[i].l+1 )*k ;
		return ;
	}
	pushdown( i );//寻找左右儿子，懒标记下放 
	if( l <= Tree[i<<1].r )
		add( i<<1 , l , r , k );
	if( r >= Tree[i<<1|1].l )
		add( i<<1|1 , l , r , k );
	Tree[i].sum = Tree[i<<1].sum+Tree[i<<1|1].sum ;//更新sum域 
	return ; 
}

inline LL Search( int i , int l , int r ) {
	if( Tree[i].l > r || Tree[i].r < l )//不在该区间 
		return 0 ;
	if( Tree[i].r <= r && Tree[i].l >= l )//包含该区间 
		return Tree[i].sum ;
	pushdown(i) ;
	return Search(i<<1,l,r) + Search(i<<1|1,l,r) ;
}
		
int main() {
	scanf("%d%d", &n , &m );
	for( int i = 1 ; i <= n ; ++ i )
		scanf("%lld", &a[i] );
	build( 1 , 1 , n );
	for( int i = 1 ; i <= m ; ++ i ) {
		int a , x , y ;
		LL k , ans = 0 ;
		scanf("%d", &a );
		if( a == 1 ) {
			scanf("%d%d%lld", &x , &y , &k );
			if( x > y )
				swap(x,y) ;
			add( 1 , x , y , k );
		}
		if( a == 2 ) {
			scanf("%d%d", &x , &y );
			if( x > y )
				swap(x,y) ;
			ans = Search( 1 , x , y );
			printf("%lld\n", ans );
		}
	}
}