Java数据结构-线段树的实现理解与分析

线段树，也称区间树，主要在解决区间问题时设计的数据结构。
二话不说，先上图

先思考一下占用内存的问题。图中一共有8个元素，在第三层中的元素就占用了8个内存空间，第0层到第2层一共占用了7个内存空间，这是元素是2的k次方，是最优的情况，最后一层正好占满，这样如果有n个元素的话，只要分配给2n个内存空间就足够了。
如果元素是2的k次+1，则最后一层只有一个元素，但也要分配，这样最后一层一个元素，倒数第二层的元素个数大约为n，倒数第三层以前的元素大约也为n，则最后一层元素个数约为倒数第二层以前的元素个数总和，即最后一层需分配2n个内存空间，虽然只有一个元素，这样就需要分配4n个内存空间，所以也意味着给数组分配4n个内存空间肯定有富余。

构造线段树：
构造函数：
在线段树中定义了两个数组，第一个data[]数组用来存储初始化线段树的数组。第二个tree[]数组用来模拟线段树数据结构所用的数组。
merger是一个接口，用来自定义融合两个元素的规则，比如，父节点仅仅是简单的把左右孩子相加，或者取左右孩子中的最大值或最小值，这里的融合可以自定义于对象间任意的合并规则。
构建线段树的方法：
线段树中除了叶子结点，其他结点都代表一个区间，线段树是一个很典型的后序遍历的例子，在构建线段树时，需要先构建其左右孩子，再构建第0层[0…7]时需要先构建第一层的两个结点，所以在构建线段树时需要进行递归，叶子结点是递归的终止条件。同时本次实现是使用数组来实现的。
构建线段树的方法buildSegmentTree(int treeIndex,int l,int r)

复述一遍递归的构建线段树的过程。首先在构造方法中调用构建线段树的方法，因为根节点在数组中的索引为0，需要的三个传入参数分别为，结点索引值，区间左边界的索引和右边界的索引值。所以调用时传入的参数分别为(0,0,data.length-1)。因为构建父节点时必须先构建其左右孩子，通过方法leftChild()和rightChild()计算出左孩子和右孩子所在数组位置的索引值，然后把区间从中间分开，成为两个区间[left,mid]和[mid+1,right]，通过这两个区间的边界值和左右孩子的索引值递归构建左右孩子。构建好左右孩子之后通过merger.merge()方法融合两个节点值作为父节点的值。
融合某个区间的值：
首先，规定要融合的区间称为查询区间，节点的区间称为分开区间。

此方法为融合区间的调用方法，供其他方法调用的方法。此方法调用融合区间方法的递归方法。

首先传入的参数(0,0,data.length-1,queryL,queryR)分别代表节点索引值，因为根节点的索引值为0，所以传入0，第二个是根节点的分开区间的左值，第三个是分开区间的右值，第四个是查询区间的左值，第五个是查询区间的右值。
进入递归方法后，先判断查询区间和分开区间是否一致，如果一致的话直接返回此结点的值。
接着进行计算分开区间中间值，之后判断查询区间是否完全在分开区间的左右两个区间中，例如，查询区间只在左区间，那直接进行调用左区间就好了。
如果查询区间不完全在分开的某个区间，则把查询区间分开进行计算，计算得到的值在最后进行融合。
修改数组中的某个值：
供外调的方法

在外调方法中，先修改数组的值，然后调用修改线段树的递归函数。

修改元素值和查询类似。
查询，修改元素值的算法复杂度都为O(logn)。

/**
 * @Author: Cui
 * @Date: 2020/12/24
 * @Description: 线段树
 */
public class SegmentTree<E> {
    private E[] data;           //用来存储初始化线段树的数组
    private E[] tree;           //存储线段树的数组
    private Merger<E> merger;   //用来定义融合两个元素的规则
    public SegmentTree(E[] es,Merger<E> merger){
        this.merger = merger;
        data = (E[])new Object[es.length];
        for(int i=0;i< es.length;i++){
            data[i] = es[i];
        }
        tree = (E[])new Object[4* es.length];
        buildSegmentTree(0,0, data.length-1);
    }

    //在treeIndex的位置创建表示区间[l...r]的线段树
    private void buildSegmentTree(int treeIndex,int l,int r){
        if(l == r){                                 //如果区间的左右值相等，则意味着区间中只有
            tree[treeIndex] = data[l];              //一个元素，意味着这个结点为叶子节点
            return;
        }
        int leftTreeIndex = leftChild(treeIndex);   //计算左孩子所在数组中的索引
        int rightTreeIndex = rightChild(treeIndex); //计算右孩子所在数组中的索引
        int mid = l + (r-l)/2;                      //计算区间的中间节点
        buildSegmentTree(leftTreeIndex,l,mid);      //构建其左孩子利用中间节点分开之后的左区间
        buildSegmentTree(rightTreeIndex,mid+1,r); //构建其右孩子利用右区间
        //tree[treeIndex] = tree[leftTreeIndex] + tree[rightTreeIndex];
        //融合左右孩子的值作为本节点的值
        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);
    }

    //在以treeID为根的线段树中[l...r]的范围里，搜索区间[queryL,queryR]的值
    private E query(int treeIndex,int l,int r,int queryL,int queryR){
        if(l == queryL && r == queryR)          //如果此次递归时左右区间正好是要计算的区间的，
            return tree[treeIndex];             //则之间返回此结点值
        int mid = l + (r - l) / 2;
        // treeIndex的节点分为[l...mid]和[mid+1...r]两部分

        int leftTreeIndex = leftChild(treeIndex);
        int rightTreeIndex = rightChild(treeIndex);
        if(queryL >= mid + 1)//如果把此结点的左右区间分开后，
                            // 查询的区间在分开两个区间的右区间，直接进入查询右孩子
            return query(rightTreeIndex, mid + 1, r, queryL, queryR);
        else if(queryR <= mid)//如果此结点的查询区间的最大值小于分开区间的中间值
                            //直接进入查询左孩子
            return query(leftTreeIndex, l, mid, queryL, queryR);
        //查询区间覆盖分开区间的左右区间，则分开进行查找，最后将查找结果融合
        E leftResult = query(leftTreeIndex,l,mid,queryL,mid);
        E rightResult = query(rightTreeIndex,mid+1, r, 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);
    }

    //修改数组的某个值，递归调用的方法
    private void set(int treeIndex,int l,int r,int index,E e){
        if(l == r){
            tree[treeIndex] = e;
            return;
        }
        int mid = l + (r-l)/2;
        int leftTreeIndex = leftChild(treeIndex);
        int rightTreeIndex = rightChild(treeIndex);
        if(index >= mid+1){
            set(rightTreeIndex,mid+1,r,index,e);
        }else {
            set(leftTreeIndex,l,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();
    }
}

merger接口

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

主函数测试方法：

public class Main {
    public static void main(String[] args) {
        Integer[] nums = {-2,0,3,-5,2,-1};
        SegmentTree<Integer> segmentTree = new SegmentTree<>(nums, (a,b)->a+b);
        System.out.println(segmentTree.query(0,4));
    }
}

读者可以做一下LeetCode上的第303号题和307号题，如果使用普通数组的话，得到的时间复杂度可能是O(logn)，而使用线段树的话，查询和修改复杂度都为O(logn)，特别是307号问题。
在此给大家分享一个我学习数据结构的视频，有些我没有讲清楚大家有兴趣可以自己听课。是由某课网上的精英讲师liuyubobobo老师讲授的。我之后会在一些文章下面持续分享一些资源，大家关注不迷路。记得点赞！

获取资源
提取码：6d6d