自定义线段树（区间树）

通过学习自定义线段树（区间树），了解线段树这一数据结构。

线段树首先是平衡二叉树。

 

用例：查询一个区间[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