【数据结构】线段树（区间树）

概述

线段树也称为“区间树”，它的适用场景也是很普遍的，关注的重点是“线段”，或者说是区间。非常经典的线段树题目是“区间染色”，搜搜看呗！

有的时候我们处理的数据的时候也需要进行区间的查询，比如说查询一个区间[i，j]的最大值，最小值，或者区间数字和。换成生活中的场景就是在2019年一年中，你的博客在什么时间段关注你的人增长最快啊，一天中自己的博文阅读量最高的时间段啊，某个星系中天体总量等等。这都可以是线段树的应用场景。

推荐两篇优秀的博文
一步一步理解线段树
线段树详解

线段树不是完全二叉树，但它是平衡二叉树，依然可以用数组表示。不要觉得惊讶，堆也是平衡二叉树的形式。

实现

数组的实现方式比较简单点，这里先采用数组的方式演示一下。

首先摆在我们面前的是，如果区间有n个元素的话，数组表示需要有多少节点？

想想满二叉树，最后一层的节点规律性是非常强的，

层数	节点数
0层	1
1层	2
2层	4
3层	8
…	…
n-1层	2的(n-1)次方

对满二叉树：n层，一共有2的n次方-1个节点（大约是2的n次方）

最后一层（n-1层），有2的（n-1）次方个节点
最后一层的节点数大致等于前面所有层节点之和

如果区间有n个元素，n的值是2的k次方的话 只需要2n的空间
n的值是2的k次方+1的话，这也是最坏的情况 需要4n的空间

区间的元素都是放在叶子节点的。
这部分一定要动笔画画 动动笔一下子就能明白

也就是4n的空间就能放下所有的元素了（不考虑添加元素），并且实际上我们的线段树还不一定是满二叉树的形式，这里为了方便当成满二叉树处理的，不是满二叉树的话浪费的空间会更多了，但是拿一些空间换时间也是值得的。

线段树的叶子节点的组合是要针对具体的业务场景的,所以这里创建一个接口 具体的实现还是看自己

public interface Merger<E> {
    E merge(E a, E b);
}

下面实现线段树的创建 区间查询 与更新

public class SegmentTree<E> {

    private E[] tree;  //线段树数组
    private E[] data;  //存放传入进来的数组的副本
    private Merger<E> merger;  //data --> tree


    //************************************************
    //初始化和创建线段树
    //************************************************
    //构造函数中的两个参数 一个是数组 一个是合并的方案
    public SegmentTree(E[] arr, Merger<E> merger){

        this.merger = merger;

        data = (E[])new Object[arr.length];
        for(int i = 0 ; i < arr.length ; i ++)
            data[i] = arr[i];

        tree = (E[])new Object[4 * arr.length];
        //三个参数，树根节点的索引 左右端点
        buildSegmentTree(0, 0, arr.length - 1);
    }

    // 在treeIndex的位置创建表示区间[left...right]的线段树
    private void buildSegmentTree(int treeIndex, int left, int right){

        if(left == right){
            tree[treeIndex] = data[left];
            return;
        }

        int leftTreeIndex = leftChild(treeIndex);  //获取左孩子的节点
        int rightTreeIndex = rightChild(treeIndex); //获取右孩子的节点

        // int mid = (left + right) / 2;
        int mid = left + (right - left) / 2;  //分支
        buildSegmentTree(leftTreeIndex, left, mid);
        buildSegmentTree(rightTreeIndex, mid + 1, right);

        //之所以用merge  是由具体的业务逻辑决定的 可以是加等 需要自己定义
        tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
    }

    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];
    }

    // 返回完全二叉树的数组表示中，一个索引所表示的元素的左孩子节点的索引
    private int leftChild(int index){
        return 2*index + 1;
    }

    // 返回完全二叉树的数组表示中，一个索引所表示的元素的右孩子节点的索引
    private int rightChild(int index){
        return 2*index + 2;
    }



    //************************************************
    //查询
    //************************************************

    // 返回区间[queryL, queryR]的值
    public E query(int queryL, int queryR){
        //做基本的边界检查
        if(queryL < 0 || queryL >= data.length ||
                queryR < 0 || queryR >= data.length || queryL > queryR)
            throw new IllegalArgumentException("Index is illegal.");

        return query(0, 0, data.length - 1, queryL, queryR);
    }


    // 在以treeIndex为根的线段树中[l...r]的范围里，搜索区间[queryL...queryR]的值
    private E query(int treeIndex, int left, int right, int queryL, int queryR){

        if(left == queryL && right == queryR)
            return tree[treeIndex];

        int mid = left + (right - left) / 2;
        // treeIndex的节点分为[l...mid]和[mid+1...r]两部分

        int leftTreeIndex = leftChild(treeIndex);
        int rightTreeIndex = rightChild(treeIndex);
        //简化递归 只递归一边
        if(queryL >= mid + 1)
            return query(rightTreeIndex, mid + 1, right, queryL, queryR);
        else if(queryR <= mid)
            return query(leftTreeIndex, left, mid, queryL, queryR);
        //当无法简化递归时 两边都要递归
        E leftResult = query(leftTreeIndex, left, mid, queryL, mid);
        E rightResult = query(rightTreeIndex, mid + 1, right, mid + 1, queryR);

        return merger.merge(leftResult, rightResult); //找到后 开始合并
    }

    //************************************************
    //更新
    //************************************************
    public void set(int index, E e){
        //做基本的检查
        if(index < 0 || index >= data.length)
            throw new IllegalArgumentException("Index is illegal");

        data[index] = e;
        set(0, 0, data.length - 1, index, e);
    }

    // 在以treeIndex为根的线段树中更新index的值为e
    private void set(int treeIndex, int left, int right, int index, E e){

        if(left == right){
            tree[treeIndex] = e;
            return;
        }

        int mid = left + (right - left) / 2;
        // treeIndex的节点分为[l...mid]和[mid+1...r]两部分

        int leftTreeIndex = leftChild(treeIndex);
        int rightTreeIndex = rightChild(treeIndex);
        if(index >= mid + 1)
            set(rightTreeIndex, mid + 1, right, index, e);
        else // index <= mid
            set(leftTreeIndex, left, mid, index, e);

        tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
    }

    //************************************************
    //打印输出
    //************************************************
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append('[');
        for(int i = 0 ; i < tree.length ; i ++){
            if(tree[i] != null)
                res.append(tree[i]);
            else
                res.append("null");

            if(i != tree.length - 1)
                res.append(", ");
        }
        res.append(']');
        return res.toString();
    }
}

线段树也可以扩展为二维线段树（矩阵）

还有动态线段树（采用链式），解决了空间的浪费，而且可以实现自定义左右分支的元素的数量。

区间操作相关还有另外一个重要数据结构–树状数组（Binary Index Tree），除此之外还有RMQ.等，有兴趣都可以搜搜呗！