在学习线段树之前，我们先来了解一下二叉树。




线段树的构造思想

线段树是一棵二叉树，树中的每一个结点表示了一个区间[a,b]。

每一个叶子节点表示了一个单位区间。

根节点表示的是“整体”的区间。

对于每一个非叶结点所表示的区间[a,b]： 

 左儿子表示的区间为[a,(a+b)/2]

右儿子表示的区间为[(a+b)/2+1,b] 

概念：
线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。
      对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。
      使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，因此有时需要离散化让空间压缩。


【以下以 求区间最大值为例】
[cpp]  view plain  copy
  1. #include <stdio.h>  
  2. #include <math.h>  
  3. const int MAXNODE = 2097152;  
  4. const int MAX = 1000003;  
  5. struct NODE{  
  6.     int value;        // 结点对应区间的权值  
  7.     int left,right;   // 区间 [左区间left,右区间right]  
  8. }node[MAXNODE];  
  9. int father[MAX];     // 每个点(当区间长度为0时，对应一个点)对应的结构体数组下标  


【创建线段树（初始化）】：

       由于线段树是用二叉树结构储存的，而且是近乎完全二叉树的，所以在这里我使用了数组来代替链表上图中区间上面的数字表示了结构体数组中对应的下标，从上到下，从左到右，按顺序排下标。

在完全二叉树中假如一个结点的序号（数组下标）为 l，那么 （二叉树基本关系）有：

（1）I 的父亲为 I/2，

（2）I 的另一个兄弟为 I/2*2（当l为右子树时） 或 I/2*2+1（当l为左子树时）

（3）I 的两个孩子为 I*2 (左)   I*2+1(右)

有了这样的关系之后，我们便能很方便的写出创建线段树的代码了。

[cpp]  view plain  copy
  1. void BuildTree(int i,int left,int right){ // 为区间[left,right]建立一个以i为祖先的线段树，i为数组下标，我称作结点序号  
  2.     node[i].left = left;    // 写入第i个结点中的 左区间  
  3.     node[i].right = right;  // 写入第i个结点中的 右区间  
  4.     node[i].value = 0;      // 每个区间初始化为 0  
  5.     if (left == right){ // 当区间长度为 0 时，结束递归  
  6.         father[left] = i; // 能知道某个点对应的序号，为了更新的时候从下往上一直到顶  
  7.         return;  
  8.     }  
  9.     // 该结点往 左孩子的方向 继续建立线段树，线段的划分是二分思想，如果写过二分查找的话这里很容易接受  
  10.     // 这里将 区间[left,right] 一分为二了  
  11.     BuildTree(i<<1, left, (int)floor( (right+left) / 2.0));  
  12.     // 该结点往 右孩子的方向 继续建立线段树  
  13.     BuildTree((i<<1) + 1, (int)floor( (right+left) / 2.0) + 1, right);  
  14. }  


【单点更新线段树】：

       由于我事先用 father[ ] 数组保存过 每单个结点 对应的下标了，因此我只需要知道第几个点，就能知道这个点在结构体中的位置（即下标）了，这样的话，根据之前已知的基本关系，就只需要直接一路更新上去即可。

[cpp]  view plain  copy
  1. void UpdataTree(int ri){ // 从下往上更新（注：这个点本身已经在函数外更新过了）  
  2.   
  3.     if (ri == 1)return; // 向上已经找到了祖先（整个线段树的祖先结点 对应的下标为1）  
  4.     int fi = ri / 2;        // ri 的父结点  
  5.     int a = node[fi<<1].value; // 该父结点的两个孩子结点（左）  
  6.     int b = node[(fi<<1)+1].value; // 右  
  7.     node[fi].value = (a > b)?(a):(b);    // 更新这个父结点（从两个孩子结点中挑个大的）  
  8.     UpdataTree(ri/2);       // 递归更新，由父结点往上找  
  9. }  


【查询区间最大值】：
       将一段区间按照建立的线段树从上往下一直拆开，直到存在有完全重合的区间停止。对照图例建立的树，假如查询区间为 [2,5] 

红色的区间为完全重合的区间，因为在这个具体问题中我们只需要比较这 三个区间的值 找出 最大值 即可。
[cpp]  view plain  copy
  1. int Max = -1<<20;  
  2. void Query(int i,int l,int r){ // i为区间的序号（对应的区间是最大范围的那个区间，也是第一个图最顶端的区间，一般初始是 1 啦）  
  3.     if (node[i].left == l && node[i].right == r){ // 找到了一个完全重合的区间  
  4.         Max = (Max < node[i].value)?node[i].value:(Max);  
  5.         return ;  
  6.     }  
  7.     i = i << 1; // get the left child of the tree node  
  8.     if (l <= node[i].right){ // 左区间有涉及  
  9.         if (r <= node[i].right) // 全包含于左区间，则查询区间形态不变  
  10.             Query(i, l, r);  
  11.         else // 半包含于左区间，则查询区间拆分，左端点不变，右端点变为左孩子的右区间端点  
  12.             Query(i, l, node[i].right);  
  13.     }  
  14.     i += 1; // right child of the tree  
  15.     if (r >= node[i].left){ // 右区间有涉及  
  16.         if (l >= node[i].left) // 全包含于右区间，则查询区间形态不变  
  17.             Query(i, l, r);  
  18.         else // 半包含于左区间，则查询区间拆分，与上同理  
  19.             Query(i, node[i].left, r);  
  20.     }  
  21. }  

举例说明：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次

在[0,7]区间上建立一棵满二叉树：（为了和已知线段区别，用【】表示线段树中的线段）

                                【0,7】
                         /                  \
                  【0,3】                      【4,7】
                  /      \                     /     \
             【0,1】     【2,3】          【4,5】      【6,7】
             /      \   /      \        /      \      /     \
        【0,0】【1,1】【2,2】 【3,3】【4,4】 【5,5】 【6,6】【7,7】


[cpp]  view plain  copy
  1. 每个节点用结构体：  
  2. struct line  
  3. {  
  4.       int left,right;//左端点、右端点  
  5.       int n;//记录这条线段出现了多少次，默认为0  
  6. }a[16];  
  7. 和堆类似，满二叉树的性质决定a[i]的左儿子是a[2*i]、右儿子是a[2*i+1];  
  8. 然后对于已知的线段依次进行插入操作：  
  9. 从树根开始调用递归函数insert  
  10. void insert(int s,int t,int step)//要插入的线段的左端点和右端点、以及当前线段树中的某条线段  
  11. {  
  12.       if (s==a[step].left && t==a[step].right)  
  13.       {  
  14.             a[step].n++;//插入的线段匹配则此条线段的记录+1  
  15.             return;//插入结束返回  
  16.       }  
  17.       if (a[step].left==a[step].right)   return;//当前线段树的线段没有儿子，插入结束返回  
  18.       int mid=(a[step].left+a[step].right)/2;  
  19.       if (mid>=t)    insert(s,t,step*2);//如果中点在t的右边，则应该插入到左儿子  
  20.       else if (mid<s)    insert(s,t,step*2+1);//如果中点在s的左边，则应该插入到右儿子  
  21.       else//否则，中点一定在s和t之间，把待插线段分成两半分别插到左右儿子里面  
  22.       {  
  23.             insert(s,mid,step*2);  
  24.             insert(mid+1,t,step*2+1);  
  25.       }  
  26. }  

三条已知线段插入过程：

[2,5]

--[2,5]与【0,7】比较，分成两部分：[2,3]插到左儿子【0,3】，[4,5]插到右儿子【4,7】

--[2,3]与【0,3】比较，插到右儿子【2,3】；[4,5]和【4,7】比较，插到左儿子【4,5】

--[2,3]与【2,3】匹配，【2,3】记录+1；[4,5]与【4,5】匹配，【4,5】记录+1

[4,6]

--[4,6]与【0,7】比较，插到右儿子【4,7】

--[4,6]与【4,7】比较，分成两部分，[4,5]插到左儿子【4,5】；[6,6]插到右儿子【6,7】

--[4,5]与【4,5】匹配，【4,5】记录+1；[6,6]与【6,7】比较，插到左儿子【6,6】

--[6,6]与【6,6】匹配，【6,6】记录+1

[0,7]

--[0,7]与【0,7】匹配，【0,7】记录+1

插入过程结束，线段树上的记录如下（红色数字为每条线段的记录n）：

                      【0,7】
                                                    1
                               /                                            \
                     【0,3】                                           【4,7】
                         0                                                     0
                 /                 \                                     /                 \
       【0,1】                 【2,3】                【4,5】                【6,7】
            0                           1                          2                         0
          /    \                      /      \                     /     \                    /      \
【0,0】【1,1】【2,2】【3,3】【4,4】【5,5】【6,6】【7,7】

     0            0            0            0            0            0           1           0

询问操作和插入操作类似，也是递归过程，略

2——依次把【0,7】 【0,3】 【2,3】【2,2】的记录n加起来，结果为2

4——依次把【0,7】 【4,7】 【4,5】【4,4】的记录n加起来，结果为3

7——依次把【0,7】 【4,7】 【6,7】【7,7】的记录n加起来，结果为1

不管是插入操作还是查询操作，每次操作的执行次数仅为树的深度——logN

建树有n次插入操作，n*logN，一次查询要logN，m次就是m*logN；总共复杂度O(n+m)*logN，这道题N不超过30000，logN约等于14，所以计算量在10^5～10^6之间，比普通方法快了1000倍；


就先记录这么多，今后还会有补充。