动态开点线段树说明
作者：Grey
原文地址：
说明
针对普通线段树，参考使用线段树解决数组任意区间元素修改问题
在普通线段树中，线段树在预处理的时候，需要申请 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 <= mid) { // l ~ mid if (c.left == null) { c.left = new Node(); } add(c.left, l, mid, i, v); } else { // mid + 1 ~ r if (c.right == null) { c.right = new Node(); } add(c.right, mid + 1, r, i, v); } c.sum = (c.left != null ? c.left.sum : 0) + (c.right != null ? c.right.sum : 0); } } 这个add方法的几个参数分别代表
c : 表示 add 操作的区间代表节点是多少
l...r 表示任务区间，由于初始化 size，所以在调用公开的 add 方法时候，l = 1， r = size，表示在初始化区间范围内操作。
i：表示要操作的位置
v： 表示要增加的值
整个 add 私有方法逻辑也比较简单，核心代码
// i 在节点左边 if (i <= mid) { // 如果节点的左树为空，则建立新节点 if (c.left == null) { c.left = new Node(); } add(c.left, l, mid, i, v); } else { // i 在节点右边 // 如果节点右树为空，则建立新节点 if (c.right == null) { c.right = new Node(); } add(c.right, mid + 1, r, i, v); } // 最后当前节点要汇聚左右树的结果，之所以要判空是因为左右树可能不需要都建立出来 c.sum = (c.left != null ? c.left.sum : 0) + (c.right != null ? c.right.sum : 0); 查询方法的逻辑也比较简单
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 <= l && r <= e) { return c.sum; } int mid = (l + r) / 2; if (e <= mid) { return query(c.left, l, mid, s, e); } else 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 <= l && r <= e) { return c.sum; } // 否则，去左右区间拿累加和 int mid = (l + r) / 2; if (e <= mid) { return query(c.left, l, mid, s, e); } else 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) { // l ~ mid if (c.left == null) { c.left = new Node(); } add(c.left, l, mid, i, v); } else { // mid + 1 ~ r if (c.right == null) { c.right = new Node(); } add(c.right, mid + 1, r, i, v); } c.sum = (c.left != null ? c.left.sum : 0) + (c.right != null ? c.right.sum : 0); } } // s~e范围的累加和 public int query(int s, int e) { return query(root, 1, size, s, e); } // 当前节点c，表达的范围l~r // 收到了一个任务，s~e这个任务！ // s~e这个任务，影响了多少l~r范围的数，把答案返回！ private int query(Node c, int l, int r, int s, int e) { if (c == null) { return 0; } if (s <= l && r <= e) { return c.sum; } int mid = (l + r) / 2; if (e <= mid) { return query(c.left, l, mid, s, e); } else 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 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 <= e; i++) { sum += arr[i]; } return sum; } } public static void main(String[] args) { int size = 10000; int testTime = 50000; int value = 500; DynamicSegmentTree dst = new DynamicSegmentTree(size); Right right = new Right(size); System.out.println("测试开始"); for (int k = 0; k < testTime; k++) { if (Math.random() < 0.5) { int i = (int) (Math.random() * size) + 1; int v = (int) (Math.random() * value); dst.add(i, v); right.add(i, v); } else { int a = (int) (Math.random() * size) + 1; int b = (int) (Math.random() * size) + 1; int s = Math.min(a, b); int e = Math.max(a, b); int ans1 = dst.query(s, e); int ans2 = right.query(s, e); if (ans1 != ans2) { System.out.println("出错了!"); System.out.println(ans1); System.out.println(ans2); } } } System.out.println("测试结束"); } } 接下来看一个使用动态开点线段树来解决的一个问题
即：LeetCode 315. Count of Smaller Numbers After Self
注：本题可以用归并排序，树状数组，有序表来解，也可以用动态开点线段树来解。
主要思路如下
以如下数组为例来说明
nums = {5,8,7,4,2,9} 首先，初始化一个 List，这个 List 用于存放每个位置的右侧比其小的数有几个，List 的大小和原始数组一样
List<Integer> ans = new ArrayList<>(nums.length); ans 在初始化的时候，均设置为 0 ，表示，所有位置都还没计算过。
ans = [0,0,0,0,0,0] 接下来对原始数组进行排序（注意：排序的时候，不能只使用值来排序，要带上这个值所在的位置，这样排序后才不会丢失该值在原始数组中的位置信息）
int[][] arr = new int[n][]; for (int i = 0; i < n; i++) { // 要记录值，也要记录位置，防止排序后找不到值对应的位置在哪里 arr[i] = new int[] {nums[i], i}; } // 排序按值排序 Arrays.sort(arr, Comparator.comparingInt(a -> 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<Integer> countSmaller(int[] nums) { if (nums == null || nums.length == 0) { return new ArrayList<>(); } int n = nums.length; List<Integer> ans = new ArrayList<>(n); for (int i = 0; i < n; i++) { ans.add(0); } int[][] arr = new int[n][]; for (int i = 0; i < n; i++) { // 要记录值，也要记录位置，防止排序后找不到值对应的位置在哪里 arr[i] = new int[] {nums[i], i}; } Arrays.sort(arr, Comparator.comparingInt(a -> 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 结构就是前面提到的动态开点线段树的实现。
