（一）线段树入门--区间最值查询

这是一篇入门文章，不过需要你知道啥是二叉树，并且知道递归，本文会持续更新，时间看作者心情。

线段树

描述

分类：二叉树搜索树
节点结构：

struct node
{
    int l,r;//范围【l,r】
}tr[100];

解决问题：区间问题
图示：（显示了节点分布）

叶子结点：树的最小节点。如【1,1】,【2,2】这些结点。

线段树是一棵二叉搜索树，它的每个结点都包含一个区间【l,r】，叶子结点对应的是一个单位区间，即 L == R 。对于一个非叶子结点，它的左儿子对应的区间为【L,(L+R)/2】，右儿子对应的区间为【(L+R)/2+1,R】。这棵树包含N个叶子结点，即整个区间的长度。

区间最值查询问题

给你一个数组，要求你进行两种操作
（1） 修改一个元素（更新操作）
（2）查询一段区间的最大值（查询操作）

用线段树可以很好解决区间的最值查询问题，首先我们要确定结点结构。

struct node//结点
{
    int l,r;//范围【l,r】
    int mx; //区间的最大值，max缩写
}tr[100];//tree的缩写

然后我们需要建树：即建立二叉树的同时把区间最大值完成。这里我们采用递归的方法
具体操作：每个结点建立它的区间，叶子节点建立区间【l,r】和结点最大值mx，等叶子节点的最大值mx完成，父节点开始建立它的区间最大值mx。

查询操作和更新操作都是先维护子结点，然后更新父节点。

总结：先维护子结点，然后更新父节点。

模板

/**
 * 线段树
 * d为结点号,每个函数都有
 */
#include<iostream>
#include<stdio.h>
#include<algorithm>

using namespace std;
const int mmax = 100;
int b[mmax] = {0,1,2,3,4,5,6,7,8,9,10};//初始化数组
struct tree
{
    int l,r;
    int mx;
}tr[mmax*4];//为何是*4呢？？（下回揭晓）

//建树
void build(int d,int l,int r)
{
    tr[d].l = l,tr[d].r = r;
    if(l == r)//叶子节点处理
    {
        tr[d].mx = b[l];
        return;
    }
    int mid = (l+r)/2;//这里的mid,lc,rc，不能定义为全局变量
    int lc = d*2;
    int rc = d*2+1;
    build(lc,l,mid);
    build(rc,mid+1,r);
    tr[d].mx = max(tr[lc].mx,tr[rc].mx);//处理爸爸们
}

//查询[l,r]最大值
int search(int d,int l,int r)
{
    if(tr[d].l == l && tr[d].r == r)//查到对应范围
    {
        return tr[d].mx;
    }
    int mid = (l+r)/2;
    int lc = d*2;
    int rc = d*2+1;
    if(mid >= r)
    {
        return search(lc,l,mid);
    }
    else if(mid <= l)
    {
        return search(rc,mid+1,r);
    }
    else
    {
        return max(search(lc,l,mid),search(rc,mid+1,r));
    }
}

//更新,将【pos,pos】结点最大值改为v
void modify(int d,int pos, int v)
{
    if(tr[d].l == tr[d].r && tr[d].l == pos)
    {
        tr[d].mx = v;
        return;
    }
    int mid = (tr[d].l+tr[d].r)/2;
    int lc = d*2;
    int rc = d*2+1;
    if(pos > mid)//右侧无法>=，可以想一想，试一试
    {
        modify(rc, pos, v);
    }
    else
    {
        modify(lc, pos, v);
    }
    tr[d].mx = max(tr[lc].mx,tr[rc].mx);
}

int main()
{
    build(1,1,4);
    for(int i = 1; i <= 7; i++)
        printf("有7个结点，第%d个结点为%d\n",i,tr[i].mx);
    printf("1-3的最大值%d\n",search(1,1,3));
    modify(1,1,10);
    for(int i = 1; i <= 7; i++)
        printf("有7个结点，第%d个结点为%d\n",i,tr[i].mx);
    return 0;
}

一棵看上去很唬人的树

线段树其实不难，本质二叉树，处理用递归，处理时分叶子结点和父结点分类讨论。很多人往往被它的名字所吓倒，其实静下心来看，还是可以看懂的。

一些比较酷的操作

在实际代码中，经常有一些骚操作，这里贴一段优化的代码。（运行起来实际其实并没快多少，但装装b还是可以的。）大家可以看一看，再复习一下。

/**
 * 线段树，优化装b版
 */
#include<iostream>
#include<stdio.h>
#include<algorithm>

using namespace std;
//不用定义局部变量了
#define mid (r+l>>1)
#define lc (d<<1)
#define rc (d<<1|1)
const int mmax = 100;

int b[mmax] = {0,1,2,3,4,5,6,7,8,9,10};//初始化数组
struct tree
{
    int l,r;
    int mx;
}tr[mmax<<2];//位运算，只是装装b，-。-

//建树
void build(int d,int l,int r)
{
    tr[d].l = l,tr[d].r = r;
    if(l == r)//叶子节点处理
    {
        tr[d].mx = b[l];
        return;
    }
    build(lc,l,mid);
    build(rc,mid+1,r);
    tr[d].mx = max(tr[lc].mx,tr[rc].mx);//处理爸爸们
}

//查询[l,r]最大值
int search(int d,int l,int r)
{
    if(tr[d].l == l && tr[d].r == r)//查到对应范围
    {
        return tr[d].mx;
    }
    if(mid >= r)
    {
        return search(lc,l,mid);
    }
    else if(mid <= l)
    {
        return search(rc,mid+1,r);
    }
    else
    {
        return max(search(lc,l,mid),search(rc,mid+1,r));
    }
}

//更新,将【pos,pos】结点最大值改为v
void modify(int d,int pos, int v)
{
    if(tr[d].l == tr[d].r && tr[d].l == pos)
    {
        tr[d].mx = v;
        return;
    }
    int mid2 = (tr[d].l+tr[d].r)/2;
    if(pos > mid2)//右侧无法>=，可以想一想，试一试
    {
        modify(rc, pos, v);
    }
    else
    {
        modify(lc, pos, v);
    }
    tr[d].mx = max(tr[lc].mx,tr[rc].mx);
}

int main()
{
    build(1,1,4);
    for(int i = 1; i <= 7; i++)
        printf("有7个结点，第%d个结点为%d\n",i,tr[i].mx);
    printf("1-3的最大值%d\n",search(1,1,3));
    modify(1,1,10);
    for(int i = 1; i <= 7; i++)
        printf("有7个结点，第%d个结点为%d\n",i,tr[i].mx);
    return 0;
}