浅谈线段树：

综述

线段树的原理：将[1,n]分解成若干特定的子区间(数量不超过4*n),然后，将每个区间[L,R]都分解为少量特定的子区间，通过对这些少量子区间的修改或者统计，来实现快速对[L,R]的修改或者统计。
作用：对编号连续的一些点的区间信息进行修改或者统计操作
主要操作：区间查询、点更新、区间更新
时间复杂度：修改和统计的复杂度都是O(log(N))

由原理可以看出线段树维护的信息必须满足区间加法
如：
数字之和——总数字之和 = 左区间数字之和 + 右区间数字之和
最大公因数(GCD)——总GCD = gcd( 左区间GCD , 右区间GCD );
最大值——总最大值=max(左区间最大值，右区间最大值)

下面是整理的一些模板，希望你能喜欢（递归实现）:

void PushUp(int tr)//往上更新
{
    sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}

void buildT(int l , int r ,int rt)//建树
{
    if(l == r){
        scanf("%d",&sum[rt]);
        return ;
    }
    int m = (l + ｒ) >> 1;
    buildT(l , m , rt << 1);
    buildT(m + 1 , r , rt << 1 | 1);
    PushUp(rt);
}

void UpDate(int p , int add ,int l ,int r,int rt)//更新节点
{
    if(l == r){
        sum[rt] += add;
        return;
    }
    int m = (l + r) >> 1;
    if(p <= m) UpDate(p , add ,l , m , rt << 1);
    else UpDate(p , add , m + 1 , r , rt << 1 | 1);
    PushUp(rt);
}

int query(int ll ,int rr ,int l , int r ,int rt)//查询
{
    if(ll <= l && rr >= r) return sum[rt];
    int m = (l + r) >> 1;
    int ret = 0;
    if(ll <= m) ret += query(ll ,rr , l , m , rt << 1);
    if(rr > m) ret += query(ll ,rr , m + 1 , r , rt << 1 | 1);
    return ret;
}

下面的代码转至他人的博客（递归实现）：

(0)定义：
#define maxn 100007  //元素总个数  
int Sum[maxn<<2];//Sum求和，开四倍空间
int A[maxn],n;//存原数组下标[1，n]

(1)建树：
//PushUp函数更新节点信息，这里是求和
void PushUp(int rt){Sum[rt]=Sum[rt<<1]+Sum[rt<<1|1];}  
//Build函数建立线段树
void Build(int l,int r,int rt){ //[l,r]表示当前节点区间，rt表示当前节点的实际存储位置 
    if(l==r) {//若到达叶节点 
        Sum[rt]=A[l];//存储A数组的值
        return;  
    }  
    int m=(l+r)>>1;  
   //左右递归
    Build(l,m,rt<<1);  
    Build(m+1,r,rt<<1|1);  
    //更新信息
    PushUp(rt);  
}  

(2)点修改：
假设A[L]+=C:

void Update(int L,int C,int l,int r,int rt){//[l,r]表示当前区间，rt是当前节点编号//l,r表示当前节点区间，rt表示当前节点编号  
    if(l==r){//到达叶节点，修改叶节点的值
        Sum[rt]+=C;  
        return;  
    }  
    int m=(l+r)>>1;  
   //根据条件判断往左子树调用还是往右
    if(L <= m) Update(L,C,l,m,rt<<1);  
    else       Update(L,C,m+1,r,rt<<1|1);  
    PushUp(rt);//子节点的信息更新了，所以本节点也要更新信息
}   
点修改其实可以写的更简单，只需要把一路经过的Sum都+=C就行了，不过上面的代码更加规范，在题目更加复杂的时候，按照格式写更不容易错。


(3)区间查询（本题为求和）：

询问A[L..R]的和
注意到，整个函数的递归过程中，L,R是不变的。
首先如果当前区间[l,r]在[L,R]内部，就直接累加答案
如果左子区间与[L,R]有重叠，就递归左子树，右子树同理
int Query(int L,int R,int l,int r,int rt){//[L,R]表示操作区间，[l,r]表示当前区间，rt:当前节点编号
    if(L <= l && r <= R){  
       //在区间内直接返回
        return Sum[rt];  
    }  
    int m=(l+r)>>1;  
    //左子区间:[l,m] 右子区间：[m+1,r]  求和区间:[L,R]
   //累加答案
    int ANS=0;  
    if(L <= m) ANS+=Query(L,R,l,m,rt<<1);//左子区间与[L,R]有重叠，递归
    if(R >  m) ANS+=Query(L,R,m+1,r,rt<<1|1); //右子区间与[L,R]有重叠，递归
    return ANS;  

下面是非递归的实现方法（emmmm）：

以下以维护数列区间和的线段树为例，演示最基本的非递归线段树代码。
(0)定义：

// 
#define maxn 100007
int A[maxn],n,N;//原数组,n为原数组元素个数 ,N为扩充元素个数 
int Sum[maxn<<2];//区间和 
int Add[maxn<<2];//懒惰标记 

(1)建树:

//
void Build(int n){
    //计算N的值 
    N=1;while(N < n+2) N <<= 1;
    //更新叶节点 
    for(int i=1;i<=n;++i) Sum[N+i]=A[i];//原数组下标+N=存储下标
    //更新非叶节点 
    for(int i=N-1;i>0;--i){
        //更新所有非叶节点的统计信息 
        Sum[i]=Sum[i<<1]+Sum[i<<1|1];
        //清空所有非叶节点的Add标记 
        Add[i]=0;
    }
} 

(2)点修改：

A[L]+=C
//
void Update(int L,int C){
    for(int s=N+L;s;s>>=1){
        Sum[s]+=C;
    }
} 

(3)点修改下的区间查询：

求A[L..R]的和（点修改没有使用Add所以不需要考虑）
代码非常简洁，也不难理解,
s和t分别代表之前的论述中的左右蓝色节点，其余的代码根据之前的论述应该很容易看懂了。
s^t^1 在s和t的父亲相同时值为0，终止循环。
两个if是判断s和t分别是左子节点还是右子节点，根据需要来计算Sum
//
int Query(int L,int R){
    int ANS=0;
    for(int s=N+L-1,t=N+R+1;s^t^1;s>>=1,t>>=1){
        if(~s&1) ANS+=Sum[s^1];
        if( t&1) ANS+=Sum[t^1];
    }
    return ANS;
} 

(4)区间修改：

A[L..R]+=C
<span style="font-size:14px;">//
void Update(int L,int R,int C){
    int s,t,Ln=0,Rn=0,x=1;
    //Ln:  s一路走来已经包含了几个数
    //Rn:  t一路走来已经包含了几个数
    //x:   本层每个节点包含几个数
    for(s=N+L-1,t=N+R+1;s^t^1;s>>=1,t>>=1,x<<=1){
        //更新Sum
        Sum[s]+=C*Ln;
        Sum[t]+=C*Rn;
        //处理Add
        if(~s&1) Add[s^1]+=C,Sum[s^1]+=C*x,Ln+=x;
        if( t&1) Add[t^1]+=C,Sum[t^1]+=C*x,Rn+=x;
    }
    //更新上层Sum
    for(;s;s>>=1,t>>=1){
        Sum[s]+=C*Ln;
        Sum[t]+=C*Rn;
    } 
} </span>

(5)区间修改下的区间查询：

求A[L..R]的和
//
int Query(int L,int R){
    int s,t,Ln=0,Rn=0,x=1;
    int ANS=0;
    for(s=N+L-1,t=N+R+1;s^t^1;s>>=1,t>>=1,x<<=1){
        //根据标记更新 
        if(Add[s]) ANS+=Add[s]*Ln;
        if(Add[t]) ANS+=Add[t]*Rn;
        //常规求和 
        if(~s&1) ANS+=Sum[s^1],Ln+=x;
        if( t&1) ANS+=Sum[t^1],Rn+=x; 
    }
    //处理上层标记
    for(;s;s>>=1,t>>=1){
        ANS+=Add[s]*Ln;
        ANS+=Add[t]*Rn;
    }
    return ANS;
}