递归专项-数据结构-线段树

线段树

比如我们有一个大小为6的数组，其索引为0，1，2，3，4，5，那么我们就可以构建出如下的一颗线段树，下图所示：

考虑到一棵完全二叉树，假设右k层，则其总数为2^0 + 2 ^1 +… + 2 ^k
= 2^(k + 1) - 1,
所以针对一棵线段树，其最好情况下是一棵满二叉树，这时候线段是的大小为2 * n即可，但是往往由于数据因素可能会变成一课完全二叉树，而不是恰好就是满二叉树，这时候如果需要涵盖所有的数据，就需要开辟2 * （2 * n) 才行【即多开一层空间】

所以根据上面的阐述，假设我们有一个数组data[n], 那么开辟的tree数组大小就是4n。构造函数如下：

private E[] tree;
    private E[] data;
    private Merger<E> merger;

    public SegmentTree(E[] value, Merger<E> merger) {
        this.data = (E[])new Object[value.length];

        for (int i = 0; i < value.length; i++) {
            data[i] = value[i];
        }

        this.tree = (E[])new Object[4 * value.length];
        this.merger = merger;

        buildSegmentTree(0,0,this.data.length - 1);

    }

首先我们可以通过递归方式插入数据：针对每一个区间，都为分裂成两个区块，直到不可分裂为止（递归终止条件是单独的index成为区块）

/**
     *
     * @param index: 该段的索引
     * @param left： 线段树的左段，对应data 里面的索引
     * @param right： 线段树的右段，对应data 里面的索引
     * @return: 该段存储的值
     */
    public E buildSegmentTree(int index, int left, int right) {
        if  (left == right) {
            tree[index] = data[left];
            return tree[index];
        }
        int mid = left + (right-left) / 2;

        // 分裂成2个段
        // 左段
        E leftValue = buildSegmentTree(2 * index + 1, left, mid);
        // 右段
        E rightValue =buildSegmentTree(2 * index + 2, mid + 1, right);

        // 聚合左段和右段的值
        tree[index] = this.merger.merge(leftValue, rightValue);

        return tree[index];
    }
    

根据区间查询结果值：本质上还是查query的范围对应线段树的哪些区间组合。

public E queryByRange(int index, int treeL, int treeR, int left, int right) {

        if (left == treeL && right == treeR) {
            return tree[index];
        }
        int mid = treeL + (treeR - treeL) / 2;
        if (right <= mid) {
            return queryByRange(2 * index + 1, treeL, mid, left, right);
        }
        if (left >= mid + 1) {
            return queryByRange(2 * index + 2, mid + 1, treeR, left, right);
        }

        // 即在左边又在右边
        return merger.merge(queryByRange(2 * index + 1, treeL, mid, left, mid) , queryByRange(2 * index + 2,mid + 1, treeR, mid + 1, right));
    }
    

更新原始数组索引的值:

public void update(int index, E e) {

        updateDg(0, 0, data.length - 1, index , e);
    }

    private void updateDg(int treeIndex, int l, int r, int dataIndex, E e) {

        if (l == r) {
            tree[treeIndex] = e;
            return;
        }

        int mid = l + (r - l) / 2;

        if (dataIndex > mid) {
            updateDg(2 * treeIndex + 2, mid + 1, r, dataIndex, e);
        } else {
            updateDg(2 * treeIndex + 1, l, mid, dataIndex, e);
        }
        tree[treeIndex] = merger.merge(tree[2 * treeIndex + 1], tree[2 * treeIndex + 2]);
    }

线段树比较适合针对一批数组，需要频繁得出查询范围区间的值得情况。其与数组之间的对比如下：

其完整代码如下：

package data.structure.segmenttree;

import com.google.common.base.Preconditions;

public class SegmentTree <E> {
    private E[] tree;
    private E[] data;
    private Merger<E> merger;

    public SegmentTree(E[] value, Merger<E> merger) {
        this.data = (E[])new Object[value.length];

        for (int i = 0; i < value.length; i++) {
            data[i] = value[i];
        }

        this.tree = (E[])new Object[4 * value.length];
        this.merger = merger;

        buildSegmentTree(0,0,this.data.length - 1);

    }


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

    public E get(int index) {
        Preconditions.checkArgument(index >= 0 && index < data.length, "index not valid");
        return data[index];
    }


    /**
     *
     * @param index: 该段的索引
     * @param left： 线段树的左段，对应data 里面的索引
     * @param right： 线段树的右段，对应data 里面的索引
     * @return: 该段存储的值
     */
    public E buildSegmentTree(int index, int left, int right) {
        if  (left == right) {
            tree[index] = data[left];
            return tree[index];
        }
        int mid = left + (right-left) / 2;

        // 分裂成2个段
        // 左段
        E leftValue = buildSegmentTree(2 * index + 1, left, mid);
        // 右段
        E rightValue =buildSegmentTree(2 * index + 2, mid + 1, right);

        // 聚合左段和右段的值
        tree[index] = this.merger.merge(leftValue, rightValue);

        return tree[index];
    }



    public E queryByRange(int index, int treeL, int treeR, int left, int right) {

        if (left == treeL && right == treeR) {
            return tree[index];
        }
        int mid = treeL + (treeR - treeL) / 2;
        if (right <= mid) {
            return queryByRange(2 * index + 1, treeL, mid, left, right);
        }
        if (left >= mid + 1) {
            return queryByRange(2 * index + 2, mid + 1, treeR, left, right);
        }

        // 即在左边又在右边
        return merger.merge(queryByRange(2 * index + 1, treeL, mid, left, mid) , queryByRange(2 * index + 2,mid + 1, treeR, mid + 1, right));
    }



    public void update(int index, E e) {

        updateDg(0, 0, data.length - 1, index , e);
    }

    private void updateDg(int treeIndex, int l, int r, int dataIndex, E e) {

        if (l == r) {
            tree[treeIndex] = e;
            return;
        }

        int mid = l + (r - l) / 2;

        if (dataIndex > mid) {
            updateDg(2 * treeIndex + 2, mid + 1, r, dataIndex, e);
        } else {
            updateDg(2 * treeIndex + 1, l, mid, dataIndex, e);
        }
        tree[treeIndex] = merger.merge(tree[2 * treeIndex + 1], tree[2 * treeIndex + 2]);
    }


    public void display(int index) {


        if (index > tree.length - 1) {
            return;
        }

        System.out.println(tree[index]);
        display(2 * index  + 1);
        display(2 * index + 2);


    }
    public static void main(String[] args) {
        SegmentTree<Integer> segmentTree = new SegmentTree<>(new Integer[]{1,2,3,4,5}, Integer::sum);

        segmentTree.display(0);

        Integer integer = segmentTree.queryByRange(0, 0, segmentTree.getSize() - 1, 1, 3);

        System.out.println("range 1:3 sum = " + integer);

        segmentTree.update(2, 10);
        integer = segmentTree.queryByRange(0, 0, segmentTree.getSize() - 1, 1, 3);

        System.out.println("range 1:3 sum = " + integer);



    }
}