数据结构之线段树
文章目录
- 线段树（区间树）Segment Tree
- 线段树的概念
- 为什么要使用线段树
- 手写一个线段树
- 线段树中的区间查询
- 线段树问题 LeetCode303
- LeetCode307
- 对区间进行操作的时间复杂度
线段树（区间树）Segment Tree
线段树的概念
线段树是一种特殊的树结构。这种数据结构主要用于解决“线段”或者是“区间”这种特殊的数据
线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。
对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。
使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN）。
如果区间有n个元素，数组表示需要有多少节点？
0层：1
1层：2
2层：4
3层：8
…
h-1层：2^(h-1)
所以对满二叉树：
h层：一共有2^h - 1个节点（大约是2^h）
最后一层(h-1)层，有2^(h-1)个节点
最后一层的节点数大致等于前面所有层节点之和
如上，当所有的元素节点都在最后一层时，2n的空间即可，
可是若元素节点存放在最后两层中，则需要4n的空间
故，需要4n的空间
- 线段树不是完全二叉树
- 线段树是平衡二叉树（最大深度与最小深度差距不大于1）
为什么要使用线段树
线段树的经典问题：区间查询
对于给定区间
- 更新：更新区间中一个元素或者一个区间的值
- 查询一个区间[i,j]的最大值，最小值，或者区间数字和
- 实质：基于区间的统计查询
例：查询某电商网站中2018年注册用户中消费最高的用户？消费最少的用户？学习时间最长的用户？
手写一个线段树
public interface Merger<E> {
// 自定义merge方法定义融合规则
E merge(E a, E b);
}
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]的值要根据具体业务来定，下面是一种求和的线段树
// tree[treeIndex] = tree[rightTreeIndex] + tree[rightTreeIndex];
// 如果是求最大值，就是 tree[treeIndex] = max(tree[leftTreeIndex], tree[rightTreeIndex]) 最小值就是min...
// 这里为了有更多的扩展性，对tree节点的赋值我们定义一个借口 Merger 里面只有一个merge方法来辅助我们处理
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];
}
// 返回完全二叉树的数组表示中，一个索引所表示的元素的左孩子节点的索引
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 class Main {
public static void main(String[] args) {
Integer[] nums = {-2, 0, 3, -5, 2, -1};
// SegmentTree segTree = new SegmentTree<>(nums,
// new Merger() {
// @Override
// public Integer merge(Integer a, Integer b) {
// return a + b;
// }
// });
SegmentTree<Integer> segTree = new SegmentTree<>(nums,
(a, b) -> a + b);
System.out.println(segTree);
}
}
线段树中的区间查询
如图在[0,7]区间中查询[2,5]节点的步骤：
方法代码：
// 在以treeID为根的线段树中[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];
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);
}
线段树问题 LeetCode303
https://leetcode-cn.com/problems/range-sum-query-immutable/
问题描述：
给定一个整数数组 nums，求出数组从索引 i 到 j (i ≤ j) 范围内元素的总和，包含 i, j 两点。
示例：
给定 nums = [-2, 0, 3, -5, 2, -1]，求和函数为 sumRange()
sumRange(0, 2) -> 1
sumRange(2, 5) -> -1
sumRange(0, 5) -> -3
说明:
- 你可以假设数组不可变。
- 会多次调用 sumRange 方法。
所给问题解题模板
class NumArray {
public NumArray(int[] nums) {
}
public int sumRange(int i, int j) {
}
}
/**
* Your NumArray object will be instantiated and called as such:
* NumArray obj = new NumArray(nums);
* int param_1 = obj.sumRange(i,j);
*/
其实用简单的索引遍历求和就可以通过… 不过还是用线段树来解决下（注意使用自定义方法要将自定义的方法拷贝进去）。
class NumArray {
// 自定义辅助接口和类
private interface Merger.....
private class SegmentTree..........
private SegmentTree<Integer> segmentTree;
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];
segmentTree = new SegmentTree<>(data, (a, b) -> a + b);
}
}
public int sumRange(int i, int j) {
if (segmentTree == null)
throw new IllegalArgumentException("Segment Tree is null");
return segmentTree.query(i, j);
}
}
提交查看测试结果可以发现比遍历效率要高得多
另外我们的需求是输入一个数组求出某个范围的元素和，也就是数组几乎是不可变的，所以我们也可以采用预处理的方式来解决，性能上也会更好。
class NumArray {
private int[] sum; // sum[i]存储前i个元素和，sum[0] = 0
// sum[i]存储nums[0...i-1]的和
public NumArray(int[] nums) {
sum = new int[nums.length + 1];
sum[0] = 0;
for (int i = 1 ; i < sum.length ; i ++)
sum[i] = sum[i - 1] + nums[i - 1];
}
public int sumRange(int i, int j) {
return sum[j + 1] - sum[i];
}
}
图上三次从上到下依次为使用预处理，线段树，和索引遍历三种方式，预处理效率最高。
当然这里线段树不如预处理的原因是因为这里不考虑更新操作，实际上线段树的效率还是很好的。
LeetCode307
https://leetcode-cn.com/problems/range-sum-query-mutable/submissions/
接下来我们看一个适合线段树的LeetCode307号问题
题目描述：
给定一个整数数组 nums，求出数组从索引 i 到 j (i ≤ j) 范围内元素的总和，包含 i, j 两点。
update(i, val) 函数可以通过将下标为 i 的数值更新为 val，从而对数列进行修改。
示例:
Given nums = [1, 3, 5]
sumRange(0, 2) -> 9
update(1, 2)
sumRange(0, 2) -> 8
说明:
数组仅可以在 update 函数下进行修改。
你可以假设 update 函数与 sumRange 函数的调用次数是均匀分布的。
所给代码模板：
class NumArray {
public NumArray(int[] nums) {
}
public void update(int i, int val) {
}
public int sumRange(int i, int j) {
}
}
/**
* Your NumArray object will be instantiated and called as such:
* NumArray obj = new NumArray(nums);
* obj.update(i,val);
* int param_2 = obj.sumRange(i,j);
*/
首先我们可以在预处理的基础上进行改进，即在更新方法update中，对修改位置后面的位置的每个sum元素重新求和：
class NumArray {
private int[] sum; // sum[i]存储前i个元素和，sum[0] = 0
// sum[i]存储nums[0...i-1]的和
private int[] data;
public NumArray(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 < sum.length ; i ++)
sum[i] = sum[i - 1] + nums[i - 1];
}
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];
}
public int sumRange(int i, int j) {
return sum[j + 1] - sum[i];
}
}
可以通过测试，可是时间复杂度很高，执行用时过长，有时甚至会超出规定运行时间，所以还是要使用线段树来解决这个问题：
在SegmentTree中添加更新方法：
// 将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;
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]);
}
使用线段树的方式解决307号问题：
class NumArray {
private SegmentTree<Integer> segmentTree;
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];
segmentTree = new SegmentTree<>(data, (a, b) -> a + b);
}
}
public void update(int index, int val){
if (segmentTree == null)
throw new IllegalArgumentException("Segment Tree is null");
segmentTree.set(index, val);
}
public int sumRange(int i, int j) {
if (segmentTree == null)
throw new IllegalArgumentException("Segment Tree is null");
return segmentTree.query(i, j);
}
}
可以看到运行时间对比：
明显线段树效率高得多。
对区间进行操作的时间复杂度
| 使用数组实现 | 使用线段树 | |
|---|---|---|
| 更新 | O(n) | O(logn) |
| 查询 | O(n) | O(logn) |