目录
一、为什么需要使用线段树
在一个区间内，需要同时实现两个操作：更新+查询，如果我们仅仅使用数组来实现，它的时间复杂度时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]);
}
1251
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
