力扣LeetCode，区域和检索

1、给定一个整数数组  nums，求出数组从索引 i 到 j  (i ≤ j) 范围内元素的总和，包含 i,  j 两点。

update(i, val) 函数可以通过将下标为 i 的数值更新为 val，从而对数列进行修改。

示例:

Given nums = [1, 3, 5]

sumRange(0, 2) -> 9
update(1, 2)
sumRange(0, 2) -> 8

说明:

a）、数组仅可以在 update 函数下进行修改。

b）、你可以假设 update 函数与 sumRange 函数的调用次数是均匀分布的。

---

2、如果使用线段树解决这个问题的话，需要先将融合器创建好，方便自己实现自己求和或者最大值或者最小值，等等需求。

package com.tree;

/**
 * 融合器,可以处理任意类型
 *
 * @param <E>
 */
public interface Merger<E> {

    /**
     * 就是将两个元素a,b转换成一个元素E
     *
     * @param a
     * @param b
     * @return
     */
    E merger(E a, E b);
}

可以实现创建自己的线段树的功能。

package com.tree;


/**
 * 线段树
 */
public class SegmentTree<E> {

    // 对于区间的每一个元素,有可能需要通过线段树来进行获取
    private E[] data;

    private E[] tree;// 这里面的变量tree,是用于将数组转换为二叉树的,看作是满二叉树.

    private Merger<E> merger;//融合器


    /**
     * 含参构造函数
     *
     * @param arr    要考察的整个区间的范围.
     * @param merger 融合器
     */
    public SegmentTree(E[] arr, Merger<E> merger) {

        this.merger = merger;

        // 通过创建Object的方式来创建E类型的数组
        data = (E[]) new Object[arr.length];
        // 循环遍历,将数组元素的值赋值给创建的数组
        for (int i = 0; i < arr.length; i++) {
            data[i] = arr[i];
        }

        // 此时,也要初始化一个线段树,数组长度是4倍的数组的大小,就可以存储所有的节点
        tree = (E[]) new Object[4 * arr.length];

        // 创建线段树,初始的时候根几点所对应的索引为0,
        // 初始的时候根节点即0索引位置的节点的左端点是0,右断点是尾部
        // 初始的时候根节点对应的区间就是我们data这个数组从头到尾,从最左端到最右端.
        buildSegmentTree(0, 0, arr.length - 1);
    }

    /**
     * 创建线段树,在treeIndex的位置创建表示区间[left...right]的线段树
     *
     * @param treeIndex 当前要创建的这个线段树的根节点所对应的索引
     * @param left      对于这个节点它所表示的那个线段或者区间的左右断点是什么,
     * @param right
     */
    private void buildSegmentTree(int treeIndex, int left, int right) {
        // 首先,考虑递归到底的情况
        // 如果区间长度为1的时候,只有一个元素,就是递归到底了
        if (left == right) {
            // 此时tree[treeIndex]线段树节点存储的就是元素的本身data[left]
            tree[treeIndex] = data[left];
            // tree[treeIndex] = data[right];
            return;
        }

        // 递归的第二部分
        // 如果此时left不等于right的时候,此时,left一定是小于right的,要表示的是一个区间的话
        // 首先要计算出表示一个区间的节点,这个节点一定会有左右孩子的.
        // 左孩子所对应的在线段树中的索引是leftTreeIndex
        int leftTreeIndex = this.leftChild(treeIndex);
        // 右孩子所对应的在线段树中的索引是rightTreeIndex
        int rightTreeIndex = this.rightChild(treeIndex);

        // 此时,要创建好这个节点的左右子树,对于创建这个节点的左右子树,我们已经知道了左右子树所对应的在数组中的
        // 那个索引,还需要知道对于这个左右子树来说,它相应的表示的区间范围,

        // 区间范围的计算
//        int mid = (left + right) / 2;// 避免整形溢出
        int mid = left + (right - left) / 2;// 左边界,加上左右边界之间的距离除以2,得到的位置也是中间的位置.
        // 比如1-5, 1  2  3  4  5中间元素是3,那么就是1 + (5 - 1) /2 = 3.

        // 此时,有了中间位置之后,那么对于当前的treeIndex所在的这个节点,他表示从left到right这个区间
        // 它的左右子树表示的是什么区间呢,其实就是left 到 mid,mid + 1 到right.
        // 基于这两个区间再创建线段树,这是一个递归的过程
        // 创建左子树,从leftTreeIndex这个索引上创建从left 到 mid这个区间对应的线段树
        buildSegmentTree(leftTreeIndex, left, mid);
        // 创建右子树从rightTreeIndex这个索引上创建从mid + 1 到 right这个区间对应的线段树
        buildSegmentTree(rightTreeIndex, mid + 1, right);

        // 此时将treeIndex的左右子树创建好,最后在创建好两个子树之后
        // 此时考虑tree[treeIndex]的值应该是多少,是和业务有关系的,这里是求和
        // 这里的信息综合左右两个线段相应的信息来得到当前的这个更大的这个线段相应的信息.
        // 怎么综合是根据业务逻辑决定的.
        // 由于此时类型E不一定定义了加法,只能做加法还是减法还是求出最大值还是最小值等等.
        // 所以此时新增了融合器的功能,使用融合器进行操作
        tree[treeIndex] = merger.merger(tree[leftTreeIndex], tree[rightTreeIndex]);
        // 此时,递归创建线段树就完成了
    }


    /**
     * 获取指定索引的元素内容
     *
     * @param index
     * @return
     */
    public E get(int index) {
        if (index < 0 || index >= data.length) {
            throw new IllegalArgumentException("Index is illegal.");
        }
        return data[index];
    }

    /**
     * 关注的线段树区间一共有多少个元素
     *
     * @return
     */
    public int getSize() {
        return data.length;
    }


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

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

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append('[');
        for (int i = 0; i < tree.length; i++) {
            if (tree[i] != null) {
                stringBuilder.append(tree[i]);
            } else {
                stringBuilder.append("null");
            }

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

    /**
     * 返回区间[queryLeft,queryRight]的值
     *
     * @param queryLeft  前闭区间，用户期望查询的区间左右两个边界
     * @param queryRight 后闭区间
     * @return
     */
    public E query(int queryLeft, int queryRight) {
        // 进行边界检查
        if (queryLeft < 0 || queryLeft >= data.length || queryRight < 0 || queryRight >= data.length || queryLeft > queryRight) {
            throw new IllegalArgumentException("Index is illegal.");
        }

        // 递归函数调用。根节点的索引是0，区间是从0开始，到data.lenght-1这个范围里面
        // 还需要查询一个区间，这个区间是queryLeft到queryRight
        return query(0, 0, data.length - 1, queryLeft, queryRight);
    }


    /**
     * 在以treeId为根的线段树中[l...r]的范围里面，搜索区间[queryLeft...queryRight]的值
     * <p>
     * <p>
     * 从线段树的根节点开始，根节点所在的索引treeIndex
     * 相应的节点表示的是一个区间，节点表示的区间用left、right表示。
     *
     * @param treeIndex
     * @param left      节点所表示的区间左边界left
     * @param right     节点所表示的区间右边界left
     * @return
     */
    private E query(int treeIndex, int left, int right, int queryLeft, int queryRight) {
        // 需要注意的是我们做的线段树相关的操作，对于每一个treeIndex都传了对于这个treeIndex所在的节点
        // 它所表示的区间范围是哪里left-right，对于这个区间范围，其实也可以包装成一个线段树中的一个节点类。
        // 对于每一个节点存储它所对应的区间范围left-right，在这种情况下，直接传入treeIndex就行了，
        // 通过这个索引就可以访问到这个节点，进而就可以访问到这个节点所表示的区间范围。


        // 此处实现的方法是，在treeIndex所表示的这个区间范围，以参数的形式进行传递。
        // int treeIndex, int left, int right三个参数都在表示当前的节点表示的相应的信息，
        // 在这个节点中去查询queryLeft到queryRight这个用户关心区间。


        // 递归的第一部分，终止条件，递归到底的情况
        // 如果这个节点的左边界left和用户想要查询的左边界queryLeft、同时这个节点的有边界right和用户想要查询的有边界queryRight
        // 重合的时候，就是递归到底的情况，这个节点的信息就是用户想要的信息。
        if (left == queryLeft && right == queryRight) {
            // 如果是的话，直接返回
            return tree[treeIndex];
        }

        // 递归的第二部分
        // 计算中间的位置，此时，要继续到当前的这个节点的孩子节点去查找
        int mid = left + (right - left) / 2;
        // 到底是去到左孩子查找还是右孩子查找呢，还是两个孩子都要找一找呢，
        // 首先计算左右两个孩子所对应的索引
        int leftTreeChild = this.leftChild(treeIndex);
        int rightTreeChild = this.rightChild(treeIndex);

        // 如果用户查询的左边界区间大于等于中间的位置即mid + 1，
        // 对于当前的这个节点它将left-right这个范围分成了两个部分，两部分的中间是mid，
        // 第一部分是left-mid，第二部分是mid-right。
        // 如果用户关心的区间的左边界是大于等于中间的位置即mid + 1的话，
        // 也就是用户关心的这个区间和这个节点的左孩子一点关系都没有的时候，左边这部分完全可以忽略了，
        if (queryLeft >= mid + 1) {
            // 此时去mid-right这个区间去查找queryLeft-queryRight这个区间的相应的结果。
            return query(rightTreeChild, mid + 1, right, queryLeft, queryRight);
        } else if (queryRight <= mid) {
            // 用户关心的右边界小于中间的位置mid。把当前这个节点的区间一分为二，得到的这个mid中间位置。
            // 此时，用户关心的这个区间和当前这个节点一分为二，和右边这一半，后半部分一点关系都没有的。
            return query(leftTreeChild, left, mid, queryLeft, queryRight);
        }

        // 如果，这两种情况都不是的话，意味着用户关注的区间queryLeft-queryRight既没有落到当前节点treeIndex
        // 这个节点的左孩子所代表的那个节点，也没有完全落在右孩子所代表的那个节点中，
        // 事实上，它有一部分落在左孩子那边，另外一部分落在右孩子那边。
        // 在这种情况下，两边都需要查询一下。

        // 先去左孩子那边去查找，此时将queryLeft-queryRight这个区间拆分成了queryLeft-mid和
        // mid + 1到queryRight这两个区间了。
        // 此时，查找的queryLeft到mid的结果，存储到queryResult中。
        E leftResult = query(leftTreeChild, left, mid, queryLeft, mid);
        E rightResult = query(rightTreeChild, mid + 1, right, mid + 1, queryRight);

        // 如果用户关系的这部分区间有一部分在左节点，有另外一部分在右节点，此时，左右两边都需要进行查询。
        // 查询完成以后就可以进行融合了。调用融合器进行融合。
        return merger.merger(leftResult, rightResult);
    }


    /**
     * 对线段树进行更新操作。
     *
     * <p>
     * 将index位置的值，更新为e
     *
     * @param index
     * @param e
     */
    public void set(int index, E e) {
        // 对index合法性进行检测
        if (index < 0 || index >= data.length) {
            throw new IllegalArgumentException("Index is illegal.");
        }

        // 索引index正常
        // 此时，将线段树的data[index]这个index索引的值换成是e
        data[index] = e;

        // 接下来对tree这个变量进行相应的更新操作了。
        // 从根节点开始，所对应的这个区间从0到data.length-1,来更新index索引位置的元素更新为e。
        this.set(0, 0, data.length - 1, index, e);
    }

    /**
     * 在以treeIndex为根的线段树中更新index的值为e
     * <p>
     * 递归函数修改，修改tree
     * <p>
     * 时间复杂度是O(logn)级别的。
     * 从根节点开始，一直找到index这个位置的元素所在的那个叶子节点，这个高度是logn级别的。
     *
     * @param treeIndex 以treeIndex为根进行的线段树
     * @param left      对于这个节点表示的是从left到right的值
     * @param right
     * @param index     在这个线段树中更新将index这个位置的元素为e
     * @param e
     */
    public void set(int treeIndex, int left, int right, int index, E e) {
        // 递归函数，递归到底的情况
        if (left == right) {
            // 此时，已经递归到底了，已经找到了要更新的节点了。
            tree[treeIndex] = e;
            return;
        }

        // 否则，就是在线段树中去找index这个位置它对应的叶子的位置在哪里。
        // 只有找到叶子节点才可以计算出根节点的值的。
        // 线段树中每一个节点都是对应一个区间。
        int mid = left + (right - left) / 2;
        // 计算出对于treeIndex这个节点的左右孩子
        // treeIndex这个左孩子的索引
        int leftTreeIndex = leftChild(treeIndex);
        // treeIndex这个右孩子的索引
        int rightTreeIndex = rightChild(treeIndex);

        // 如果我们要找的index >= mid + 1的时候，此时只要去右子树继续寻找就行了
        if (index >= mid + 1) {
            // 此时,index在该节点对应的右子树所对应的区间
            set(rightTreeIndex, mid + 1, right, index, e);
        } else if (index <= mid) {
            // 去左子树的所对应的区间去更新操作
            set(leftTreeIndex, left, mid, index, e);
        }

        // 对于线段树来说，我们最终找到了叶子节点，更新完了tree[treeIndex]之后，是不够的
        // 相应的在返回去的过程中，这个叶子节点的父亲节点，这个父亲节点的父亲节点等一系列节点
        // 都会受到牵连，因为这些节点描述的都是一个区间内相应的统计的值，而这些区间包含index这个
        // 索引的元素，一旦index这个位置的元素发生了改变，那么它的祖辈节点相应所表示的区间包含这个index
        // 其统计结果也要发生改变，所以最后的时候，在对每一个节点更新的时候，对这个节点的值tree[treeIndex]
        // 也要进行一下更新，之间调用融合器进行更新。

        // 每次递归操作都进行了更新操作的。
        tree[treeIndex] = merger.merger(tree[leftTreeIndex], tree[rightTreeIndex]);
    }


    public static void main(String[] args) {
        Integer[] nums = {2, 0, 3, 5, 2, 1};
//        SegmentTree<Integer> segmentTree = new SegmentTree<Integer>(nums, new Merger<Integer>() {
//
//            /**
//             * 使用匿名内部类,来实现融合器
//             * @param a
//             * @param b
//             * @return
//             */
//            @Override
//            public Integer merger(Integer a, Integer b) {
//                return a + b;
//            }
//        });


        //
        SegmentTree<Integer> segmentTree = new SegmentTree<Integer>(nums,
                (a, b) -> a + b
        );
        System.out.println(segmentTree.toString());

        System.out.println();
        // 线段树的查询
        Integer query = segmentTree.query(0, 3);
        System.out.println(query);
    }

}

解决力扣LeetCode，力扣LeetCode，区域和检索 - 数组可修改，代码，如下所示：

package com.leetcode;

import com.tree.SegmentTree;

/**
 * 线段树解决此问题
 * <p>
 * <p>
 * <p>
 * 给定一个整数数组  nums，求出数组从索引 i 到 j  (i ≤ j) 范围内元素的总和，包含 i,  j 两点。
 * <p>
 * <p>
 * 线段树的查询操作和修改操作的时间复杂度是O(logn)级别的。O(logn)远远快于O(n)级别的时间复杂度
 * <p>
 * <p>
 * 线段树的创建的过程时间复杂度是O(n)的复杂度，更准确的说是O(4*n)的复杂度。
 * <p>
 * <p>
 * 对于线段树来说，对于要考虑区间的这一种数据，尤其是想要查询区间的相关统计的信息的时候，
 * 同时数据是动态的，不时要更新数据，线段树是一种很好的数据结构。
 */
public class NumArray {

    // 线段树
    private SegmentTree<Integer> segmentTree;


    /**
     * 给定 nums = [-2, 0, 3, -5, 2, -1]，求和函数为 sumRange()
     * <p>
     * <p>
     * sumRange(0, 2) -> 1
     * sumRange(2, 5) -> -1
     * sumRange(0, 5) -> -3
     *
     * @param nums
     */
    public NumArray(int[] nums) {
        // 判断数组长度是否大于0，如果大于0就进行创建线段树
        if (nums.length > 0) {
            // 将int[]数组转换为Integer[]类型
            Integer[] data = new Integer[nums.length];
            for (int i = 0; i < data.length; i++) {
                data[i] = nums[i];
            }

            // 开始初始化线段树
            segmentTree = new SegmentTree<>(data, (a, b) -> a + b);
        }
    }

    /**
     * 查询区间之间的和
     * 查询操作，时间复杂度是O(logn)
     *
     * @param i
     * @param j
     * @return
     */
    public int sumRange(int i, int j) {
        if (segmentTree == null) {
            throw new IllegalArgumentException("Segment Tree is null.");
        }

        return segmentTree.query(i, j);
    }


    /**
     * <p>
     * <p>
     * 更新操作，时间复杂度是O(logn)
     *
     * @param i
     * @param val
     */
    public void update(int i, int val) {
        if (segmentTree == null) {
            throw new IllegalArgumentException("Segment Tree is null.");
        }

        // 直接调用线段树的更新操作即可
        segmentTree.set(i, val);
    }

    public static void main(String[] args) {
        int[] nums = {-2, 0, 3, -5, 2, -1};
        NumArray numArray = new NumArray(nums);
        int sumRange = numArray.sumRange(0, 3);
        System.out.println(sumRange);
    }

}