线段树 java

public class SegmentTree {
    public static void main(String[] args) {
        SegmentTree tree = new SegmentTree(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9});
        System.out.println(tree.query(0, 2));
        tree.add(1, 2, 3);
        System.out.println(tree.query(0, 2));
        tree.add(1, 1, 9);
        System.out.println(tree.query(0, 2));
        tree.add(2, 8, 10);
        System.out.println(tree.query(0, 8));
    }

    private Node[] data;
    private int size;

    public SegmentTree(int[] source) {
        size = source.length;
        data = new Node[size * 4];
        build(0, 0, source.length - 1, source);
    }

    public void add(int l, int r, int value) {
        add(0, l, r, value);
    }

    public int query(int l, int r) {
        return query(0, l, r);
    }

    public int query(int v, int l, int r) {
        Node cur = data[v];
        if (cur.left == l && cur.right == r) {
            return cur.sum;
        }
        int mid = (cur.left + cur.right) / 2;
        if (r <= mid) {
            return query(v * 2 + 1, l, r);
        } else {
            if (l > mid) {
                return query(v * 2 + 2, l, r);
            }
            return query(v * 2 + 1, l, mid) +
                    query(v * 2 + 2, mid + 1, r);
        }
    }

    public void add(int v, int l, int r, int value) {
        Node cur = data[v];
        if (cur.left == l && cur.right == r) {
            cur.add += value;
            cur.sum += value * (cur.right - cur.left + 1);
            return;
        }
        if (cur.add > 0) {
            data[v * 2 + 1].add += cur.add;
            data[v * 2 + 2].add += cur.add;
        }
        cur.add = 0;
        int mid = (cur.left + cur.right) / 2;
        if (l > mid) {
            add(v * 2 + 2, l, r, value);
        } else {
            if (r <= mid) {
                add(v * 2 + 1, l, r, value);
            } else {
                add(v * 2 + 1, l, mid, value);
                add(v * 2 + 2, mid + 1, r, value);
            }
        }
        cur.sum = data[v * 2 + 1].sum + data[v * 2 + 2].sum;
    }

    private void build(int v, int l, int r, int[] source) {
        if (l == r) {
            Node n = new Node();
            n.left = l;
            n.right = l;
            n.data = source[l];
            n.sum = n.data;
            data[v] = n;
            return;
        }
        int mid = (l + r) / 2;
        int left = getLeftChild(v);
        int right = getRightChild(v);
        build(left, l, mid, source);
        build(right, mid + 1, r, source);
        data[v] = new Node();
        data[v].left = l;
        data[v].right = r;
        data[v].sum = data[left].sum + data[right].sum;
    }

    private int getLeftChild(int v) {
        return v * 2 + 1;
    }

    private int getRightChild(int v) {
        return v * 2 + 2;
    }

    public static class Node {
        private int data;
        private int left;
        private int right;
        private int add;
        private int sum;
    }
}