线段树介绍与实现

线段树

线段树不一定是满二叉树，也不一定为完全二叉树

满二叉树

除了叶子节点，每个节点都有左右两个子树

完全二叉树

不一定是满二叉树，但他不满的那部分一定位于整个树的右下方

# 所以将线段树没满的那部分看成空，凑成满二叉树，这样就可以用堆的方式计算得到索引，这样在数组中就能对线段树进行操作

一定是平衡二叉树（任意节点左右子树高度差不超过一），堆也是平衡二叉树

经典问题：区间染色 ， 区间查询

区间固定，里面元素需要更新和查询

以求和操作为例，线段树中每个节点存的都是一个区间的元素和，从上到下不断细分

实现

/**
 * @author gwj
 * 自定义融合器
 */
public interface Merger<E> {

    public E merge(E a,E b);
}

/**
 * @author gwj
 * 线段树
 */
public class SegmentTree<E> {
    private E[] data;
    private E[] tree;
    private Merger<E> merger;
    
    /**
     * 让用户自定义线段树节点的融合方式
     */
    public SegmentTree(E[] arr,Merger<E> merger) {
        this.merger = merger;
        data = arr;
        //需要给线段树中看成空（没满的）的那部分留足空间
        tree = (E[])new Object[4 * arr.length];
        buildSegmentTree(0,0,arr.length - 1);
    }

    private void buildSegmentTree(int treeIndex, int start, int end) {
        if (start == end) {
            //只有一个元素
            tree[treeIndex] = data[start];
            return;
        }

        int left = left(treeIndex);
        int right = right(treeIndex);
        int mid = start + (end - start) / 2;
        buildSegmentTree(left,start,mid);
        buildSegmentTree(right,mid + 1,end);

        //按照指定方式融合
        tree[treeIndex] = merger.merge(tree[left], tree[right]);

    }

    public int getSize() {
        return data.length;
    }

    public E get(int index) {
        if (index < 0 || index >= data.length) {
            throw new IllegalArgumentException("index is illegal");
        }
        return data[index];
    }

    public E query(int leftRange,int rightRange) {
        if (leftRange < 0 || leftRange >= data.length || rightRange < 0 || rightRange >= data.length) {
            throw new IllegalArgumentException("index is illegal");
        }

        return query(0,0,data.length - 1, leftRange,rightRange);
    }

    /**
     * 在以treeIndex索引为根节点的索引范围在[l,r]的区间中查找[leftRange,rightRange]区间
     */
    private E query(int treeIndex,int l,int r,int leftRange,int rightRange) {
        //两者刚好重合时
        if (l == leftRange && r == rightRange) {
            return tree[treeIndex];
        }

        //不重合，在左右子区间寻找
        int mid = (l + r) / 2;
        int left = left(treeIndex);
        int right = right(treeIndex);

        if (leftRange >= mid + 1) {
            return query(right,mid + 1,r,leftRange,rightRange);
        }else if (rightRange <= mid) {
            return query(left,l,mid,leftRange,rightRange);
        }

        //跨越了左右区间
        //将要找的区间分成两部分，分别在左右区间寻找，最后融合
        E queryLeft = query(left, l, mid, leftRange, mid);
        E queryRight = query(right, mid + 1, r, mid + 1, rightRange);
        return merger.merge(queryLeft,queryRight);

    }

    private int parent(int index) {
        if (index == 0) {
            throw new IllegalArgumentException("无父元素");
        }
        return (index - 1) / 2;
    }

    private int left(int index) {
        return 2 * index + 1;
    }

    private int right(int index) {
        return 2 * index + 2;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < tree.length; i++) {
            sb.append(" ").append(tree[i]);
        }
        sb.append("]");
        return sb.toString();
    }
    
}