线段树(Java)

线段树

线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。
使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。

这不是一棵完全二叉树，也不是满二叉树，是一棵平衡二叉树，如果将这棵树的最后一层不存在的节点定义为null，补齐就可以看做是一棵满二叉树，就可以使用数组作为底层进行表示。

SegmentTree.java(线段树)

//线段树
public class SegmentTree<E> {
	private E[] data;// 底层数组
	private E[] tree;// 构建线段树
	private Merger<E> merger;// 线段树融合器

	// 构造方法 传入arr数组与融合器匿名函数
	public SegmentTree(E[] arr, Merger<E> merger) {
		// TODO Auto-generated constructor stub
		this.merger = merger;
		data = (E[]) new Object[arr.length];// 初始化arr数组
		for (int i = 0; i < arr.length; i++)
			data[i] = arr[i];
		tree = (E[]) new Object[4 * arr.length];// 初始化tree数组存放线段树
		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];// 当线段树子树长度为1，也就是它本身
			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]为当前两个孩子融合得到的结果
		tree[treeIndex] = merger.meger(tree[leftTreeIndex], tree[rightTreeIndex]);
	}

	public E get(int index) {
		if (index < 0 || index >= data.length)
			try {
				throw new Exception("index越界");
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		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;
	}

	// 返回区间[queryL,queryR]的值
	public E query(int queryL, int queryR) {
		if (queryL < 0 || queryL >= data.length || queryR < 0 || queryR >= data.length || queryL > queryR)
			try {
				throw new Exception("[queryL,queryR]区间错误");
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		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) {
		// TODO Auto-generated method stub
		if (l == queryL && r == queryR)
			return tree[treeIndex];
		int mid = l + (r - l) / 2;
		int leftTreeIndex = leftChild(treeIndex);
		int rightTreeIndex = rightChild(treeIndex);
		// [queryL,queryR]完全在左子树区间或右子树区间
		if (queryL >= mid + 1)// 完全在右子树查询
			return query(rightTreeIndex, mid + 1, r, queryL, queryR);
		else if (queryR <= mid)// 完全在左子树查询
			return query(leftTreeIndex, l, mid, queryL, queryR);

		// [queryL,queryR]不完全在左子树区间或右子树区间
		E leftResult = query(leftTreeIndex, l, mid, queryL, mid);// 在左边区间查询
		E rightResult = query(rightTreeIndex, mid + 1, r, mid + 1, queryR);// 在右边区间查询
		return merger.meger(leftResult, rightResult);// 融合返回
	}

	// 将index位置的值，更新为e
	public void set(int index, E e) {
		if (index < 0 || index >= data.length)
			try {
				throw new Exception("index越界");
			} catch (Exception e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		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; // 当线段树子树长度为1，也就是它本身
			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);
		// 由于index节点进行了修改，index的祖辈节点也应该被修改，即重新调用融合器
		tree[treeIndex] = merger.meger(tree[leftTreeIndex], tree[rightTreeIndex]);
	}

	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();
	}

}

Merger.java(融合器接口)

//融合器接口
public interface Merger<E> {
		E meger(E a,E b);//通过一个meger操作把a和b两个元素转换成一个元素返回
}

Main.java(测试)

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 meger(Integer a, Integer b) {
		// // TODO Auto-generated method stub
		// return a+b;
		// }
		// });
		SegmentTree<Integer> segTree = new SegmentTree<>(nums, (a, b) -> a + b);//传入a和b，返回a+b
		System.out.println(segTree);//输出线段树
		System.out.println(segTree.query(0, 2));//输出线段树[0-2]区间的和
		segTree.set(0, 6);//将data[0]修改为6
		System.out.println(segTree.query(0,2));//输出线段树[0-2]区间的和
	}
}

测试结果

总结

线段树查询与更新操作时间复杂度为O(logn)
利用线段树，我们可以高效地询问和修改一个数列中某个区间的信息，并且代码也不算特别复杂。
但是线段树也是有一定的局限性的，其中最明显的就是数列中数的个数必须固定，即不能添加或删除数列中的数。