线段树入门总结

树结构的基本思想是分割，普通二叉搜索树是按照数据来划分(想了解二叉搜索树的请移步：Here)，线段树处理的对象是线段（区间也可以看成线段，L==R时为一个点），它把线段组织成有利于检索和统计的形式，它的本质是线段的二叉搜索树。但是它的线段可以分解和合并，线段树又有一些一般二叉检索树没有的特殊操作。另外线段树操作的是整个区间，它的时间复杂度不依赖于数据对象。它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN）。而未优化的空间复杂度为2N，因此有时需要离散化让空间压缩。

线段树的定义：
       线段树是一棵二叉检索树，最终将一个区间 [1,n] 划分为一些 [ i,i+1 ]的但愿区间，每个单元区间对应一个叶节点。叶节点区间只有一个数（L == R）。对于每个线段树的非叶子节点 [ a, b ]，其左儿子 为 [a,(a+b)/2],右儿子为 [ (a+b)/2 + 1,b]。所以线段树是一颗平衡二叉树。最后节点数目为 N 即整段区间的长度，其节点数为  n + n/2 + n/4 + ... = 2n。所以其空间复杂度为 O(2n)。
时间复杂度为 log n（插入或者读取均为log n）。其结构如图
线段树的处理对象：
           线段树的处理对象是一段区间，区间上的格点对应有限个区域的变量，处理问题的时候，抽出区间上的格点，也是明确每个格点对应变量的含义。
线段树的基本结构：
       一棵线段树，应该具有 插入 ， 修改  ，  查询 三个基本功能。
【代码实现】：
我们以区间最值问题（RMQ）为例：
我们先声明线段树所需的结构体
[cpp] view plaincopyprint?
  1. #include <stdio.h>  
  2. #define MAXN 1<<19  
  3. typedef struct  
  4. {  
  5.     int value;      //区间最值  
  6.     int left,right; //区间范围  
  7. }Tree;  
  8. Tree node[2*MAXN];  
  9. int father[MAXN];   //记录叶子对应结构体的 下标</span>  
#include <stdio.h>
#define MAXN 1<<19
typedef struct
{
    int value;      //区间最值
    int left,right; //区间范围
}Tree;
Tree node[2*MAXN];
int father[MAXN];   //记录叶子对应结构体的 下标</span>
 
如图所示：
如果 二叉树 的 父节点 为 k，那么其 左儿子为 2k，右儿子 为 2k+1。
现在我们可以建立线段树里。
[cpp] view plaincopyprint?
  1. //线段树的建立  
  2. void build(int i, int left, int right){    //i为结构体数组的下标  
  3.     node[i].left = left;          //为节点成员初始化  
  4.     node[i].right = right;  
  5.     node[i].value = 0;  
  6.     if(left == right){   //当线段树的节点为叶子时，结束递归  
  7.         father[left] = i;//将叶子在结构体数组的下标记录，以便更新是可以自下而上  
  8.         return ;  
  9.     }  
  10.     //现在分别建立该节点的左右孩子  
  11.     build(i<<1,left,(left+right)/2);  
  12.     build( (i<<1)+1,1+(left+right)/2,right);  
  13.     return ;  
  14. }  
//线段树的建立
void build(int i, int left, int right){    //i为结构体数组的下标
    node[i].left = left;          //为节点成员初始化
    node[i].right = right;
    node[i].value = 0;
    if(left == right){   //当线段树的节点为叶子时，结束递归
        father[left] = i;//将叶子在结构体数组的下标记录，以便更新是可以自下而上
        return ;
    }
    //现在分别建立该节点的左右孩子
    build(i<<1,left,(left+right)/2);
    build( (i<<1)+1,1+(left+right)/2,right);
    return ;
}
因为我们现在是以最值得问题作为样例，所以我们更新数据的话就是单点操作，这里最值我们以最大值为例
[cpp] view plaincopyprint?
  1. //自上往下的更新,n_i 如上图所意  
  2. void Updata(int n_i){  
  3.     if(n_i == 1) return ;   //找到了根节点，结束递归  
  4.     int fa = n_i/2;     //找到了父节点  
  5.     int a = node[2*fa].value;  //该父节点的左儿子的值  
  6.     int b = node[2*fa + 1].value;//该父节点的右儿子的值  
  7.     node[fa].value = a>b?a:b;       //更新节点数据  
  8.     Updata(fa);             //递归更新  
  9.     return ;  
  10. }  
//自上往下的更新,n_i 如上图所意
void Updata(int n_i){
    if(n_i == 1) return ;   //找到了根节点，结束递归
    int fa = n_i/2;     //找到了父节点
    int a = node[2*fa].value;  //该父节点的左儿子的值
    int b = node[2*fa + 1].value;//该父节点的右儿子的值
    node[fa].value = a>b?a:b;       //更新节点数据
    Updata(fa);             //递归更新
    return ;
}
现在我们剩下的就差查询操作了
[cpp] view plaincopyprint?
  1. int Max = -MAXN;  
  2. //k为结构体下标，通常我都从根节点开始查询，所以，通常我们初始化时为1  
  3. //查询区间为 [ left, right ]  
  4. void Query(int k,int left,int right){  
  5.     //当查询区间完全重合时  
  6.     if(node[k].left == left && node[k].right == right){  
  7.         Max = Max > node[k].value ? Max : node[k].value;  
  8.         return ;  
  9.     }  
  10.     //对左子树进行操作  
  11.     if(left <= node[2*k].right){  //如果与左区间有交集  
  12.         if(right <= node[2*k].right)  //如果完全包含于左区间，则查询范围不变  
  13.             Query(2*k,left,right);  
  14.         else//否则这将区间查分开，先查询左边的  
  15.             Query(2*k,left,node[2*k].right);  
  16.     }  
  17.     //对右子树进行操作  
  18.     if(right >= node[2*k+1].left){  //如果与右区间有交集  
  19.         if(left >= node[2*k+1].left)  //如果完全包含于右区间，则查询范围不变  
  20.             Query(2*k+1,left,right);  
  21.         else//否则这将区间查分开，先查询右边的  
  22.             Query(2*k+1,node[2*k+1].left,right);  
  23.     }  
  24.     return ;  
  25. }  
int Max = -MAXN;
//k为结构体下标，通常我都从根节点开始查询，所以，通常我们初始化时为1
//查询区间为 [ left, right ]
void Query(int k,int left,int right){
    //当查询区间完全重合时
    if(node[k].left == left && node[k].right == right){
        Max = Max > node[k].value ? Max : node[k].value;
        return ;
    }
    //对左子树进行操作
    if(left <= node[2*k].right){  //如果与左区间有交集
        if(right <= node[2*k].right)  //如果完全包含于左区间，则查询范围不变
            Query(2*k,left,right);
        else//否则这将区间查分开，先查询左边的
            Query(2*k,left,node[2*k].right);
    }
    //对右子树进行操作
    if(right >= node[2*k+1].left){  //如果与右区间有交集
        if(left >= node[2*k+1].left)  //如果完全包含于右区间，则查询范围不变
            Query(2*k+1,left,right);
        else//否则这将区间查分开，先查询右边的
            Query(2*k+1,node[2*k+1].left,right);
    }
    return ;
}
这样我们就完整的建立了一棵线段树了，通过建立线段树我们对线段树已经有了一个大致的了解了，大家可以去找题目练习练习。
hdu1754 I Hate It这是一道线段树的入门级水题，大家可以尝试尝试
posted @ 2015-11-30 21:10  小松鼠。  阅读(276)  评论(0)  编辑  收藏  举报