目录
一、为什么需要使用线段树
在一个区间内,需要同时实现两个操作:更新+查询,如果我们仅仅使用数组来实现,它的时间复杂度时O(n)级别的,相对来说,如果我们使用线段树,便可以获得更好的时间复杂度和更高的执行效率。
例如,我们需要在一个数组中,求一个区间内的元素的和,如果我们使用数组来进行实现,需要找到数组中所有的这些元素,然后进行一个一个的遍历求和操作,如果数据量很大的化,这种操作时比较低效的。
对于使用线段树的操作方式来说,它的数据存储结构如下图,每一个节点存储的是一段区间内的数字和,当我们需要查询索引4-7内的元素的和时,我们只需要访问A[4..7]这个节点就可以了,并不需要把4-7内的元素全部遍历出来再进行一下求和操作。
对于线段树来说,它不是一棵完全二叉树,它的根节点的位置不是按照层级从左到右的顺序排列的。但是,它是一颗平衡二叉树,所谓的平衡二叉树,就是树中叶子节点的最大深度和最小的深度之差不超过1,所以完全二叉树也是一棵平衡二叉树。
对于平衡二叉树来说,它不会像二分搜索树那样退化成一个链表,所以在平衡二叉树上的查询永远都是O(log(n))级别的,相对于链表O(n)复杂度的查询,平衡二叉树效率要高很多。
对于线段树来说,我们可以把它看成是一棵满二叉树,这样就可以通过数组来存储线段树(满二叉树每一层存多少数据是确定的);对于满二叉树:
n层,一共有2^n-1个节点。
最后一层(n-1)层,有2^(n-1)个节点,
因此,我们大致可以得出以下结论,在满二叉树中最后一层的节点数大致等于前面所有层的节点数之和。
接下来,我们需要计算一下:如果区间有n个元素,数组表示需要有多少节点?
如果我们的线段树不考虑添加元素,即区间固定,我们使用4n的静态空间即可(这是线段树最坏的情况,即开辟的空间中有很多将被浪费)
因此,使用线段树、我们追求的是以空间来换取时间
根据以上的分析,我们通过代码的实现如下:
public class SegmentTree<E> {
// 使用数组来存储线段树
private E[] data;
private E[] tree;
public SegmentTree(E[] arr){
data = (E[]) new Object[arr.length];
for(int i =0;i<arr.length;i++){
data[i] = arr[i];
}
// 存储线段树,需要开辟的存储空间的大小为4n
tree = (E[]) new Object[4 * arr.length];
}
public E get(int index) {
if (index < 0 || index >= data.length) {
throw new IllegalArgumentException("index is illegal");
}
return data[index];
}
public int getSize(){
return data.length;
}
// 返回完全二叉树的数组表示中,一个索引所表示的元素的左孩子的索引
private int leftChild(int index) {
return 2 * index + 1;
}
// 返回完全二叉树的数组表示中,一个索引所表示的元素的右孩子的索引
private int rightChild(int index) {
return 2 * index + 2;
}
}
二、创建线段树
下图以求和为例(具体做什么操作,根据具体的业务逻辑而定),如果我们的数组有10个元素,那么根节点位置存储的就是所有这些元素的和,相应的左孩子存储的是索引为[0-4]位置元素的和,右孩子存储的是[5-9]位置元素的和;依次往下,每个节点又可以有自己的左孩子和右孩子,直到所有的叶子节点中只存在一个元素为止。
在线段树的实现中,为了更灵活的处理业务请求,我们设置了一个融合器,通过这个融合器,用户可以自定义业务逻辑;融合器非常简单,我们首先定义一个接口,然后把融合器再传进去
public interface Merger<E> {
// 将两个值整合成一个值
E merger(E a,E b);
}
线段树代码的实现
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];
}
// 存储线段树,需要开辟的存储空间的大小为4n
tree = (E[]) new Object[4 * arr.length];
// 创建线段树
bulidSegmentTree(0, 0, data.length - 1);
}
// 在treeIndex的位置创建表示区间[l...r]的线段树
private void bulidSegmentTree(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;
bulidSegmentTree(leftTreeIndex, l, mid);
bulidSegmentTree(rightTreeIndex, mid + 1, r);
// 综合两个线段树相应的信息来写业务逻辑,求和,最大,最小等-融合器可以自定义
tree[treeIndex] = merger.merger(tree[leftTreeIndex],tree[rightTreeIndex]);
}
public E get(int index) {
if (index < 0 || index >= data.length) {
throw new IllegalArgumentException("index is illegal");
}
return data[index];
}
public int getSize(){
return data.length;
}
// 返回完全二叉树的数组表示中,一个索引所表示的元素的左孩子的索引
private int leftChild(int index) {
return 2 * index + 1;
}
// 返回完全二叉树的数组表示中,一个索引所表示的元素的右孩子的索引
private int rightChild(int index) {
return 2 * index + 2;
}
@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 static void main(String[] args) {
Integer[] nums = {-2, 0, 3, -5, 2, -1};
SegmentTree<Integer> segmentTree = new SegmentTree<>(nums,(a,b)->a+b);
System.out.println(segmentTree);
}
测试结果如下:
我们可以看到,数组中有很多为null的元素,我们开辟的数组中仍然有很多空间没有被利用,对于数组中的元素,我们也可以看到,根据我们定义的求和场景,元素1是-2,0,3元素的求和;-4是-5,2,-1的求和。
三、线段树的查询
线段树的查询操作:跟查询的数组长度没有关系,跟线段树的深度有关系,所以线段树的查询时间复杂度是O(log(n))级别的。
例如,我们要查找【2,5】区间的元素的和,我们从根节点出发开始寻找,首先是查询【0,7】区间,发现不满足需求,接下来我们继续去查找根节点的左孩子【0,3】区间和根节点的右孩子【4,7】区间,此时仍不满足需求,那还要继续往下找,直到查询到【2,3】区间和【4,5】区间,此时已经满足查询需求,所以把这两个区间的元素merger起来,得到最终想要的结果。
根据上边的分析逻辑,我们的代码具体实现如下
// 返回【queryL,queryR】之间的值
public E query(int queryL,int 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);
}
// 在以treeIndex为根的线段树中【l,r】的范围里,搜索区间为【queryL,queryR】的值
private E query(int treeIndex, int l, int r, int queryL, int queryR) {
// 递归到底的情况
if(queryL == l && queryR == r){
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 { // 居中
E leftResult = query(leftTreeIndex, l, mid, queryL, mid);
E rightResult = query(rightTreeIndex, mid + 1, r, mid + 1, queryR);
return merger.merger(leftResult, rightResult);
}
}
四、线段树的更新
线段树是一种比较高级的数据结构,它主要的应用场景在于区域查询和动态更新当中,对于一段区间内的查询和更新操作,使用线段树可以很大程度的帮我们提高程序的运算效率。
下边是线段树更新的代码逻辑
// 将index位置得值,更新为e
public void set(int index, E e) {
if (index < 0 || index >= data.length) {
throw new IllegalArgumentException("index is illegal.");
}
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 {
set(leftTreeIndex, l, mid, index, e);
}
// 更改节点会影响到其他相应节点的值,需要重新merger一下
tree[treeIndex] = merger.merger(tree[leftTreeIndex], tree[rightTreeIndex]);
}