数据结构之线段树

版权声明：本文为博主原创文章，转载请附上博文链接！ https://blog.csdn.net/qq_24095055/article/details/89308956

线段树（区间树）Segment Tree

线段树的概念

线段树是一种特殊的树结构。这种数据结构主要用于解决“线段”或者是“区间”这种特殊的数据

线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。

对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。
使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN）。

如果区间有n个元素，数组表示需要有多少节点？

0层：1
1层：2
2层：4
3层：8
…
h-1层：2^(h-1)
所以对满二叉树：
h层：一共有2^h - 1个节点（大约是2^h）
最后一层(h-1)层，有2^(h-1)个节点
最后一层的节点数大致等于前面所有层节点之和

如上，当所有的元素节点都在最后一层时，2n的空间即可，
可是若元素节点存放在最后两层中，则需要4n的空间
故，需要4n的空间

• 线段树不是完全二叉树
• 线段树是平衡二叉树（最大深度与最小深度差距不大于1）

为什么要使用线段树

线段树的经典问题：区间查询

对于给定区间

• 更新：更新区间中一个元素或者一个区间的值
• 查询一个区间[i,j]的最大值，最小值，或者区间数字和
• 实质：基于区间的统计查询

例：查询某电商网站中2018年注册用户中消费最高的用户？消费最少的用户？学习时间最长的用户？

手写一个线段树

public interface Merger<E> {
    // 自定义merge方法定义融合规则
    E merge(E a, E b);
}

public class SegmentTree<E> {

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

    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的位置创建表示区间[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) / 2;
        int mid = l + (r - l) / 2;
        buildSegmentTree(leftTreeIndex, l, mid);
        buildSegmentTree(rightTreeIndex, mid + 1, r);

        // tree[treeIndex]的值要根据具体业务来定，下面是一种求和的线段树
        // tree[treeIndex] = tree[rightTreeIndex] + tree[rightTreeIndex];
        // 如果是求最大值，就是 tree[treeIndex] = max(tree[leftTreeIndex], tree[rightTreeIndex]) 最小值就是min...
        // 这里为了有更多的扩展性，对tree节点的赋值我们定义一个借口 Merger 里面只有一个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;
    }

    @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();
    }
}

public class Main {

    public static void main(String[] args) {

        Integer[] nums = {-2, 0, 3, -5, 2, -1};
//        SegmentTree<Integer> segTree = new SegmentTree<>(nums,
//                new Merger<Integer>() {
//                    @Override
//                    public Integer merge(Integer a, Integer b) {
//                        return a + b;
//                    }
//                });

        SegmentTree<Integer> segTree = new SegmentTree<>(nums,
                (a, b) -> a + b);
        System.out.println(segTree);
    }
}

线段树中的区间查询

如图在[0,7]区间中查询[2,5]节点的步骤：

方法代码：

// 在以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;
    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);
}

线段树问题 LeetCode303

https://leetcode-cn.com/problems/range-sum-query-immutable/

问题描述：

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

示例：

给定 nums = [-2, 0, 3, -5, 2, -1]，求和函数为 sumRange()
sumRange(0, 2) -> 1
sumRange(2, 5) -> -1
sumRange(0, 5) -> -3

说明:

1. 你可以假设数组不可变。
2. 会多次调用 sumRange 方法。

所给问题解题模板

class NumArray {

    public NumArray(int[] nums) {
        
    }
    
    public int sumRange(int i, int j) {
        
    }
}

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray obj = new NumArray(nums);
 * int param_1 = obj.sumRange(i,j);
 */

其实用简单的索引遍历求和就可以通过… 不过还是用线段树来解决下（注意使用自定义方法要将自定义的方法拷贝进去）。

class NumArray {
	
	// 自定义辅助接口和类
	private interface Merger.....
	private class SegmentTree..........
	
    private SegmentTree<Integer> segmentTree;

    public NumArray(int[] nums) {

        if (nums.length > 0){
            Integer[] data = new Integer[nums.length];
            for (int i = 0 ; i < nums.length ; i ++)
                data[i] = nums[i];
            segmentTree = new SegmentTree<>(data, (a, b) -> a + b);
        }
    }

    public int sumRange(int i, int j) {

        if (segmentTree == null)
            throw new IllegalArgumentException("Segment Tree is null");
        return segmentTree.query(i, j);
    }
}

提交查看测试结果可以发现比遍历效率要高得多

另外我们的需求是输入一个数组求出某个范围的元素和，也就是数组几乎是不可变的，所以我们也可以采用预处理的方式来解决，性能上也会更好。

class NumArray {

    private int[] sum; // sum[i]存储前i个元素和，sum[0] = 0
                       // sum[i]存储nums[0...i-1]的和

    public NumArray(int[] nums) {
        sum = new int[nums.length + 1];
        sum[0] = 0;
        for (int i = 1 ; i < sum.length ; i ++)
            sum[i] = sum[i - 1] + nums[i - 1];
    }

    public int sumRange(int i, int j) {
        return sum[j + 1] - sum[i];
    }
}

图上三次从上到下依次为使用预处理，线段树，和索引遍历三种方式，预处理效率最高。

当然这里线段树不如预处理的原因是因为这里不考虑更新操作，实际上线段树的效率还是很好的。

LeetCode307

https://leetcode-cn.com/problems/range-sum-query-mutable/submissions/

接下来我们看一个适合线段树的LeetCode307号问题

题目描述：

给定一个整数数组 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

说明:

数组仅可以在 update 函数下进行修改。
你可以假设 update 函数与 sumRange 函数的调用次数是均匀分布的。

所给代码模板：

class NumArray {

    public NumArray(int[] nums) {
        
    }
    
    public void update(int i, int val) {
        
    }
    
    public int sumRange(int i, int j) {
        
    }
}

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray obj = new NumArray(nums);
 * obj.update(i,val);
 * int param_2 = obj.sumRange(i,j);
 */

首先我们可以在预处理的基础上进行改进，即在更新方法update中，对修改位置后面的位置的每个sum元素重新求和：

class NumArray {

    private int[] sum; // sum[i]存储前i个元素和，sum[0] = 0
                       // sum[i]存储nums[0...i-1]的和
    private int[] data;

    public NumArray(int[] nums) {

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

        sum = new int[nums.length + 1];
        sum[0] = 0;
        for (int i = 1 ; i < sum.length ; i ++)
            sum[i] = sum[i - 1] + nums[i - 1];
    }

    public void update(int index, int val){
        data[index] = val;
        for (int i = index + 1 ; i < sum.length ; i ++)
            sum[i] = sum[i - 1] + data[i - 1];
    }

    public int sumRange(int i, int j) {
        return sum[j + 1] - sum[i];
    }
}

可以通过测试，可是时间复杂度很高，执行用时过长，有时甚至会超出规定运行时间，所以还是要使用线段树来解决这个问题：

在SegmentTree中添加更新方法：

// 将index位置的值，更新为e
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 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 // index <= mid
        set(leftTreeIndex, l, mid, index, e);
    tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
}

使用线段树的方式解决307号问题：

class NumArray {

    private SegmentTree<Integer> segmentTree;

    public NumArray(int[] nums) {

        if (nums.length > 0){
            Integer[] data = new Integer[nums.length];
            for (int i = 0 ; i < nums.length ; i ++)
                data[i] = nums[i];
            segmentTree = new SegmentTree<>(data, (a, b) -> a + b);
        }
    }

    public void update(int index, int val){

        if (segmentTree == null)
            throw new IllegalArgumentException("Segment Tree is null");
        segmentTree.set(index, val);
    }

    public int sumRange(int i, int j) {

        if (segmentTree == null)
            throw new IllegalArgumentException("Segment Tree is null");
        return segmentTree.query(i, j);
    }
}

可以看到运行时间对比：

明显线段树效率高得多。

对区间进行操作的时间复杂度

	使用数组实现	使用线段树
更新	O(n)	O(logn)
查询	O(n)	O(logn)