高级数据结构线段树和树状数组的应用

zhou_145

已于 2023-05-04 19:47:44 修改

阅读量84

点赞数

文章标签：数据结构 java 算法

于 2023-04-28 11:58:20 首次发布

本文链接：https://blog.csdn.net/zhou_145/article/details/130422652

版权

线段树的构建

麻麻子，最近debug了很久，才理解这个思路，还是很实用的，原理上是简单的递归，但是和前缀树的更新不同的是，在维护线段树的时候，时间复杂度为logn，而前缀树是n，但前缀树在查询是是O（1），线段树为logn，线段树适用于经常改变数组范围的情形。

线段树的构建与更新与查询

思路：首先构建并维护一个线段树，把数组的值放到线段树中。把{1，2，3，4}存进线段树中，得到的是
{0，10，3，7，1，2，3，4}在构建的时候是通过先左子树，再右子树的方式进行的，先由tree[1]开
始，分别得到tree[2]和tree[3],tree[2]又分别得到了tree[4]和tree[5],同样的tree[3]得到了
tree[6]和tree[7],最后得到tree[2]和tree[3]的值后，得到tree[1].

public class LineTree {
    int[] tree,nums;
    int n;
    public LineTree(int[] nums){
        this.nums = nums;
        n = nums.length;
        tree = new int[n*4];
        build(1,0, n-1, nums);
    }
    private void build(int p, int l, int r, int[] nums) {    //构建出了数组的线段树
        if (l == r) {
            tree[p] = nums[l];
            return;
        }
        int mid = (l + r) / 2;
        build(p * 2, l, mid, nums);
        build(p * 2 + 1, mid + 1, r, nums);
        tree[p] = tree[p * 2] + tree[p * 2 + 1];
    }
    public void update(int i, int val) {   //修改的是索引为i处的数据为val
        update(1, 0, n - 1, i, val);
    }
    private void update(int p, int l, int r, int i, int val) {   //重建线段树
        if (l == r) {
            tree[p] = val;
            return;
        }
        int mid = (l + r) / 2;
        if (i <= mid)
            update(p * 2, l, mid, i, val);   //二分法
        else
            update(p * 2 + 1, mid + 1, r, i, val);
        tree[p] = tree[p * 2] + tree[p * 2 + 1];
    }
    public int query(int i, int j) {
        return query(1, 0, n - 1, i, j);
    }

    private int query(int p, int l, int r, int i, int j) {
        if (i > r || j < l)   //终止条件一
            return 0;
        if (l >= i && r <= j)  //终止条件二
            return tree[p];
        int mid = (l + r) / 2;
        return query(p * 2, l, mid, i, j) + query(p * 2 + 1, mid + 1, r, i, j);   //实际上是递归的过程，先去左边查看，再去右边查看
    }

    public static void main(String[] args) {
        int []num=new int[]{1,2,3,4};
        LineTree lineTree=new LineTree(num);
        System.out.println(lineTree.query(1,2));
    }
}

线段树求解滑动数组的最大值：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int n = nums.length;
        SegmentTree tree = new SegmentTree(nums);
        int[] ans = new int[n - k + 1];
        for (int i = 0; i <= n - k; i++) {
            ans[i] = tree.query(i, i + k - 1);
        }
        return ans;
    }
    class SegmentTree {
    int[] tree;
    int n;

    public SegmentTree(int[] nums) {
        n = nums.length;
        tree = new int[n * 4];
        build(1, 0, n - 1, nums);
    }

    private void build(int p, int l, int r, int[] nums) {
        if (l == r) {
            tree[p] = nums[l];
            return;
        }
        int mid = (l + r) / 2;
        build(p * 2, l, mid, nums);
        build(p * 2 + 1, mid + 1, r, nums);
        tree[p] = Math.max(tree[p * 2], tree[p * 2 + 1]);
    }

    public int query(int i, int j) {
        return query(1, 0, n - 1, i, j);
    }

    private int query(int p, int l, int r, int i, int j) {
        if (i > r || j < l)
            return Integer.MIN_VALUE;
        if (l >= i && r <= j)
            return tree[p];
        int mid = (l + r) / 2;
        return Math.max(query(p * 2, l, mid, i, j), query(p * 2 + 1, mid + 1, r, i, j));
    }
    }
}
//

滑动窗口的最大值其实求解起来和普通的线段树没有什么区别，但是需要改一下，因为传统的线段树
是求区间的总和，而最大值的时候，可以将其父节点
tree[p] = Math.max(tree[p * 2], tree[p * 2 + 1]);的值维护区间的最大值，最后的查询的时候也是查询出最大值。

在这里插入图片描述

    private int query(int p, int l, int r, int i, int j) {
        if (i > r || j < l)   //终止条件一
            return 0;
        if (l >= i && r <= j)  //终止条件二
            return tree[p];
        int mid = (l + r) / 2;
        return query(p * 2, l, mid, i, j) + query(p * 2 + 1, mid + 1, r, i, j);  
         //实际上是递归的过程，先去左边查看，再去右边查看
    }

将数据一直向下进行遍历，当最后一层的元素在查询区间[i,j]中的时候，可以通过判断最后一层
的[1,1]是否在查询的[1,2]中。以此类推。

以摘草莓的每日一题为例

解法上和树状数组大佬的解法一摸一样，只是最近刚学了线段树，就要秀一把
int l = Math.max(0,startPos-k);
int r = Math.min(startPos+k,maxPos);
确定了最左和最右能到达哪里，
int rm = k-2*(startPos-f);
表示的是往左边走能否到达回到原点的路，如果不能的话，就是x = startPos;
如果可以的话，就更新x的值x = startPos+rm;
其中if (x>maxPos)x = maxPos;
往右边的路也是一样的。

class Solution {
    public class LineTree {
    int[] tree,nums;
    int n;
    public LineTree(int[] nums){
        this.nums = nums;
        n = nums.length;
        tree = new int[n*4];
        build(1,0, n-1, nums);
    }
    private void build(int p, int l, int r, int[] nums) {    //构建出了数组的线段树
        if (l == r) {
            tree[p] = nums[l];
            return;
        }
        int mid = (l + r) / 2;
        build(p * 2, l, mid, nums);
        build(p * 2 + 1, mid + 1, r, nums);
        tree[p] = tree[p * 2] + tree[p * 2 + 1];
    }
    public void update(int i, int val) {   //修改的是索引为i处的数据为val
        update(1, 0, n - 1, i, val);
    }
    private void update(int p, int l, int r, int i, int val) {   //重建线段树
        if (l == r) {
            tree[p] = val;
            return;
        }
        int mid = (l + r) / 2;
        if (i <= mid)
            update(p * 2, l, mid, i, val);   //二分法
        else
            update(p * 2 + 1, mid + 1, r, i, val);
        tree[p] = tree[p * 2] + tree[p * 2 + 1];
    }
    public int query(int i, int j) {
        return query(1, 0, n - 1, i, j);
    }

    private int query(int p, int l, int r, int i, int j) {
        if (i > r || j < l)   //终止条件一
            return 0;
        if (l >= i && r <= j)  //终止条件二
            return tree[p];
        int mid = (l + r) / 2;
        return query(p * 2, l, mid, i, j) + query(p * 2 + 1, mid + 1, r, i, j);   //实际上是递归的过程，先去左边查看，再去右边查看
    }
    }
    public int maxTotalFruits(int[][] fruits, int startPos, int k) {
        int maxPos = -1;
        for (int[] f:fruits){
            if (maxPos<f[0])maxPos = f[0];
        }
        maxPos = Math.max(maxPos,startPos);
        int n=fruits.length;
        int []num=new int[maxPos+1];
        for(int[] nu:fruits){
            num[nu[0]]=nu[1];
        }
        LineTree lineTree=new LineTree(num);
        int l = Math.max(0,startPos-k);
        int r = Math.min(startPos+k,maxPos);
        int ans = 0,tmp,x;
        for (int f = l; f < startPos; f++) {
            int rm = k-2*(startPos-f);
            if (rm>=0) {
                x = startPos+rm;
                if (x>maxPos)x = maxPos;
            }
            else x = startPos;
            tmp = lineTree.query(f,x);
            if (ans < tmp)ans = tmp;
        }
        for (int f = startPos; f <= r; f++) {
            int rm = k - 2*(f-startPos);
            if (rm>=0){
                x = startPos-rm;
                if (x<0)x = 0;
            }else x = startPos;
            tmp = lineTree.query(x,f);
            if (ans<tmp) ans = tmp;
        }
        return ans;
    }
}

树状数组的使用

感觉上树状数组和线段树差不多，都是维护区间的元素的个数，线段树是维护区间内的元素的和，而树状数组也是，但两者之间的差异是，线段树的空间复杂度较高，需要4n个位置的数组才能维护，但是树状数组只需要n就可以维护。
在这里插入图片描述

class BIT {
    private final int[] tree;

    public BIT(int n) {
        tree = new int[n];
    }

    // 将下标 i 上的数加一

    int lowbit(int x){return x&-x;}
    //给x这个位置增加c 同时会对其所有的父节点进行操作
    public void inc(int x,int c){
        for(int i=x;i<tree.length;i+=lowbit(i)) tree[i] += c;
    }
    // 返回闭区间 [1, i] 的元素和
    //求[1,x]的和
    int sum(int x){
        int res = 0;
        for(int i=x;i>=1;i-=lowbit(i)) res += tree[i];
        return res;
    }
    //求[l,r]的和
    int query(int l,int r){
        return sum(r) - sum(l-1);
    }
}

    public long countOperationsToEmptyArray(int[] nums) {
        int n = nums.length;
        var id = new Integer[n];
        for (int i = 0; i < n; ++i)
            id[i] = i;
        Arrays.sort(id, Comparator.comparingInt(i -> nums[i]));

        long ans = n; // 先把 n 计入答案
        var t = new BIT(n + 1); // 下标从 1 开始
        int pre = 1; // 上一个最小值的位置，初始为 1
        for (int k = 0; k < n; ++k) {
            int i = id[k] + 1; // 下标从 1 开始
            if (i >= pre) // 从 pre 移动到 i，跳过已经删除的数
                ans += i - pre - t.query(pre, i);
            else // 从 pre 移动到 n，再从 1 移动到 i，跳过已经删除的数
                ans += n-pre-query(pre,n) + index - query(1,index);
            t.inc(i,1); // 删除 i
            pre = i;
        }
        return ans;
    }

思路是首先将元素按照下标来表示例如对于2413的数组可以表示为2031，这主要是考虑将元素进行移动的时候考虑的是下标
首先pre为1,而要删除的第一个数1的下标为2+1，i>pre,则此时是将pre的元素放到i后面去，因而长度是i - pre
同时要考虑已经删掉的元素，即t.query(pre, i);其中存放的是已经删掉的元素，但此时[1,3]中还没有元素被删除，
因而为0，ans += i - pre - t.query(pre, i);此时ans为6，同时将1删除，代表着tree[1]++,pre=3，下一个要删除的元素为
2，其下标为0+1，i<pre,因而要将pre-->n和1-->i中的元素移动，同时考虑这里面已经删除的元素，因而为
ans += n-pre-query(pre,n) + index - query(1,index);此时加上的元素为4-3-[3,4]+1-[1,1]=4-3-0+1-1=1;
ans+=1-->ans=7，最后依次类推即可。

zhou_145

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
高级数据结构线段树和树状数组的应用

麻麻子，最近debug了很久，才理解这个思路，还是很实用的，原理上是简单的递归，但是和前缀树的更新不同的是，在维护线段树的时候，时间复杂度为logn，而前缀树是n，但前缀树在查询是是O（1），线段树为logn，线段树适用于经常改变数组范围的情形。
复制链接

扫一扫