Java树状数组【Binary Indexed Tree】应用

最新推荐文章于 2024-04-11 19:03:28 发布
最新推荐文章于 2024-04-11 19:03:28 发布
阅读量304 收藏
点赞数 1
分类专栏： 算法 Java 文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43871354/article/details/115840591
版权

单点更新–求区间最大(小)值

import java.util.Arrays;

public class BIT_MaxMin {
    static final int maxN = 50;
    static int N;
    static int[] bitMax = new int[maxN];
    static int[] bitMin = new int[maxN];
    static int[] arr = new int[maxN];

    public static void main(String[] args) throws Exception {
        int[] in = new int[]{5, 6, 7, 7, 4, 2, 8, 3, 9, 9, 9, 10, 10, 11};
        N = in.length;
        for (int i = 1; i <= N; i++) {
            arr[i] = in[i - 1];
            update(i, arr[i]);
        }
        int[] ans = queryMaxMin(1, 7);
        System.out.println("1~7区间最大值: " + ans[0]);//8
        System.out.println("1~7区间最小值: " + ans[1]);//2
    }

    static int lowBit(int x) {
        // x & x取反+1
        return x & -x;
    }
    //最大最小可拆分成两个方法
    static void update(int x, int val) {
        arr[x] = val;
        while (x <= maxN) {
            bitMax[x] = arr[x];
            bitMin[x] = arr[x];
            for (int i = 1; i < lowBit(x); i *= 2) {
                bitMax[x] = Math.max(bitMax[x], bitMax[x - i]);
                bitMin[x] = Math.min(bitMin[x], bitMin[x - i]);
            }
            x += lowBit(x);
        }
    }
    //最大最小可拆分成两个方法
    static int[] queryMaxMin(int x, int y) {
        int max = arr[y];
        int min = arr[y];
        while (y != x) {
            for (y--; y - lowBit(y) >= x; y -= lowBit(y)) {
                max = Math.max(max, bitMax[y]);
                min = Math.min(min, bitMin[y]);
            }
            max = Math.max(max, arr[y]);
            min = Math.min(min, arr[y]);
        }
        return new int[]{max, min};
    }
}

最长递增子序列的长度(LIS、LNDS)

LIS(Longest Increasing Subsequence)：最长单调递增子序列长度
LNDS：最长不递减子序列长度

import java.util.Arrays;
import java.util.Comparator;

public class BIT_LIS_LNDS {
    static final int maxN = 50;
    static int N;
    static int lis = 0, lnds = 0;
    static Node[] lisArr = new Node[maxN];
    static Node[] lndsArr = new Node[maxN];
    static int[] bit = new int[maxN];
    static Comparator<Node> lisCmp = new Comparator<Node>() {
        @Override
        public int compare(Node o1, Node o2) {
            //lds 按值升序 索引降序
            return o1.val == o2.val ? o2.idx - o1.idx : o1.val - o2.val;
        }
    };
    static Comparator<Node> lndsCmp = new Comparator<Node>() {
        @Override
        public int compare(Node o1, Node o2) {
            //lds 按值升序 索引升序
            return o1.val == o2.val ? o1.idx - o2.idx : o1.val - o2.val;
        }
    };

    public static void main(String[] args) {
        int[] in = new int[]{5, 6, 7, 7, 4, 2, 8, 3, 9, 9, 9, 10, 10, 11};
        //lis(7):5 6 7 8 9 10 11
        //lnds(11):5 6 7 7 8 9 9 9 10 10 11
        N = in.length;
        for (int i = 0; i < N; i++) {
            lisArr[i + 1] = new Node(i + 1, in[i]);
            lndsArr[i + 1] = new Node(i + 1, in[i]);
        }
        Arrays.sort(lisArr, 1, N + 1, lisCmp);
        for (int i = 1; i <= N; i++) {
            int len = query(lisArr[i].idx-1) + 1;
            update(lisArr[i].idx, len);
            lis = Math.max(lis, len);
        }
        System.out.println("lis: " + lis);

        Arrays.fill(bit, 0);
        Arrays.sort(lndsArr, 1, N + 1, lndsCmp);
        for (int i = 1; i <= N; i++) {
            int len = query(lndsArr[i].idx-1) + 1;
            update(lndsArr[i].idx, len);
            lnds = Math.max(lnds, len);
        }
        System.out.println("lnds: " + lnds);
    }

    static int lowBit(int x) {
        // x & x取反+1
        return x & -x;
    }

    static void update(int x, int val) {
        while (x < maxN) {
            bit[x] = Math.max(bit[x], val);
            x += lowBit(x);
        }
    }

    static int query(int x) {
        int max = 0;
        while (x > 0) {
            max = Math.max(bit[x], max);
            x -= lowBit(x);
        }
        return max;
    }

    static class Node {
        int idx;
        int val;

        Node(int idx, int val) {
            this.idx = idx;
            this.val = val;
        }
    }
}

最长递减子序列的长度(LDS、LNIS)

LDS(Longest Decreasing Subsequence)：最长单调递减子序列长度
LNIS：最长不递增子序列长度

import java.util.Arrays;
import java.util.Comparator;

public class BIT_LDS_LNIS {
    static final int maxN = 50;
    static int N;
    static int lds = 0, lnis = 0;
    static Node[] ldsArr = new Node[maxN];
    static Node[] lnisArr = new Node[maxN];
    static int[] bit = new int[maxN];

    static Comparator<Node> ldsCmp = new Comparator<Node>() {
        @Override
        public int compare(Node o1, Node o2) {
            //lds 按值升序 索引升序
            return o1.val == o2.val ? o1.idx - o2.idx : o1.val - o2.val;
        }
    };
    static Comparator<Node> lnisCmp = new Comparator<Node>() {
        @Override
        public int compare(Node o1, Node o2) {
            //lnis 按值升序 索引降序
            return o1.val == o2.val ? o2.idx - o1.idx : o1.val - o2.val;
        }
    };

    public static void main(String[] args) {
        int[] in = new int[]{11, 10, 10, 9, 9, 9, 3, 8, 2, 4, 7, 7, 6, 5};
        //lds(7):11 10 9 8 7 6 5
        //lnis(11):11 10 10 9 9 9 8 7 7 6 5
        N = in.length;
        for (int i = 0; i < N; i++) {
            ldsArr[i + 1] = new Node(i + 1, in[i]);
            lnisArr[i + 1] = new Node(i + 1, in[i]);
        }
        Arrays.sort(ldsArr, 1, N + 1, ldsCmp);
        for (int i = N; i >= 1; i--) {
            int len = query(ldsArr[i].idx-1) + 1;
            update(ldsArr[i].idx, len);
            lds = Math.max(lds, len);
        }
        System.out.println("lds: " + lds);

        Arrays.fill(bit, 0);
        Arrays.sort(lnisArr, 1, N + 1, lnisCmp);
        for (int i = N; i >= 1; i--) {
            int len = query(lnisArr[i].idx-1) + 1;
            update(lnisArr[i].idx, len);
            lnis = Math.max(lnis, len);
        }
        System.out.println("lnis: " + lnis);
    }

    static int lowBit(int x) {
        // x & x取反+1
        return x & -x;
    }

    static void update(int x, int val) {
        while (x < maxN) {
            bit[x] = Math.max(bit[x], val);
            x += lowBit(x);
        }
    }

    static int query(int x) {
        int max = 0;
        while (x > 0) {
            max = Math.max(bit[x], max);
            x -= lowBit(x);
        }
        return max;
    }

    static class Node {
        int idx;
        int val;

        Node(int idx, int val) {
            this.idx = idx;
            this.val = val;
        }
    }
}

单点更新–求区间和

public class BIT_Sum {
    static final int maxN = 50;
    static int N;
    static int[] bit = new int[maxN];

    public static void main(String[] args) throws Exception {
        int[] in = new int[]{5, 6, 7, 7, 4, 2, 8, 3, 9, 9, 9, 10, 10, 11};
        N = in.length;
        for (int i = 0; i < N; i++) {
            update(i + 1, in[i]);//初始化
        }
        //第x~y项的区间和 query(y) - query(x-1)
        //第x项的值改为y update(x, y)
        System.out.println(query(5) - query(2 - 1));//2~5项的区间和 6+7+7+4=24
        update(3, 10 - 7);//第三项由7改为10
        System.out.println(query(5) - query(2 - 1));//2~5项的区间和 6+10+7+4=27
    }

    static int lowBit(int x) {
        return x & (-x);
    }

    static void update(int x, int val) {
        while (x < maxN) {
            bit[x] += val;
            x += lowBit(x);
        }
    }

    static int query(int x) {
        int sum = 0;
        while (x > 0) {
            sum += bit[x];
            x -= lowBit(x);
        }
        return sum;
    }
}

区间更新–单点查询

区间更新，暴力方法：遍历区间，对区间中每个值更新，再求和。
优化方法：使用差分数组
原数组为ai[i], 差分数组di[i]=ai[i]−ai[i−1] (ai[0]=0)，则 ai[i]=sum(di[j])

public class BIT_RangeUpdate_SingleQuery {
    static final int maxN = 50;
    static int N;
    static int[] bit = new int[maxN];

    public static void main(String[] args) throws Exception {
        int[] ai = new int[]{0, 5, 6, 7, 7, 4, 2, 8, 3, 9, 9, 9, 10, 10, 11};
        N = ai.length;
        // 差分数组di[i] = ai[i] - ai[i-1]
        // 0 5 1 1 0 -3 -2 6 -5 6 0 0 1 0 1
        int[] di = new int[N];
        for (int i = 1; i < N; i++) {
            di[i] = ai[i] - ai[i - 1];
            update(i, di[i]);
        }

        System.out.print("差分数组: ");
        for (int i = 0; i < N; i++) {
            System.out.print(di[i] + " ");
        }
        System.out.println();
        //区间修改,第x~y项的区间 都加2: rangeUpdate(x, y, 2)
        //单点查询,查询第x项的值 query(x)
        rangeUpdate(2, 7, 2);
        System.out.println(query(5));//ai[6]的值4+2=6
    }

    static int lowBit(int x) {
        return x & (-x);
    }

    /*
    区间修改
     */
    static void rangeUpdate(int x, int y, int val) {
        update(x, val);
        update(y + 1, -val);
    }

    static void update(int x, int val) {
        while (x < maxN) {
            bit[x] += val;
            x += lowBit(x);
        }
    }

    /*
    单点查询
     */
    static int query(int x) {
        int sum = 0;
        while (x > 0) {
            sum += bit[x];
            x -= lowBit(x);
        }
        return sum;
    }
}

区间更新–区间求和

public class BIT_RangeUpdate_RangeQuery {
    static final int maxN = 50;
    static int N;
    static int[] sum1 = new int[maxN];// sum1[i]=di[i]
    static int[] sum2 = new int[maxN];// sum2[i]=di[i]∗i

    public static void main(String[] args) throws Exception {
        int[] ai = new int[]{0, 5, 6, 7, 7, 4, 2, 8, 3, 9, 9, 9, 10, 10, 11};
        N = ai.length;
        // di[i] = ai[i] - ai[i-1]
        // 0 5 1 1 0 -3 -2 6 -5 6 0 0 1 0 1
        int[] di = new int[N + 1];
        for (int i = 1; i < N; i++) {
            di[i] = ai[i] - ai[i - 1];
            update(i, di[i]);
        }

        System.out.print("差分数组: ");
        for (int i = 0; i < N; i++) {
            System.out.print(di[i] + " ");
        }
        System.out.println();
        //区间修改,第x~y项的区间 都加2: rangeUpdate(x, y, 2)
        //区间查询,查询第x~y项区间的和 query(y) - query(x-1)
        rangeUpdate(2, 7, 2);
        System.out.println(query(5) - query(2 - 1));//ai[3]+...+ai[6]项的区间和 6+10+7+4=27
    }

    static int lowBit(int x) {
        return x & (-x);
    }

    static void rangeUpdate(int x, int y, int val) {
        update(x, val);
        update(y + 1, -val);
    }

    static void update(int x, int val) {
        int init = x;
        while (x < maxN) {
            sum1[x] += val;
            sum2[x] += init * val;
            x += lowBit(x);
        }
    }

    static int query(int x) {
        int init = x;
        int sum = 0;
        while (x > 0) {
            sum += (init + 1) * sum1[x] - sum2[x];
            x -= lowBit(x);
        }
        return sum;
    }
}

这个博客写得很好
[https://blog.csdn.net/bestsort/article/details/80796531]

Jianhong Li
关注
专栏目录
树状数组 Binary Indexed Tree (B.I.T)
yake1965
01-21 922
树状数组
java实现的 树状数组
09-16
用java实现的树状数组，可以作为一个简单的模版来进行应用，如果有不懂得地方，可以上网查找树状数组的原理
树状数组实现（Java）
gaoqiandr的博客
03-21 455
树状数组通常用来解决一些区间问题，本文主要介绍的是树状数组的模板
Java数据结构-树状数组
阳光码术-Java面试宝典
01-30 816
什么是树状数组?[面试5.0] 使用数组表示多叉树的结构,和优先队列有点类似,区别在于优先队列只表示二叉树主要用来: 更新数组元素的数值并且求数组前K个元素的总和或平均值时间复杂度为O(logN)树状数组的第一个元素是空节点,若有y是x的父节点,那么需要满足y = x - (x & (-x)) ...
树状数组(java)
梦码城博客中心
03-22 895
树状数组 问题模型 树状数组是一个查询和修改复杂度都为log(n)的数据结构。 首先我们搞明白树状数组是用来干嘛的，现在有一个这样的问题：有一个数组a，下标从0到n-1，现在给你w次修改，q次查询，修改的话是修改数组中某一个元素的值；查询的话是查询数组中任意一个区间的和，w + q < 500000。 这个问题很常见，首先分析下朴素做法的时间复杂度，修改是O ( 1 ) O(1)O(1)的时间复杂度，而查询的话是O ( n ) O(n)O(n)的复杂度，总体时间复杂度为O ( q n ) O(qn)O
树状数组 java_算法模板之树状数组
weixin_42309293的博客
02-16 290
什么是树状数组？​树状数组就是通过数组来模拟一种树形结构，这种树形结构能够维护区间信息。同样类似的数据结构还有线段树，线段树与树状数组相比，它的结点更多，也就是说线段树的常数更大。​线段树是通过把区间二分来维护区间的信息，而树状数组是通过lowbit来维护区间的信息。​以树状数组维护区间和为例，对于树状数组c而言，$ c[i]= a[i-2k+1]+a[i-2k+2]+...+a[i]$ ,其中数...
树状数组（Binary Indexed Tree, BIT，或称 Fenwick Tree）
01-10
树状数组，也称为二进制索引树（Binary Indexed Tree, BIT）或Fenwick树，是一种高效的数据结构，特别适用于处理动态集合上的范围查询和单点更新问题。它在许多算法和数据处理任务中都有广泛应用，尤其是当需要频繁...
树状数组（Binary Indexed Tree，BIT）高效地处理动态的区间求和问题
最新发布
06-08
树状数组（Binary Indexed Tree，简称 BIT）是一种高效的线性数据结构，主要应用于处理动态的区间求和问题。与传统数组相比，树状数组在执行单点更新和区间查询时能实现更快速的操作，其时间复杂度仅为 O(log n)。...
树状数组（Binary Indexed Tree），看这一篇就够了
正西风落叶下长安
03-09 5万+
定义 根据维基百科的定义： A Fenwick tree or binary indexed tree is a data structure that can efficiently update elements and calculate prefix sums in a table of numbers. 也就是说，所谓树状数组，或称Binary Indexed Tree,...
树状数组(Binary Indexed Tree)
10-25
**树状数组**（Binary Indexed Tree, BIT），又称**费尼克树**（Fenwick Tree），是一种特殊的数据结构，它能高效地完成对数组元素的累加查询和更新操作。相较于其他数据结构如线段树，树状数组在实现上更为简洁，...
树状数组练习：POJ 2481(JAVA)
04-14
NULL 博文链接：https://128kj.iteye.com/blog/1744222
树状数组-Java代码纯享版
小吴同学的博客
07-29 381
树状数组的java实现
树状数组 java_树状数组详解
weixin_42220669的博客
02-16 1343
先来看几个问题吧。1.什么是树状数组？顾名思义，就是用数组来模拟树形结构呗。那么衍生出一个问题，为什么不直接建树？答案是没必要，因为树状数组能处理的问题就没必要建树。和Trie树的构造方式有类似之处。2.树状数组可以解决什么问题可以解决大部分基于区间上的更新以及求和问题。3.树状数组和线段树的区别在哪里树状数组可以解决的问题都可以用线段树解决，这两者的区别在哪里呢？树状数组的系数要少很多，就比如字...
线段树、树状数组（Java）
weixin_51416432的博客
01-15 576
线段树、树状数组（Java实现）
java数据结构与算法总结(二十二)--树状数组
秋天的猿
06-02 482
据说树状数组就是线段树。线段树参考链接 有一天，小明给了我三个问题(其实是我自己出的啦~) (1)有一个机器，支持两种操作，在区间[1,10000]上进行。 操作A:把位置x的值+k 操作B:询问区间[l,r]所有数字之和 区间的初始值全部为0 现在你要充当这个机器，操作A和操作B会被穿插着安排给你， 要求对于所有操作B，给出正确的答案。 怎样做才能最节省精力？ (2)有一个机器，支持两种操作，在区间[1,10000]上进行。 操作A:把区间[l,r]的值全都+x 操作B..
搞懂树状数组
热门推荐
int64Ago的专栏
04-05 6万+
引用请注明出处：http://blog.csdn.net/int64ago/article/details/7429868       写下这个标题，其实心里还是没底的，与其说是写博帖，不如说是做总结。第一个接触树状数组还是两年前，用什么语言来形容当时的感觉呢？……太神奇了！真的，无法表达出那种感觉，她是那么的优雅，10行不到的代码，却把事情干的如此出色！没有了解她原理的前提下即使把代码倒背
Java树状数组树状数组（含面试大厂题和源码）
2302_80314137的博客
04-11 693
树状数组（Fenwick Tree 或 Binary Indexed Tree，简称 BIT），是一种特殊的二叉查找树，用于高效地进行区间求和和单点更新操作。它是一种线性时间复杂度的数据结构，特别适用于解决静态数组的区间查询问题。
怎么在java中实现树状数组_树状数组---原理代码实现
weixin_29635919的博客
02-16 498
刚刚学了树状数组，有必要总结一下；(因为有人说；别人能很快理解算法，最好是让刚刚理解的人来教而不是研究多年的大牛，因为刚刚理解的才知道初学的人哪里不会；；当然这也不一样啦~~~)或许你还不知道什么是树状数组，这里大致讲一下(参考wiki，baidu)；树状数组(BinaryIndexedTree，BIT，二分索引树)，最早由PeterM. Fenwick于1994年以A New Data Stru...
怎么在java中实现树状数组_Java基础 - 树状数组Java版
weixin_31437055的博客
02-16 619
下面的文字说明引用了 int64Ago的一篇博文。用什么语言来形容当时的感觉呢？……太神奇了！真的，无法表达出那种感觉，她是那么的优雅，10行不到的代码，却把事情干的如此出色！没有了解她原理的前提下即使把代码倒背如流也理解不了！下面我争取用自己的方式让更多人明白她，而不是背诵她。为了更方便的说明，文章里会自己强加一些概念，只是为了更好的理解，不是什么专业术语之类的。一、树状数组是干什么的？平常我...
树状数组（FenwickTree）：区间查询与单点更新数据结构
"树状数组，也称为二进制索引树（Binary Indexed Tree, BIT），是一种高效的数据结构，特别适合处理区间和的查询与更新。这种数据结构可以在O(logN)的时间复杂度内完成单点更新和区间查询，极大地提高了处理大量数据...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值