什么是线段树
线段树应用地点
package com.dataStructrue.SegmentTree;
public interface Merger<E> {//融合两个数据
E merge(E a, E b);
}
package com.dataStructrue.SegmentTree;
public class SegmentTree<E> {
private E[] tree;
private E[] data;
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, arr.length - 1);//(线段树根节点索引,节点左端点,节点右端点)
}
// 在treeIndex的位置创建表示区间[l...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) / 2; 不写这个,防止整型溢出
int mid = l + (r - l) / 2;//中间值的位置
buildSegmentTree(leftTreeIndex, l, mid);//索引与左区间
buildSegmentTree(rightTreeIndex, mid + 1, r);//索引与右区间
tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
//综合两个线段的信息,来得到父亲的线段信息
//merger.merge,不是merger.merger
}
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];
}
// 返回完全二叉树的数组表示中,一个索引所表示的元素的左孩子节点的索引
private int leftChild(int index){
return 2*index + 1;
}
// 返回完全二叉树的数组表示中,一个索引所表示的元素的右孩子节点的索引
private int rightChild(int index){
return 2*index + 2;
}
// 返回区间[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(l == queryL && r == queryR)
return tree[treeIndex];
// treeIndex的节点分为[l...mid]和[mid+1...r]两部分
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);
//否则的话,左边有一点,右边有一点
E leftResult = query(leftTreeIndex, l, mid, queryL, mid);
E rightResult = query(rightTreeIndex, mid + 1, r, mid + 1, queryR);
return merger.merge(leftResult, rightResult);
}
// 将index位置的值,更新为e
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);
}
// 在以treeIndex为根的线段树中更新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;
// 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);
//左右两边的treeIndex的值都可能发生改变
tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
}
@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();
}
}
package com.dataStructrue.SegmentTree;
public class Main {
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 merge(Integer a, Integer b) {
// return a + b;
// }
// });
SegmentTree<Integer> segTree = new SegmentTree<>(nums, (a, b) -> a + b);
}
}
查询操作:查询[2,5]
merger组合后返回
[i,j]区间的和
package com.dataStructrue.SegmentTree;
/// Leetcode 307. Range Sum Query - Mutable
/// https://leetcode.com/problems/range-sum-query-mutable/description/
class NumArray {
private SegmentTree<Integer> segTree;
public NumArray(int[] nums) {
if(nums.length != 0){
Integer[] data = new Integer[nums.length];
for(int i = 0 ; i < nums.length ; i ++)
data[i] = nums[i];
segTree = new SegmentTree<>(data, (a, b) -> a + b);
}
}
public void update(int i, int val) {
if(segTree == null)
throw new IllegalArgumentException("Error");
segTree.set(i, val);
}
public int sumRange(int i, int j) {
if(segTree == null)
throw new IllegalArgumentException("Error");
return segTree.query(i, j);
}
}
加了更新操作
package com.dataStructrue.SegmentTree;
/// Leetcode 307. Range Sum Query - Mutable
/// 使用sum数组的思路:TLE
class NumArray3 {
private int[] data;
private int[] sum;
public NumArray3(int[] nums) {
data = new int[nums.length];//更新的基本操作
for(int i = 0 ; i < nums.length ; i ++)
data[i] = nums[i];
sum = new int[nums.length + 1];
sum[0] = 0;
for(int i = 1 ; i <= nums.length ; i ++)
sum[i] = sum[i - 1] + nums[i - 1];//sum是从1开始的,num是从0开始的
}
public int sumRange(int i, int j) {
return sum[j + 1] - sum[i];
}
public void update(int index, int val) {
data[index] = val;
for(int i = index + 1 ; i < sum.length ; i ++)
sum[i] = sum[i - 1] + data[i - 1];
}
}