线段树初探

一.基础准备

 
        自己发现：n个点的话，共n-1个非叶子节点，不过没证明过，直接看图。

        线段树，也叫区间树（有人说实际不一样），是一个完全二叉树，它在各个节点保存一条线段，因而常用于解决数列维护问题，树的根节点表示是“整体”的区间，左右子树分别表示这个区间的左半边和右半边。

        线段树是一个满二叉树，假设共n个节点，区间为[0,n-1]，那么共2*n-1个节点，深度log(2*n-1)，即O(logn)，这基本上述所有操作的复杂度。

        线段树缺点：数列中的数不能添加或者删除。

        查询的时候为什么也需要hidden(root)操作？看区间修改，估计是因为当用户修改一个区间的值时，如果连同其子孙全部修改，则改动的节点数必定会远远超过O(log n)个。因而，如果要想把区间修改操作也控制在O(log n)的时间内，只修改O(log n)个节点的信息就成为必要。然后如果要用到区间的子区间的时候，我们才去真正更新！

        hidden(root)里为什么不更新id本身和？因为add函数最后一行已经更新。 

        hidden函数里st.node[root<<1].delta += st.node[root].delta为什么连加呢？因为可能上次查询没执行到改点，而且由于更新并未更新子节点，所以连加。

        以上总结纯属个人观点，如有错误，还请指正。

二.Java实现

        以POJ3468为例，直接那我的代码去AC吧。

  1: /*
  2:  * 1.我知道错误在哪啦，节点编号不能从0开始，否则左子树编号始终是0
  3:  * 2.root<<1 +1 前面必须加括号，通过打印节点发现全是2的幂
  4:  * 3.增量必须是long，否则wa
  5:  */
  6: import java.io.InputStreamReader;
  7: import java.util.Scanner;
  8: 
  9: /*
 10:  * n个点的话，共n-1个非叶子节点,
 11:  * 我认为这个很重要，
 12:  */
 13: public class Main {
 14: 
 15:   static int N = 400000;
 16:   static Node node[] = new Node[N];
 17:   
 18:   public static void main(String[] args) {
 19:     //必须放在main内
 20:     for(int i=0; i<N; i++) {
 21:       node[i] = new Node();
 22:     }
 23:     new ST().go();
 24:   }
 25: }
 26: 
 27: class Node {
 28:   int left;
 29:   int right;
 30:   long sum;
 31:   long delta;
 32:   
 33:   public Node() {
 34:     this.delta = 0;
 35:     this.sum = 0;
 36:   }
 37: }
 38: 
 39: class ST {
 40:   String str;//判断是询问还是增加
 41:   int a,b,c;
 42:   long ans = -1;
 43:   Scanner sc = new Scanner(new InputStreamReader(System.in));
 44:   int n,m;//n个数据，m次询问
 45:   int array[];
 46:   Main st = new Main();//为了用node数组
 47:   
 48:   public void go() {
 49:     n = sc.nextInt();
 50:     m = sc.nextInt();
 51:     array = new int[n+1];
 52:     for(int i=1; i<n+1; i++) {
 53:       array[i] = sc.nextInt();
 54:     }
 55:     buildTree(1,array,1,n);
 56:     //printTree(1);
 57:     for(int i=0; i<m; i++) {
 58:       str = sc.next();
 59:       a = sc.nextInt();
 60:       b = sc.nextInt();
 61:       
 62:       if(str.equals("Q")) {
 63:         ans = query(1,a,b);
 64:         System.out.println(ans);
 65:       }else {
 66:         c = sc.nextInt();
 67:         //System.out.println(a+" "+b+" "+c);
 68:         add(1,a,b,c);
 69:       }
 70:     }
 71:   }
 72: 
 73:   private void buildTree(int root, int[] array,int left,int right) {
 74:     st.node[root].left = left;
 75:     st.node[root].right = right;
 76:     if(left==right) {
 77:       st.node[root].sum = array[left];
 78:       st.node[root].delta = 0;
 79:       return ;
 80:     }
 81:     int mid = (left+right)>>1;
 82:     //注意：中值在左子树
 83:     buildTree(root<<1, array, left, mid);
 84:     buildTree((root<<1)+1, array, mid+1, right);
 85:     //下面这句别忘了，就是更新父节点的值,注意不是连加
 86:     st.node[root].sum = st.node[root<<1].sum + st.node[(root<<1)+1].sum;
 87:   }
 88: 
 89:   private long query(int root, int a, int b) {
 90:     /*
 91:      * n个点的话，共n-1个非叶子节点,所以传过来的
 92:      * 范围可直接与节点编号比较
 93:      * 笔者认为理解这点很重要
 94:      */
 95:     //System.out.println(root);
 96:     if(st.node[root].left==a&&st.node[root].right==b) {
 97:       return st.node[root].sum;
 98:     }
 99:     hidden(root);
100:     int mid = (st.node[root].left+st.node[root].right)>>1;
101:     if(b<=mid) {//有等号,因为建树时mid在左子树
102:       return query(root<<1, a, b);
103:     }else if(a>mid) {
104:       return query((root<<1)+1, a, b);
105:     }else {
106:       return query(root<<1, a, mid) + query((root<<1)+1, mid+1, b);
107:     }
108:   }
109: 
110:   //将更新标记传递至子节点
111:   private void hidden(int root) {
112:     if(st.node[root].delta!=0) {
113:       st.node[root<<1].delta += st.node[root].delta;
114:       st.node[root<<1].sum += st.node[root].delta
115:           *(st.node[root<<1].right - st.node[root<<1].left + 1);
116:       st.node[(root<<1)+1].delta += st.node[root].delta;
117:       st.node[(root<<1)+1].sum += st.node[root].delta
118:           *(st.node[(root<<1)+1].right - st.node[(root<<1)+1].left + 1);
119:       //别忘了加上，否则栈溢出
120:       st.node[root].delta = 0;
121:     }
122:   }
123:   private void printTree(int i) {
124:     if (st.node[i].left != 0) {
125:       printTree(2 * i);
126:       System.out.print(i+":"+"[" + st.node[i].left + "," + st.node[i].right + "] ");
127:       printTree(2 * i + 1);
128:     }
129:   }
130:   private void add(int root, int a, int b, int c) {
131:     if (st.node[root].left == a && st.node[root].right == b) {// 找到操作区间了
132:       st.node[root].delta += c; // 标记
133:       st.node[root].sum += c * (b - a + 1);
134:       return;
135:     }
136:     hidden(root);
137:     int mid = (st.node[root].left + st.node[root].right)>>1;
138:     if (b <= mid) {
139:       add(root * 2, a, b, c);
140:     } else if (a > mid) {
141:       add(root * 2 + 1, a, b, c);
142:     } else {
143:       add(root * 2, a, mid, c);
144:       add(root * 2 + 1, mid + 1, b, c);
145:     }
146:     st.node[root].sum = st.node[root * 2].sum + st.node[2 * root + 1].sum;// 更新父节点
147:   }
148: }