leetcode 303. 區域和檢索 - 數組不可變(線段樹解法、樹狀數組)

public class NumArray {
    private int [] tree;
    private int [] data;

    public NumArray(int [] nums){
        data=new int[nums.length];
        for(int i=0;i<nums.length;i++)
            data[i]=nums[i];
        tree=new int[4*nums.length];
                if(nums.length!=0)
           
        buildSegmentTree(0,0,nums.length-1);
    }
    public void  buildSegmentTree(int treeIndex,int l,int r){
        if(l==r){
            tree[treeIndex]=data[l];
            return;
        }
        int TreeLeft=LeftChild(treeIndex);
        int TreeRight=RightChild(treeIndex);
        int mid=l+(r-l)/2;

        buildSegmentTree(TreeLeft,l,mid);
        buildSegmentTree(TreeRight,mid+1,r);
        tree[treeIndex]=tree[TreeLeft]+tree[TreeRight];

    }
    public int LeftChild(int index){ return index*2+1;}
    public int RightChild(int index){return index*2+2;}
    public int query(int queryL,int queryR){
        if(queryL<0||queryL>=data.length||queryR<0||queryR>=data.length||queryL>queryR)
            throw new IllegalArgumentException("index illegal");
        return query(0,0,data.length-1,queryL,queryR);
    }
    public int query(int treeIndex,int l,int r,int queryL,int queryR){
        if(queryL==l && queryR==r)
            return tree[treeIndex];
        int mid=l+(r-l)/2;
        if (queryR<=mid) return query(LeftChild(treeIndex),l,mid,queryL,queryR);
        else if(queryL>mid) return query(RightChild(treeIndex),mid+1,r,queryL,queryR);
        return query(LeftChild(treeIndex),l,mid,queryL,mid)+query(RightChild(treeIndex),mid+1,r,mid+1,queryR);
    }
    public int sumRange(int i, int j) {
        return query(i,j);
    }

}


/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray obj = new NumArray(nums);
 * int param_1 = obj.sumRange(i,j);
 */

 //        int [] numsleet={-2,0,3,-5,2,-1};
        int [] nums2={};
        NumArray numarray=new NumArray(nums2);
        System.out.println(numarray.sumRange(2,5));
    }

樹狀數組

class NumArray {
    private BIT bit;
     private class BIT{

    private int []Ctree;
    public BIT(int []nums){

        Ctree=new int [nums.length+1];
        for(int i=1;i< Ctree.length;i++){
            updata(i-1,nums[i-1]);
        }

    }
    public int lowbit(int i){
        return i&(-i);
    }
    public void updata (int i,int val){
        i+=1;
        if(i<=0||i>=Ctree.length)
            throw new IllegalArgumentException("index is illegal");

        while(i<Ctree.length){

            Ctree[i]+=val;
            i+=lowbit(i);
        }
    }

    public int query(int i){
        i+=1;
        int res=0;
        while(i>0){
            res+=Ctree[i];
            i-=lowbit(i);
        }
        return  res;
    }
}


   

    public NumArray(int[] nums) {
        bit=new BIT(nums);
    }
    
    public int sumRange(int i, int j) {
        return bit.query(j)-bit.query(i-1); 
    }
}

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray obj = new NumArray(nums);
 * int param_1 = obj.sumRange(i,j);
 */