为什么要使用线段树?
区间查询;区间染色的统计;太空区间天体总量统计等等。
对于给定的区间(可用固定数组存储数据):
更新:更新区间中一个元素或者一个区间的值;
查询一个区间[i,j]的最大值,最小值,或者区间数字和等等;
线段树是平衡二叉树,所以我们存储线段树的元素可以用静态数组存储
如果我们要在线段树中存储n个元素,那么这个数组我们需要开4n个区间,因为最坏情况下线段树的最后一层只有一个节点,其他全部为null;
实现线段树
public class SegmentTree<E>{
private E[] data;
private E[] tree;
private Merger<E> merger;
public SegmentTree(E[] arr,Merger<E> merger){
this.merger = merger;
data = (E[])new Object[arr.length];
for (int i = 0; i < arr.length; i++) {
data[i] = arr[i];
}
tree = (E[])new Object[4 * arr.length];
buildSegmentTree(0,0,data.length - 1);
}
/**
* 在treeIndex的位置创建表示区间[l....r]的线段树
* @param treeIndex 根节点对应的索引
* @param l 左端点
* @param r 右断点
*/
private void buildSegmentTree(int treeIndex, int l, int r) {
if (l == r){
tree[treeIndex] = data[l];
return;
}
int leftTreeIndex = leftChild(treeIndex);
int rightTreeIndex = rightChild(treeIndex);
// 创建该节点的子树
// 左边界+左右边界的距离/2
int mid = l + (r - l) / 2;
buildSegmentTree(leftTreeIndex, l, mid);
buildSegmentTree(rightTreeIndex, mid + 1, r);
// 计算
tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
}
public int getSize(){
return data.length;
}
public E get(int index){
if (index < 0 || index >= data.length){
throw new IllegalArgumentException("Index is illegal");
}
return data[index];
}
// 线段树更新方法
public void set(int index, E e){
if (index < 0 || index >= data.length){
throw new IllegalArgumentException("Index is illegal");
}
data[index] = e;
set(0,0,data.length - 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 = l + (r - l) / 2;
int leftTreeIndex = leftChild(treeIndex);
int rightTreeIndex = rightChild(treeIndex);
if (index >= mid + 1){
set(rightTreeIndex,mid + 1,r,index,e);
}else {// index <= mid
set(leftTreeIndex,l,mid,index,e);
}
tree[treeIndex] = merger.merge(tree[leftTreeIndex],tree[rightTreeIndex]);
}
/**
* 返回完全二叉树的数组表示中,一个索引所表示的元素的左孩子节点的索引
* @param index
* @return
*/
private int leftChild(int index){
return index * 2 + 1;
}
private int rightChild(int index){
return index * 2 + 2;
}
// 返回区间[queryL,queryR]的值
public E query(int queryL, int queryR){
// queryL > queryR 形成有效的区间
if (queryL < 0 || queryL >= data.length
|| queryR < 0 || queryR >= data.length || queryL > queryR){
throw new IllegalArgumentException("Index is illegal");
}
return query(0, 0, data.length - 1, queryL, queryR);
}
private E 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 leftIndex = leftChild(treeIndex);
int rightIndex = rightChild(treeIndex);
if (queryR <= mid){
return query(leftIndex,l,mid,queryL,queryR);
}else if (queryL >= mid + 1){
return query(rightIndex, mid + 1,r,queryL,queryR);
}
E leftResult = query(leftIndex,l,mid,queryL,mid);
E rightResult = query(rightIndex,mid + 1,r,mid + 1,queryR);
return merger.merge(leftResult,rightResult);
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append('[');
for (int i = 0; i < tree.length; i++) {
if (tree[i] != null){
res.append(tree[i]);
}else {
res.append("null");
}
if (i != tree.length - 1){
res.append(",");
}
}
res.append(']');
return res.toString();
}
}
public interface Merger<E> {
/**
* 定义2个元素的合并方式,用户自定义融合方式,是+,是取最大值、最小值,还是?
* 接口里面有且只有一个抽象方法,可用lambda表达式书写
* @param a 元素
* @param b 元素
* @return 返回值
*/
E merge(E a, E b);
}