动态开点线段树说明

动态开点线段树说明

作者:Grey

原文地址:

博客园:动态开点线段树说明

CSDN:动态开点线段树说明

说明

针对普通线段树,参考使用线段树解决数组任意区间元素修改问题

在普通线段树中,线段树在预处理的时候,需要申请 4 倍大小的数组空间来存放划分的区域,

而本文介绍的动态开点线段树,它和普通线段树的区别是,动态开点线段树不需要像普通线段树那样提前申请 4 倍大小的数据空间来存放划分区域,等到实际使用的时候,再来申请。

先讲一种比较简单的动态开点线段树,这种线段树只支持单点的更新和查询。

即支持如下两个方法

void add(i, v);

该方法表示在 i 上的值加上 v;

int query(int s, int e)

该方法用于获取 s 到 e 区间内的累加和信息。

该线段树只需要定义一个节点数据结构即可

  public static class Node {
    public int sum;
    public Node left;
    public Node right;
  }

其中 sum 表示 Node 所在区间的累加和,left 表示节点左孩子信息,right 表示节点右孩子信息。

线段树初始化过程也只需要

  public static class DynamicSegmentTree {
    public Node root;
    public int size;

    public DynamicSegmentTree(int max) {
      root = new Node();
      size = max;
    }
  }

size 表示线段树支持的范围,这个范围从线段树一开始初始化的时候设定好(编号1 到 编号size就是区间范围)。和普通线段树不一样的地方在于,节点只建立了 root 节点,未初始化所有区间。

接下来看add方法,

    public void add(int i, int v) {
      add(root, 1, size, i, v);
    }

这个方法调用了线段树内部的私有add方法,

    // c-> cur 当前节点!表达的范围 l~r
    // i位置的数,增加v
    // 潜台词!i一定在l~r范围上!
    private void add(Node c, int l, int r, int i, int v) {
      if (l == r) {
        c.sum += v;
      } else { // l~r 还可以划分
        int mid = (l + r) / 2;
        if (i 

这个add方法的几个参数分别代表

c : 表示 add 操作的区间代表节点是多少

l...r 表示任务区间,由于初始化 size,所以在调用公开的 add 方法时候,l = 1, r = size,表示在初始化区间范围内操作。

i:表示要操作的位置

v: 表示要增加的值

整个 add 私有方法逻辑也比较简单,核心代码

        // i 在节点左边
        if (i 

查询方法的逻辑也比较简单

    public int query(int s, int e) {
      return query(root, 1, size, s, e);
    }

调用了内部的一个私有 query 方法,

    private int query(Node c, int l, int r, int s, int e) {
      if (c == null) {
        return 0;
      }
      if (s  mid) {
        return query(c.right, mid + 1, r, s, e);
      } else {
        return query(c.left, l, mid, s, e) + query(c.right, mid + 1, r, s, e);
      }
    }
  }

这个私有方法的几个参数说明如下

c:表示要操作的线段树的代表节点是什么;

l...r 是划分的区间范围

s...e 是任务的区间范围

核心逻辑如下

// 如果任务的区间已经包含了划分的区间,直接返回结果
      if (s  mid) {
        return query(c.right, mid + 1, r, s, e);
      } else {
        // 整合成自己的累加和返回
        return query(c.left, l, mid, s, e) + query(c.right, mid + 1, r, s, e);
      }

整个支持单点更新的动态线段树的完整代码如下(含对数器代码)

// 只支持单点增加 + 范围查询的动态开点线段树(累加和)
public class Code01_DynamicSegmentTree {

  public static class Node {
    public int sum;
    public Node left;
    public Node right;
  }

  // arr[0] -> 1
  // 线段树,从1开始下标!
  public static class DynamicSegmentTree {
    public Node root;
    public int size;

    public DynamicSegmentTree(int max) {
      root = new Node();
      size = max;
    }

    // 下标i这个位置的数,增加v
    public void add(int i, int v) {
      add(root, 1, size, i, v);
    }

    // c-> cur 当前节点!表达的范围 l~r
    // i位置的数,增加v
    // 潜台词!i一定在l~r范围上!
    private void add(Node c, int l, int r, int i, int v) {
      if (l == r) {
        c.sum += v;
      } else { // l~r 还可以划分
        int mid = (l + r) / 2;
        if (i  mid) {
        return query(c.right, mid + 1, r, s, e);
      } else {
        return query(c.left, l, mid, s, e) + query(c.right, mid + 1, r, s, e);
      }
    }
  }

  public static class Right {
    public int[] arr;

    public Right(int size) {
      arr = new int[size + 1];
    }

    public void add(int i, int v) {
      arr[i] += v;
    }

    public int query(int s, int e) {
      int sum = 0;
      for (int i = s; i 

接下来看一个使用动态开点线段树来解决的一个问题

即:LeetCode 315. Count of Smaller Numbers After Self

注:本题可以用归并排序,树状数组,有序表来解,也可以用动态开点线段树来解。

主要思路如下

以如下数组为例来说明

nums = {5,8,7,4,2,9}

首先,初始化一个 List,这个 List 用于存放每个位置的右侧比其小的数有几个,List 的大小和原始数组一样

List ans = new ArrayList(nums.length);

ans 在初始化的时候,均设置为 0 ,表示,所有位置都还没计算过。

ans = [0,0,0,0,0,0]

接下来对原始数组进行排序(注意:排序的时候,不能只使用值来排序,要带上这个值所在的位置,这样排序后才不会丢失该值在原始数组中的位置信息)

    int[][] arr = new int[n][];
    for (int i = 0; i  a[0]));

排序后,arr 按如下顺序组织

{值:2,原始位置:4}
{值:4,原始位置:3}
{值:5,原始位置:0}
{值:7,原始位置:2}
{值:8,原始位置:1}
{值:9,原始位置:5}

接下来初始化开点线段树,线段树的size就是原始数组的大小,且每个位置都是0,

按顺序遍历这个 arr 数组,最小值 2 被取出,其原始位置是 4,且 4 号位置右侧没有比自己更小的数,接下来在开点线段树中把把 4 号位置的值加1,表示 4 号位置被处理过了,在线段树中查4号位置以后并没有任何标记记录,说明没有比这个数更小的数了,直接设置4号位置的ans值为0

ans = [0,0,0,0,0,0]

线段树中

seg = [0,0,0,0,1,0]

接下来是 3 号位置的4,在线段树中查到,有一个比它小的,直接设置到 ans 中,然后在线段树中把 3 号位置也标记为 1,说明处理过,

ans = [0,0,0,1,0,0]

线段树中

seg = [0,0,0,1,1,0]

接下来是0号位置的5, 在线段树中,查到右侧有两个标记过的,说明有两个比它小的数,直接在 ans 中把 0 号位置设置为 2, 然后在线段树中把 0 号位置标记为 1 ,说明处理过,此时

ans = [2,0,0,1,0,0]

线段树中

seg = [1,0,0,1,1,0]

接下来是 2 号位置的 7, 在线段树中,查到右侧有两个标记过的,说明有两个比它小的数,直接在 ans 中把 2 号位置设置为 2, 然后在线段树中把 2 号位置标记为 1 ,说明处理过,此时

ans = [2,0,2,1,0,0]

线段树中

seg = [1,0,1,1,1,0]

接下来是 1 号位置的 8, 在线段树中,查到右侧有三个标记过的,说明有三个比它小的数,直接在 ans 中把 1 号位置设置为 3, 然后在线段树中把 1 号位置标记为 1 ,说明处理过,此时

ans = [2,3,2,1,0,0]

线段树中

seg = [1,1,1,1,1,0]

接下来是 5 号位置的 9, 在线段树中,查到右侧没有标记过的,说明没有比它小的数,直接在 ans 中把 5 号位置设置为 0, 然后在线段树中把 5 号位置标记为 1 ,说明处理过,此时

ans = [2,3,2,1,0,0]

线段树中

seg = [1,1,1,1,1,1]

以上就是整个流程。

核心代码如下

  public static List countSmaller(int[] nums) {
    if (nums == null || nums.length == 0) {
      return new ArrayList();
    }
    int n = nums.length;
    List ans = new ArrayList(n);
    for (int i = 0; i  a[0]));
    DynamicSegmentTree dst = new DynamicSegmentTree(n);
    for (int[] num : arr) {
      ans.set(num[1], dst.query(num[1] + 1, n));
      dst.add(num[1] + 1, 1);
    }
    return ans;
  }

其中 DynamicSegmentTree 结构就是前面提到的动态开点线段树的实现。

更多

算法和数据结构笔记

文章来源于互联网:动态开点线段树说明

THE END
分享
二维码