数据结构笔记（5）：线段树和树状数组模板

最新推荐文章于 2023-07-26 14:07:02 发布
最新推荐文章于 2023-07-26 14:07:02 发布
阅读量159 收藏
点赞数
分类专栏： 数据结构 ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gh6267/article/details/108568950
版权

树状数组模板

struct fenwick {
    int* data;
    int n;
    fenwick(int _n) : n(_n) {
      data = new int[n];
      for (int i = 0; i < n; i++) data[i] = 0;
    }
    ~fenwick() {
      delete[] data;
    }

    void add(int x) {
      while (x < n) {
        data[x]++;
        x += (x & -x);
      }
    }

    int get(int x) {
      int ans = 0;
      while (x > 0) {
        ans += data[x];
        x -= (x & -x);
      }
      return ans;
    }
  };

例题：LeetCode315. 计算右侧小于当前元素的个数

给定一个整数数组 nums，按要求返回一个新数组 counts。数组 counts 有该性质： counts[i] 的值是  nums[i] 右侧小于 nums[i] 的元素的数量。

 

示例：

输入：nums = [5,2,6,1]
输出：[2,1,1,0] 
解释：
5 的右侧有 2 个更小的元素 (2 和 1)
2 的右侧仅有 1 个更小的元素 (1)
6 的右侧有 1 个更小的元素 (1)
1 的右侧有 0 个更小的元素
 

提示：

0 <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4

题解：树状数组+离散化

class Solution {
public:
  struct fenwick {
    int* data;
    int n;
    fenwick(int _n) : n(_n) {
      data = new int[n];
      for (int i = 0; i < n; i++) data[i] = 0;
    }
    ~fenwick() {
      delete[] data;
    }

    void add(int x) {
      while (x < n) {
        data[x]++;
        x += (x & -x);
      }
    }

    int get(int x) {
      int ans = 0;
      while (x > 0) {
        ans += data[x];
        x -= (x & -x);
      }
      return ans;
    }
  };
  vector<int> countSmaller(vector<int>& nums) {
    int sz = (int)nums.size();
    vector<int> t(nums);
    vector<int> r(sz, 0);
    sort(t.begin(), t.end());
    for (int& n : nums) {
      n = lower_bound(t.begin(), t.end(), n) - t.begin() + 1;
    }
    fenwick* fwk = new fenwick(sz + 1);
    for (int i = sz - 1; i >= 0; i--) {
      r[i] = fwk->get(nums[i] - 1);
      fwk->add(nums[i]);
    }
    return r;
  }
};

线段树单点更新、区间查询 模板

template<class T>
class SegmentTree {
public:
  //SegmentTree();
  SegmentTree(T* arr, int n, function<T(T, T)> fun) {
    this->len = n;
    this->func = fun;
    data = new T[n];
    tree = new T[4 * n];
    for (int i = 0; i < n; i++) {
      data[i] = arr[i];
    }
    buildSegment(0, 0, n - 1);
  }
  T get(int index){
    if (index < 0 || index >= this->len) {
      throw exception();
    }
    return data[index];
  }
  int getSize(){
    return this->len;
  }
  T query(int queryL, int queryR) {
    return __query(0, 0, len - 1, queryL, queryR);
  }
  void modify(int index, T e) {
    data[index] = e;
    __modify(0, 0, len - 1, index, e);
  }
  virtual ~SegmentTree() {
    delete[] data;
    delete[] tree;
  }
private:
  void __modify(int treeIndex, int l, int r, int index, T 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) {
      __modify(leftTreeIndex, l, mid, index, e);
    } else {
      __modify(rightTreeIndex, mid + 1, r, index, e);
    }
    tree[treeIndex] = func(tree[leftTreeIndex], tree[rightTreeIndex]);
  }
  T __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);
    } else {
      T leftResult = __query(leftTreeIndex, l, mid, queryL, mid);
      T rightResult = __query(rightTreeIndex, mid + 1, r, mid + 1, queryR);
      return func(leftResult, rightResult);
    }
  }
  int leftChild(int index) {
    return 2 * index + 1;
  }
  int rightChild(int index) {
    return 2 * index + 2;
  }
  void buildSegment(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 - l) / 2;
    buildSegment(leftTreeIndex, l, mid);
    buildSegment(rightTreeIndex, mid + 1, r);
    tree[treeIndex] = func(tree[leftTreeIndex], tree[rightTreeIndex]);
  }
private:
  int len;
  T* data;
  T* tree;
  function<T(T, T)> func;
};

例题：307. 区域和检索 - 数组可修改

给定一个整数数组  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 函数的调用次数是均匀分布的。

 

题解：线段树的单点更新和区间查询

template<class T>
class SegmentTree {
public:
  //SegmentTree();
  SegmentTree(T* arr, int n, function<T(T, T)> fun) {
    this->len = n;
    this->func = fun;
    data = new T[n];
    tree = new T[4 * n];
    for (int i = 0; i < n; i++) {
      data[i] = arr[i];
    }
    buildSegment(0, 0, n - 1);
  }
  T get(int index){
    if (index < 0 || index >= this->len) {
      throw exception();
    }
    return data[index];
  }
  int getSize(){
    return this->len;
  }
  T query(int queryL, int queryR) {
    return __query(0, 0, len - 1, queryL, queryR);
  }
  void modify(int index, T e) {
    data[index] = e;
    __modify(0, 0, len - 1, index, e);
  }
  virtual ~SegmentTree() {
    delete[] data;
    delete[] tree;
  }
private:
  void __modify(int treeIndex, int l, int r, int index, T 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) {
      __modify(leftTreeIndex, l, mid, index, e);
    } else {
      __modify(rightTreeIndex, mid + 1, r, index, e);
    }
    tree[treeIndex] = func(tree[leftTreeIndex], tree[rightTreeIndex]);
  }
  T __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);
    } else {
      T leftResult = __query(leftTreeIndex, l, mid, queryL, mid);
      T rightResult = __query(rightTreeIndex, mid + 1, r, mid + 1, queryR);
      return func(leftResult, rightResult);
    }
  }
  int leftChild(int index) {
    return 2 * index + 1;
  }
  int rightChild(int index) {
    return 2 * index + 2;
  }
  void buildSegment(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 - l) / 2;
    buildSegment(leftTreeIndex, l, mid);
    buildSegment(rightTreeIndex, mid + 1, r);
    tree[treeIndex] = func(tree[leftTreeIndex], tree[rightTreeIndex]);
  }
private:
  int len;
  T* data;
  T* tree;
  function<T(T, T)> func;
};
class NumArray {
public:
    NumArray(vector<int>& nums) {
        int n = (int)nums.size();
        if (n > 0) {
            int* a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = nums[i];
            }
            segTree = new SegmentTree<int>(a, n, [&](int x, int y){return x + y;});
        }
    }
    
    void update(int i, int val) {
        if (segTree == NULL) {
            return;
        }
        segTree->modify(i, val);
    }
    
    int sumRange(int i, int j) {
        if (segTree == NULL) {
            return 0;
        }
        return segTree->query(i, j);
    }
private:
    SegmentTree<int>* segTree;
};

/**
 * 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);
 */

线段树区间更新区间查询模板

class segtree {
public:
  int n;
  int* data;
  long long* tree;
  long long* lazy;
  segtree(int* arr, int _n) : n (_n) {
    data = new int[_n];
    tree = new long long[_n * 4];
    lazy = new long long[_n * 4];
    fill_n(tree, _n * 4, 0);
    fill_n(lazy, _n * 4, 0);
    for (int i = 0; i < n; i++) {
      data[i] = arr[i];
    }
    build(0, 0, n - 1);
  }
  ~segtree() {
    delete []data;
    delete []tree;
    delete []lazy;
  }
  void build(int tId, int l, int r) {
    if (l == r) {
      tree[tId] = data[l];
      lazy[tId] = 0;
      return;
    }
    int mid = (l + r) >> 1;
    build((tId << 1) | 1, l, mid);
    build((tId << 1) + 2, mid + 1, r);
    push(tId);
  }
  void modify(int tId, int l, int r, int ml, int mr, int v) {
    if (ml <= l && r <= mr) {
      tree[tId] += (r - l + 1) * v;
      lazy[tId] += v;
      return;
    }
    if (lazy[tId] != 0) {
      pull(tId, l, r);
    }
    int mid = (l + r) >> 1;
    if (mr <= mid) {
      modify((tId * 2) + 1, l, mid, ml, mr, v);
    } else if (ml > mid) {
      modify((tId * 2) + 2, mid + 1, r, ml, mr, v);
    } else {
      modify((tId * 2) + 1, l, mid, ml, mid, v);
      modify((tId * 2) + 2, mid + 1, r, mid + 1, mr, v);
    }
    push(tId);
  }
  long long get(int tId, int l, int r, int gl, int gr) {
    if (gl <= l && r <= gr) {
      return tree[tId];
    }
    if (lazy[tId]) {
      pull(tId, l, r);
    }
    int mid = (l + r) >> 1;
    if (gr <= mid) {
      return get((tId * 2) + 1, l, mid, gl, gr);
    } else if (gl > mid) {
      return get((tId * 2) + 2, mid + 1, r, gl, gr);
    } else {
      return get((tId * 2) + 1, l, mid, gl, mid) + get((tId * 2) + 2, mid + 1, r, mid + 1, gr);
    }
  }
  void pull(int tId, int l, int r) {
    int mid = (l + r) / 2;
    tree[(tId * 2) + 1] += (mid - l + 1) * lazy[tId];
    tree[(tId * 2) + 2] += (r - mid) * lazy[tId];
    lazy[(tId * 2) + 1] += lazy[tId];
    lazy[(tId * 2) + 2] += lazy[tId];
    lazy[tId] = 0;
  }
  void push(int tId) {
    tree[tId] = tree[(tId * 2) + 1] + tree[(tId * 2) + 2];
  }
};

例题：poj3468

A Simple Problem with Integers

Description

You have N integers, A1, A2, ... , AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval.

Input

The first line contains two numbers N and Q. 1 ≤ N,Q ≤ 100000.
The second line contains N numbers, the initial values of A1, A2, ... , AN. -1000000000 ≤ Ai ≤ 1000000000.
Each of the next Q lines represents an operation.
"C a b c" means adding c to each of Aa, Aa+1, ... , Ab. -10000 ≤ c ≤ 10000.
"Q a b" means querying the sum of Aa, Aa+1, ... , Ab.

Output

You need to answer all Q commands in order. One answer in a line.

Sample Input

10 5
1 2 3 4 5 6 7 8 9 10
Q 4 4
Q 1 10
Q 2 4
C 3 6 3
Q 2 4

Sample Output

4
55
9
15

Hint

The sums may exceed the range of 32-bit integers.

#include <iostream>
#include <cstdio>

using namespace std;

class segtree {
public:
  int n;
  int* data;
  long long* tree;
  long long* lazy;
  segtree(int* arr, int _n) : n (_n) {
    data = new int[_n];
    tree = new long long[_n * 4];
    lazy = new long long[_n * 4];
    fill_n(tree, _n * 4, 0);
    fill_n(lazy, _n * 4, 0);
    for (int i = 0; i < n; i++) {
      data[i] = arr[i];
    }
    build(0, 0, n - 1);
  }
  ~segtree() {
    delete []data;
    delete []tree;
    delete []lazy;
  }
  void build(int tId, int l, int r) {
    if (l == r) {
      tree[tId] = data[l];
      lazy[tId] = 0;
      return;
    }
    int mid = (l + r) >> 1;
    build((tId << 1) | 1, l, mid);
    build((tId << 1) + 2, mid + 1, r);
    push(tId);
  }
  void modify(int tId, int l, int r, int ml, int mr, int v) {
    if (ml <= l && r <= mr) {
      tree[tId] += (r - l + 1) * v;
      lazy[tId] += v;
      return;
    }
    if (lazy[tId] != 0) {
      pull(tId, l, r);
    }
    int mid = (l + r) >> 1;
    if (mr <= mid) {
      modify((tId * 2) + 1, l, mid, ml, mr, v);
    } else if (ml > mid) {
      modify((tId * 2) + 2, mid + 1, r, ml, mr, v);
    } else {
      modify((tId * 2) + 1, l, mid, ml, mid, v);
      modify((tId * 2) + 2, mid + 1, r, mid + 1, mr, v);
    }
    push(tId);
  }
  long long get(int tId, int l, int r, int gl, int gr) {
    if (gl <= l && r <= gr) {
      return tree[tId];
    }
    if (lazy[tId]) {
      pull(tId, l, r);
    }
    int mid = (l + r) >> 1;
    if (gr <= mid) {
      return get((tId * 2) + 1, l, mid, gl, gr);
    } else if (gl > mid) {
      return get((tId * 2) + 2, mid + 1, r, gl, gr);
    } else {
      return get((tId * 2) + 1, l, mid, gl, mid) + get((tId * 2) + 2, mid + 1, r, mid + 1, gr);
    }
  }
  void pull(int tId, int l, int r) {
    int mid = (l + r) / 2;
    tree[(tId * 2) + 1] += (mid - l + 1) * lazy[tId];
    tree[(tId * 2) + 2] += (r - mid) * lazy[tId];
    lazy[(tId * 2) + 1] += lazy[tId];
    lazy[(tId * 2) + 2] += lazy[tId];
    lazy[tId] = 0;
  }
  void push(int tId) {
    tree[tId] = tree[(tId * 2) + 1] + tree[(tId * 2) + 2];
  }
};

int main() {
  int n, q;
  scanf("%d %d", &n, &q);
  int* arr = new int[n];
  for (int i = 0; i < n; i++) {
    scanf("%d", &arr[i]);
  }
  segtree st(arr, n);
  while (q--) {
    char str[10];
    scanf("%s", str);
    int l, r;
    scanf("%d %d", &l, &r);
    l--;
    r--;
    if (str[0] == 'Q') {
      cout << st.get(0, 0, n - 1, l, r) << "\n";
    } else {
      int val;
      scanf("%d", &val);
      st.modify(0, 0, n - 1, l, r, val);
    }
  }
  return 0;
}

 

hansy2015
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树状数组模版
yan_qiu_ynlchrz的博客
04-21 52
一维树状数组 struct Fenwick { LL d[N]; void init(){ rep(i, n + 1) d[i] = 0; } void modify(int x, LL val){ while (x <= n){ d[x] += val; x += x & -x; } } LL query(int x){ LL ret = 0; while (x){ ret += d[x]; x -= x & -x; } return ret; }
数据结构笔记：树
12-14
数据结构中的树是一种重要的抽象数据结构，...了解并熟练掌握树的数据结构及其应用是计算机科学中的基础，对于算法设计和数据处理至关重要。通过理解这些概念，开发者能够更好地解决复杂问题，优化数据存储和检索效率。
[ACM模块化模板] 树状数组-Fenwick
Abmcar的博客
01-02 368
昨天在codeforces看tourist代码是看到了这个Fenwick,看了半天才发下这是个树状数组 突然间就萌生了写一些常用模板封装起来的打算 git仓库链接:https://github.com/abmcar/ACM/tree/master/template template <typename T> class Fenwick { public: Fenwick(int _n) : n(_n) { fenw.resize(n + 1); }
b+树时间复杂度_前端大神用的学习笔记：线段树和树状数组
weixin_39808893的博客
11-20 500
全文篇幅较长，细心理解一定会有收获的♪(^∇^*)。1|0线段树1|1一些概念    线段树是一种二叉搜索树，每一个结点都是一个区间(也可以叫作线段，可以有单点的叶子结点)，有一张比较形象的图如下(侵删)：    可以看出，线段树除根结点外的其他节点，都由其父节点二分长度得到，这种优秀的性质使得我们可以把它近似看成是一棵完全二叉树。而完全二叉树可以用一个数组表示：设根节点下标为 nownow (在...
【真香笔记இ௰இ】线段树和树状数组
crane_起重菜鸡的博客
08-16 202
文章开头第一句：回家旅游一时爽，______________ 。 Day4-线段树和树状数组（简单） Day5-线段树和树状数组（进阶） 树状数组 是什么：是数组，原理图： 为什么：适用于单点更新+区间查询 怎么弄： 两个数组：A是原数据数组，C是树状数组 两个函数 线段树 是什么：是树，原理图： 为什么：使用条件：满足区间加法。（即区间[L,R]的答案可以由[L,M]和[M+1,R]得到） ...
算法笔记：树套树（树状数组套主席树+线段树套平衡树）
I1I1I11I1I1的博客
02-27 2554
从我短暂的ACMer生涯当中学到一件事———越是玩弄数据结构，就越会发现树的能力是有极限的… 除非超越树。 那就再套一层树！Wryyyyy！！！ 最近打算研究一波树套树，平衡树怎么套还没搞懂，目前学习了一点套主席树的方法，平衡树的内容可能也会补在这吧。 ...
【数据结构】树状数组和线段树
Tikitian的博客
07-26 414
【数据结构】树状数组和线段树
寒假笔记·线段树与树状数组
weixin_43918350的博客
02-27 307
线段树与树状数组 线段树和树状数组，是两个十分相似的数据结构。他们能使对一个区间的数修改以及查询的速度提升许多。两个结构本质相同，各有优缺点。 线段树 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN）。 比如讲一个有4个数的线段树，是长这个样子的： ...
数据结构学习笔记 - 线段树（基础）
haobowen的博客
02-09 540
前言 众所周知线段树这个数据结构，比较麻烦。但在解决类似于区间修改和查询这种问题的时候会很方便，其实也没有那么方便。具体来说，之所以不用暴力或者树状数组来进行上述操作，是因为有的题目对算法效率要求高，普通的算法就不行了。总结来说，我们在学习线段树之前，应该要理解我们为什么要学线段树，学了之后在哪种情况下会用到，和怎么把模板变成题目要求的代码。这些问题是我们要考虑到的。 定义 线段树是一种基于分治思想的二叉树结构，用于在区间上进行信息统计。与按照二进制（2的次幂）进行区间划分的树状数组相比，线段树是一种
[集训笔记5th]树状数组与线段树的入门
__surtr的博客
08-06 133
树状数组 树状数组（Binary Indexed Trees）是一种由于维护序列前缀和的数据结构。对于给定序列aaa，我们建立一个数组ccc，其中c[x]c[x]c[x]保存序列aaa的区间[x−lowbit(x)+1,x][x - lowbit(x)+1, x][x−lowbit(x)+1,x]中所有数的和，即∑i=x−lowbit(x)+1xa[i]\sum^{x}_{i = x-lowbit...
线段树学习笔记（个人整理模板）
12-25
个人线段树学习整理
数据结构笔记的记录和心得
05-06
队列是先进先出（FIFO）的数据结构，适用于任务调度和数据传输。 2. **树形数据结构**：树是一种非线性的数据结构，由节点和连接这些节点的边构成。二叉树是最常见的树类型，每个节点最多有两个子节点。二叉搜索树...
数据结构学习笔记——使用draw.io绘制的树结构图
04-29
树结构 draw.io图 二叉树、顺序树、树的链式存储结构、树的数组存储结构、欧拉树 绘图软件为免费开源软件draw.io
《数据结构与算法分析：C语言描述》读书笔记模板.pptx
09-15
《数据结构与算法分析：C语言描述》读书笔记模板.pptx是一本经典的数据结构与算法分析教材，作者Mark Allen Weiss对算法和数据结构方面有着深入的研究和实践经验。本书以C语言为基础，通过实际的编程实践来阐述抽象...
Crypto_30_vHsm_Types.h
07-09
Crypto_30_vHsm_Types
vmware虚拟机安装教程.pdf
最新发布
07-10
VMware虚拟机安装教程是一个详细且系统的过程，涵盖了从下载、安装到配置虚拟机的多个步骤。以下是一个详尽的VMware虚拟机安装教程，旨在帮助用户顺利搭建自己的虚拟环境。
11111111111
07-10
11111111111
nvidia平台torch-2.0.0.nv23.05-cp38-cp38-linux-aarch64安装包
07-09
特定版本的 PyTorch 包，专为 NVIDIA 的 Jetson 平台优化，并且适用于使用 Python 3.8 的 ARM64 架构（如 NVIDIA Jetson 系列设备）上的 Linux 操作系统 PyTorch 是一个广泛使用的开源机器学习库，主要用于深度学习和神经网络的构建和训练。它由 Facebook's AI Research Lab (FAIR) 开发和维护。 提供了强大的张量计算功能以及支持 GPU 加速的计算能力。
初学数据结构时候做的练习题集合笔记
04-02
这些笔记涵盖了数据结构的基础概念与实践应用，特别是针对数组和链表这两种常用的数据结构进行了深入的分析。 首先，数组的优势在于查找效率高，因为元素是连续存储的，可以通过计算基地址加上元素大小的倍数快速...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值