小繁的Binary_Indexed_Tree学习笔记

原创已于 2023-02-26 14:04:41 修改 · 184 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#学习 #算法 #数据结构

于 2023-01-26 15:53:56 首次发布

数据结构算法笔记专栏收录该内容

3 篇文章

订阅专栏

博客介绍了从线段树到树状数组的演变过程。为解决数组单点修改和区间求和的效率问题，通过对线段树剪枝得到树状数组。详细阐述了树状数组的区间划分、单点修改和区间求和的实现方法，还进行了算法分析，并给出了相关程序实现示例。

从线段树到树状数组

对于一个数组nums，我们要完成两个操作

修改其中某个元素的值（单点修改）
求出前n个元素的和（区间求和）
对于数组nums，单点修改的时间复杂度为 $O(1)\mathcal{O}(1)$ ，区间求和为 $O(n)\mathcal{O}(n)$

对于前缀和，可以得到数组prenums，该数组区间求和时间复杂度为 $O(1)\mathcal{O}(1)$ ，单点修改为 $O(n)\mathcal{O}(n)$

能不能考虑一个折中的办法，让单点修改和区间求和的方法都不那么慢？

有人考虑用线段树来完成这两个操作，把数字两两求和，保存在另一个数组中，然后逐层向上，重复操作，变成类似二叉树的结构。

此时如果计算前15个数字的和，只计算前4个数字即可(8+4+2+1)，这样加快了查询的时间。

而且我们发现有些数据是不需要使用的，例如左端的14和5，在计算前三个数和，前四个数和时，不需要使用5，而计算前5个数组时使用上方的19更好，所以5在这里不需要使用。

类似还有很多这样的数字，我们对这个线段树进行剪枝，我们可以得到下面的结构。我们还发现剩下的数据量与原数组相等，这样我们可以将这些数据正好放入一个数组中，这个数组与原数组一样长。这种数组就称为树状数组，该数组中每一个元素都对应下面的一个区间，每个区间表示的是原数组的区间和，求和时找到对应区间求和，修改时向上找到包含它的区间进行修改即可。

树状数组介绍

树状数组(Binary Indexed Tree, Fenmick Tree)，它对数组进行区间划分，是一种用于高效求解前缀和的数据结构，它的单点修改和区间求和的时间复杂度为 $O(log⁡n)\mathcal{O}(\log n)$ 。

树状数组单点修改和区间求和的实现

树状数组在原数组的基础上划分区间保存区间和，例如，数列有9个元素，分别用 $,a[9]a[1],a[2],\cdots,a[9]$ 存储，树状数组引入数组 $c []$ 保存一个或多个元素和，因为数组 $c []$ 可以用树状结构表示，因此 $c []$ 称为树状数组。

区间长度

树状数组通过二进制分解划分区间，对于 $c [i]$ ，若 $i$ 的二进制表示中末尾有 $k$ 个连续的0，则 $c [i]$ 存储的区间长度为 $2^k$ ，区间为 $a [i]$ 起始向前数 $2^k$ 个元素,即 $2^k + 1] + a[i - 2^k + 2] + \cdots + a[i]$ 。

区间长度就是i的二进制表示下最低位的1及它后面的0构成的数值。
例如i=20，其二进制表示为10100，末尾有两个0，区间长度为 $2^2$ ，其实就是10100最低位1及其后面的0构成的数值 $100)_2$ ，十进制为4。

已知一个十进制数 $i$ ，如何求其区间长度
以 $i = 20$ 为例，将i取反，得 $∼i=01011\sim i = 01011$ ， $∼i+1=01100\sim i + 1 = 01100$ ，之后 $(∼i+1)&i=(01100)2&(10100)2=(00100)2(\sim i + 1) \& i=(01100)_{2}\&(10100)_{2}=(00100)_{2}$
在计算机中，-i的补码正好是 $∼i+1\sim i + 1$
$c [i]$ 存储的区间长度 $lowbit(i)=(−i)&ilowbit(i)=(-i)\&i$

前驱和后继

直接前驱： $c [i]$ 的直接前驱为 $c [i - l o w bi t (i)]$ ，即 $c [i]$ 左侧紧邻的子树的根。
直接后继： $c [i]$ 的直接后继为 $c [i + l o w bi t (i)]$ ，即 $c [i]$ 的父节点。
前驱： $c [i]$ 的直接前驱、其直接前驱的直接前驱等，即 $c [i]$ 左侧所有子树的根。
后继： $c [i]$ 的直接后继，其直接后继的直接后继等，即 $c [i]$ 的所有祖先。

$c [7]$ 的直接前驱为 $c [6]$ ， $c [6]$ 的直接前驱为 $c [4]$ ， $c [4]$ 没有直接前驱； $c [7]$ 的前驱为 $c [6]$ 、 $c [4]$ 。
$c [5]$ 的直接后继为 $c [6]$ ， $c [6]$ 的直接后继为 $c [8]$ ， $c [8]$ 没有直接后继； $c [5]$ 的后继为 $c [6]$ 、 $c [8]$ 。

查询前缀和

前 $i$ 个元素的前缀和 $s u m [i]$ 等于 $c [i]$ 加上 $c [i]$ 的前驱，
$s u m [7]$ 等于 $c [7]$ 加上 $c [7]$ 的前驱， $c [7]$ 的前驱为 $c [6]$ 、 $c [4]$ ，因此 $s u m [7] = c [7] + c [6] + c [4]$ 。

点更新

若对 $a [i]$ 进行修改，令 $a [i]$ 加上一个数 $z$ ，则只需更新 $c [i]$ 及其后继（祖先），即令这些节点都加上 $z$ 即可，无需修改其他节点。
例如，修改 $a [5]$ ，令其加 $2$ 。只需 $c [5] + 2$ ，然后 $c [5]$ 的后继分别加 $2$ ，即 $c [6] + 2$ 、 $c [8] + 2$ 。

查询区间和

若求区间和值 $a [i] + a [i + 1] + \dots + a [j]$ ，则求解前 $j$ 个元素的和值减去前 $i - 1$ 个元素的和值即可，即 $s u m [j] - s u m [i - 1]$ 。

算法分析

前缀和：求 $a[1]⋯a[i]a[1]\cdots a[i]$ 的前缀和，普通数组 $O(n)\mathcal O(n)$ ，树状数组 $O(log⁡n)\mathcal O(\log n)$ 。

区间和：求 $a[1]⋯a[j]a[1]\cdots a[j]$ 的区间和，普通数组 $O(n)\mathcal O(n)$ ，树状数组 $O(log⁡n)\mathcal O(\log n)$ 。

点更新：修改 $a [i]$ 加上 $z$ ，普通数组 $O(1)\mathcal O(1)$ ，树状数组 $O(log⁡n)\mathcal O(\log n)$ 。

程序实现

class BinaryIndexTree:

    def __init__(self, nums: List[int]):
        self.tree = [0] + nums
        # 构造出的BIT空间比原nums多一，第1个下标0不用
        n = len(nums)
        for i in range(1, n + 1):
        
            j = i + self.lowbit(i)
            if j < n + 1:
                self.tree[j] += self.tree[i]

    def update(self, index: int, val: int) -> None:
        prev = self.sumRange(index, index)
        index += 1
        val -= prev
        while index < len(self.tree):
            self.tree[index] += val
            index += self.lowbit(index)
            
    def sumRange(self, left: int, right: int) -> int:
        return self.presum(right) - self.presum(left - 1)

    def lowbit(self, x: int) -> int:
        return x & -x

	#自定义前缀和preSum函数
    def presum(self, index: int) -> int:
        index += 1
        res = 0
        while index:
            res += self.tree[index]
            index -= self.lowbit(index)
        return res

LeetCode 面试题10.10 数字流的秩
tree数组序号为输入数字，数组数字为数字的次数，通过树状数组做统计。

class StreamRank:
    def __init__(self):
        self.tree = [0]*50002

    def track(self, x: int) -> None:
        x += 1 # x = 0时会陷入死循环
        while x < 50002:
            self.tree[x] += 1
            x += x & -x
            
    def getRankOfNumber(self, x: int) -> int:
        x += 1
        res = 0
        while x:
            res += self.tree[x]
            x -= -x & x
        return res

LeetCode307 区域和检索-区间可修改
BIT数组初始化有点技巧，需要多看看加深理解

class NumArray:

    def __init__(self, nums: List[int]):
        self.tree = [0] + nums
        n = len(nums)

        for i in range(1, n + 1):
            j = i + self.lowbit(i)
            if j < n + 1:
                self.tree[j] += self.tree[i]

    def update(self, index: int, val: int) -> None:
        prev = self.sumRange(index, index)
        index += 1
        val -= prev
        while index < len(self.tree):
            self.tree[index] += val
            index += self.lowbit(index)
            
    def sumRange(self, left: int, right: int) -> int:
        return self.presum(right) - self.presum(left - 1)

    def lowbit(self, x: int) -> int:
        return x & -x

    def presum(self, index: int) -> int:
        index += 1
        res = 0
        while index:
            res += self.tree[index]
            index -= self.lowbit(index)
        return res