线段树的本质是由对元数据的区间计算结果缓存组成平衡二叉树(不一定是完全二叉树)
缓存结果取决于给定的融合算法,在jdk1.8+
中,这个算法可被标记为BinaryOperator
类型
线段树的元数据和缓存数据均可由数组保存,但不一定是完全二叉树,会存在浪费空间的可能
数组的可靠空间大小为元数据个数的4倍,推算过程如下
区间操作 | 数组 | 线段树 |
---|---|---|
更新 | O( n n n) | O( log ( n ) \log(n) log(n)) |
查询 | O( n n n) | O( log ( n ) \log(n) log(n)) |
Github源码
元数据与树,均用数组表示:
public class SegmentTree<E> {
private E[] tree;
private E[] data;
private BinaryOperator<E> merger;
}
private int left(int index) {
return (index << 1) + 1;
}
private int right(int index) {
return left(index) + 1;
}
private int mid(int l, int r) {
return l + ((r - l) >> 1);
}
初始化,区间操作时均涉及此方法。可以查看动画演示
private void buildSegmentTree(int index, int l, int r) {
// 递归到底了,l==r意味着没有孩子节点了,没必要融合,直接赋值
if (l == r) {
tree[index] = data[l];
return;
}
int left = left(index);
int right = right(index);
int mid = mid(l, r);
buildSegmentTree(left, l, mid);
buildSegmentTree(right, mid + 1, r);
tree[index] = merger.apply(tree[left], tree[right]);
}
public E query(int left, int right) {
// 此处忽略索引检查
return query(0, 0, size() - 1, left, right);
}
/**
* 根据左右范围索引值[lq,rq]递归查询
* [l,r]肯定是包含[lq,rq]的
*
* @param index 当前片段树索引
* @param l 当前片段树索引下支持的最小索引值
* @param r 当前片段树索引下支持的最大索引值
* @param lq 结果需要的最小索引值
* @param rq 结果需要的最大索引值
* @return 返回索引范围在(lq, rq)的结果融合值
*/
private E query(int index, int l, int r, int lq, int rq) {
if (l == lq && r == rq) {
return tree[index];
}
int lc = left(index);
int rc = right(index);
int mid = mid(l, r);
if (lq > mid) {
return query(rc, mid + 1, r, lq, rq);
}
if (rq <= mid) {
return query(lc, l, mid, lq, rq);
}
// 左子树融合结果
E lr = query(lc, l, mid, lq, mid);
// 右子树融合结果
E rr = query(rc, mid + 1, r, mid + 1, rq);
return merger.apply(lr, rr);
}
单节点更新是指只更新线段树的某个叶子节点的值,但是更新叶子节点会对其父节点的值产生影响,因此更新子节点后,要回溯更新其父节点的值。
public void set(int index, E e) {
set(0, 0, size() - 1, index, e);
}
private void set(int treeIndex, int l, int r, int index, E e) {
if (l == r) {
tree[treeIndex] = e;
return;
}
int mid = mid(l, r);
int left = left(treeIndex);
int right = right(treeIndex);
if (index > mid) {
set(right, mid + 1, r, index, e);
} else {
set(left, l, mid, index, e);
}
tree[treeIndex] = merger.apply(tree[left], tree[right]);
}
这里面的treeIndex
初始值设置为0是没有问题的,后期(行13和行15)会被动态替换掉。
区间更新类似于Arrays.fill(...)
这里给出多态形式,分别是值更新
和规则更新
public void fill(E e) {
fill(x -> e);
}
public void fill(E e, int l, int r) {
Arrays.fill(data, l, r, e);
buildSegmentTree(0, l, r);
}
public void fill(Function<E, E> function) {
fill(function, 0, size() - 1);
}
public void fill(Function<E, E> function, int l, int r) {
if (l == r) {
set(l, function.apply(data[l]));
return;
}
for (int i = l; i <= r; i++) {
data[i] = function.apply(data[i]);
}
buildSegmentTree(0, l, r);
}
区间更新还有个懒惰标记
的概念,听说是其精髓,这里不实现,可以参考线段树的懒惰标记小笔记