版权声明：转载请注明出处： https://blog.csdn.net/qq_34774655/article/details/85646346
通过学习自定义线段树（区间树），了解线段树这一数据结构。
线段树首先是平衡二叉树。
用例：查询一个区间[i,j]的最大值，最小值，或者区间数字和等。
实质：基于区间的统计查询。
为什么用线段树：
|
|
使用数组实现 |
使用线段树 |
| 更新 |
O(n) |
O(log n) |
| 查询 |
O(n) |
O(log n) |
使用满二叉树的数组来表示线段树，需要用4n的静态空间。
包结构：
Merger.java接口：
package SegmentTree;
/**
* @author xiaohua
*
* @param <E>
*/
public interface Merger<E> {
E merger(E a, E b);
}
SegmentTree.java：
package SegmentTree;
public class SegmentTree<E> {
private E[] tree;//底层使用完全二叉树的数组实现线段树
private E[] data;//复制构造函数传入的数组
private Merger<E> mer;//表示对区间的操作
/**
* 带参构造函数
*/
public SegmentTree(E[] arr,Merger<E> mer) {
this.mer=mer;
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,arr.length-1);
}
/**
* 返回线段树的大小
* @return
*/
public int getSize() {
return data.length;
}
/**
* 获取指定索引的元素
* @param index
* @return
*/
public E get(int index){
if(index < 0 || index >= data.length) {
throw new IllegalArgumentException("索引不合法.");
}
return data[index];
}
/**辅助方法
* 返回完全二叉树的数组表示中，一个索引所表示的元素的左孩子节点的索引
* @param index
* @return
*/
private int leftChild(int index) {
return 2*index+1;
}
/**辅助方法
* 返回完全二叉树的数组表示中，一个索引所表示的元素的右孩子节点的索引
* @param index
* @return
*/
private int rightChild(int index) {
return 2*index+2;
}
/**
* 在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);
int mid=l+(r-l)/2;
buildSegmentTree(leftTreeIndex,l,mid);
buildSegmentTree(rightTreeIndex,mid+1,r);
tree[treeIndex]=mer.merger(tree[leftTreeIndex],tree[rightTreeIndex]);
}
/**
* 返回区间[queryL, queryR]的值
* @param queryL
* @param queryR
* @return
*/
public E query(int queryL,int queryR) {
if(queryL < 0 || queryL >= data.length || queryR < 0 || queryR >= data.length || queryL > queryR) {
throw new IllegalArgumentException("索引不合法.");
}
return query(0, 0, data.length - 1, queryL, queryR);
}
/**
* 在以treeIndex为根的线段树中[l...r]的范围里，搜索区间[queryL...queryR]的值
* @param treeIndex
* @param l
* @param r
* @param queryL
* @param queryR
* @return
*/
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;
// treeIndex的节点分为[l...mid]和[mid+1...r]两部分
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);
}
E leftResult = query(leftTreeIndex, l, mid, queryL, mid);
E rightResult = query(rightTreeIndex, mid + 1, r, mid + 1, queryR);
return mer.merger(leftResult, rightResult);
}
/**
* 将index位置的值，更新为e
* @param index
* @param e
*/
public void set(int index, E e){
if(index < 0 || index >= data.length)
throw new IllegalArgumentException("索引不合法");
data[index] = e;
set(0, 0, data.length - 1, index, e);
}
/**
* 在以treeIndex为根的线段树中更新index的值为e
* @param treeIndex
* @param l
* @param r
* @param index
* @param 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;
// treeIndex的节点分为[l...mid]和[mid+1...r]两部分
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] = mer.merger(tree[leftTreeIndex], tree[rightTreeIndex]);
}
/**
* 重写Object的toString方法
*/
@Override
public String toString() {
StringBuilder sb=new StringBuilder();
sb.append('[');
for(int i=0;i<tree.length;i++) {
if(tree[i]!=null) {
sb.append(tree[i]);
}else {
sb.append("null");
}
if(i!=tree.length-1) {
sb.append(", ");
}
}
sb.append(']');
return sb.toString();
}
}
Test.java测试类：
package SegmentTree;
public class Test {
public static void main(String[] args) {
Integer[] nums= {-2,0,3,-5,2,-1};
SegmentTree<Integer> segTree=new SegmentTree<>(nums,new Merger<Integer>() {
//定义区间操作为计算区间数字的和
@Override
public Integer merger(Integer a, Integer b) {
return a+b;
}
});
System.out.println(segTree);
System.out.println(segTree.query(0, 2));
System.out.println(segTree.query(2, 5));
System.out.println(segTree.query(0, 5));
}
}
控制台输出：
[-3, 1, -4, -2, 3, -3, -1, -2, 0, null, null, -5, 2, null, null, null, null, null, null, null, null, null, null, null]
1
-1
-3