段树java实现

你知道一个很好的Java（二进制）实现吗

这已经在开源软件中实现了

这是一个

您可能会发现这些代码很有用。我既没有验证它，也没有运行它，我无法从代码和网站的快速搜索中找到代码所提供的许可证，因此请注意清空

您可以联系作者，但最后一次活动似乎是在2008年8月。

public class SegmentTree{
public class SegmentTree {
    public static class STNode {
        int leftIndex;
        int rightIndex;
        int sum;
        STNode leftNode;
        STNode rightNode;
    }

    static STNode constructSegmentTree(int[] A, int l, int r) {
        if (l == r) {
            STNode node = new STNode();
            node.leftIndex = l;
            node.rightIndex = r;
            node.sum = A[l];
            return node;
        }
        int mid = (l + r) / 2;
        STNode leftNode = constructSegmentTree(A, l, mid);
        STNode rightNode = constructSegmentTree(A, mid+1, r);
        STNode root = new STNode();
        root.leftIndex = leftNode.leftIndex;
        root.rightIndex = rightNode.rightIndex;
        root.sum = leftNode.sum + rightNode.sum;
        root.leftNode = leftNode;
        root.rightNode = rightNode;
        return root;
    }

    static int getSum(STNode root, int l, int r) {
        if (root.leftIndex >= l && root.rightIndex <= r) {
            return root.sum;
        }
        if (root.rightIndex < l || root.leftIndex > r) {
            return 0;
        }
        return getSum(root.leftNode, l, r) + getSum(root.rightNode, l, r);
    }

    /**
     * 
     * @param root
     * @param index index of number to be updated in original array 
     * @param newValue
     * @return difference between new and old values
     */
    static int updateValueAtIndex(STNode root, int index, int newValue) {
        int diff = 0;
        if(root.leftIndex==root.rightIndex && index == root.leftIndex) {
            // We actually reached to the leaf node to be updated
            diff = newValue-root.sum;
            root.sum=newValue;
            return diff;
        }
        int mid = (root.leftIndex + root.rightIndex) / 2;
        if (index <= mid) {
            diff= updateValueAtIndex(root.leftNode, index, newValue);
        } else {
            diff= updateValueAtIndex(root.rightNode, index, newValue);
        }
        root.sum+=diff;
        return diff;
    }
}

公共静态类STNode{
int-leftIndex；
int-rightIndex；
整数和；
STNode-leftNode；
STNode-rightNode；
}
静态STNode结构段树（int[]A，int-l，int-r）{
如果（l==r）{
STNode node=新的STNode（）；
node.leftIndex=l；
node.rightIndex=r；
node.sum=A[l]；
返回节点；
}
int mid=（l+r）/2；
STNode leftNode=constructSegmentTree（A、l、mid）；
STNode rightNode=constructionsegmenttree（A，mid+1，r）；
STNode root=新的STNode（）；
root.leftIndex=leftNode.leftIndex；
root.rightIndex=rightNode.rightIndex；
root.sum=leftNode.sum+rightNode.sum；
root.leftNode=leftNode；
root.rightNode=rightNode；
返回根；
}
静态int getSum（STNode root、int l、int r）{
如果（root.leftIndex>=l&&root.rightIndex r）{
返回0；
}
返回getSum（root.leftNode，l，r）+getSum（root.righnode，l，r）；
}
/**
* 
*@param根
*@param index原始数组中要更新的编号索引
*@param newValue
*@返回新旧值之间的差异
*/
静态int updateValueAtIndex（STNode根、int索引、int newValue）{
int-diff=0；
if（root.leftIndex==root.rightIndex&&index==root.leftIndex）{
//我们实际上到达了要更新的叶节点
diff=newValue-root.sum；
root.sum=newValue；
返回差；
}
int mid=（root.leftIndex+root.rightIndex）/2；
如果（指数：

公共类NumarayTest{
@试验
public void testUpdateSumRange_with empty（）引发异常{
NumArray NumArray=新NumArray（新int[]{}）；
资产质量（0，numArray.sumRange（0，0））；
}
@试验
public void testUpdateSumRange_with Singleton（）引发异常{
NumArray NumArray=新NumArray（新int[]{1}）；
assertEquals（1，numArray.sumRange（0，0））；
更新（0,2）；
资产质量（2，numArray.sumRange（0，0））；
}
@试验
public void testUpdateSumRange_with pairections（）引发异常{
NumArray NumArray=新NumArray（新int[]{1,2,3,4,5,6}）；
assertEquals（12，numArray.sumRange（2，4））；
更新（3,2）；
assertEquals（10，numArray.sumRange（2，4））；
}
@试验
public void testUpdateSumRange_WithInPairElements（）引发异常{
NumArray NumArray=新NumArray（新int[]{1,2,3,4,5,6,7}）；
assertEquals（12，numArray.sumRange（2，4））；
更新（3,2）；
assertEquals（10，numArray.sumRange（2，4））；
}
}
纽马拉公务舱{
私有最终节点根；
私有静态类节点{
私人决赛开始；
私人终端；
私有最后节点左；
私有最终节点权；
私人整数和；
公共节点（整数开始、整数结束、整数和、左节点、右节点）{
this.begin=开始；
this.end=end；
this.sum=sum；
this.left=左；
这个。右=右；
}
公共布尔值isSingle（）{
返回开始==结束；
}
公共布尔包含（int i）{
返回i>=begin&i end | | j
在这里：

import java.util.Scanner;

public class MinimumSegmentTree {

    static Scanner in = new Scanner(System.in);

    public static void main(String[] args) {
        final int n = in.nextInt();
        int[] a = new int[n];

        for (int i = 0; i < n; i++) {
            a[i] = in.nextInt();
        }

        int sizeOfSegmentTree = (int) Math.pow(2, Math.ceil(Math.log10(n) / Math.log10(2)));
        sizeOfSegmentTree = 2*sizeOfSegmentTree-1;

//      System.out.println(sizeOfSegmentTree);

        int[] segmentTree = new int[sizeOfSegmentTree];
        formSegmentTree(a, segmentTree, 0, n-1, 0);

//      for(int i=0; i<sizeOfSegmentTree; i++){
//          System.out.print(segmentTree[i]+" ");
//      }
//      System.out.println();

        final int q = in.nextInt();
        for (int i = 0; i < q; i++) {
            int s, e;
            s = in.nextInt();
            e = in.nextInt();

            int minOverRange = getMinimumOverRange(segmentTree, s, e, 0, n-1, 0);
            System.out.println(minOverRange);
        }
    }

    private static int getMinimumOverRange(int[] segmentTree, int qs, int qe, int s, int e, int pos) {
        if (qs <= s && qe >= e) {
            return segmentTree[pos];
        }
        if (qs > e || s > qe) {
            return 10000000;
        }

        int mid = (s + e) / 2;
        return Math.min(getMinimumOverRange(segmentTree, qs, qe, s, mid, 2 * pos + 1),
                getMinimumOverRange(segmentTree, qs, qe, mid+1, e, 2 * pos + 2));
    }

    private static void formSegmentTree(int[] a, int[] segmentTree, int s, int e, int pos) {
        if (e - s == 0) {
            segmentTree[pos] = a[s];
            return;

        }

        int mid = (s + e) / 2;

        formSegmentTree(a, segmentTree, s, mid, 2 * pos + 1);
        formSegmentTree(a, segmentTree, mid+1, e, 2 * pos + 2);

        segmentTree[pos] = Math.min(segmentTree[2 * pos + 1], segmentTree[2 * pos + 2]);

    }

}

import java.util.Scanner；
公共类最小分段树{
静态扫描仪输入=新扫描仪（系统输入）；
公共静态void main（字符串[]args）{
final int n=in.nextInt（）；
int[]a=新的int[n]；
import java.util.Scanner;

public class MinimumSegmentTree {

    static Scanner in = new Scanner(System.in);

    public static void main(String[] args) {
        final int n = in.nextInt();
        int[] a = new int[n];

        for (int i = 0; i < n; i++) {
            a[i] = in.nextInt();
        }

        int sizeOfSegmentTree = (int) Math.pow(2, Math.ceil(Math.log10(n) / Math.log10(2)));
        sizeOfSegmentTree = 2*sizeOfSegmentTree-1;

//      System.out.println(sizeOfSegmentTree);

        int[] segmentTree = new int[sizeOfSegmentTree];
        formSegmentTree(a, segmentTree, 0, n-1, 0);

//      for(int i=0; i<sizeOfSegmentTree; i++){
//          System.out.print(segmentTree[i]+" ");
//      }
//      System.out.println();

        final int q = in.nextInt();
        for (int i = 0; i < q; i++) {
            int s, e;
            s = in.nextInt();
            e = in.nextInt();

            int minOverRange = getMinimumOverRange(segmentTree, s, e, 0, n-1, 0);
            System.out.println(minOverRange);
        }
    }

    private static int getMinimumOverRange(int[] segmentTree, int qs, int qe, int s, int e, int pos) {
        if (qs <= s && qe >= e) {
            return segmentTree[pos];
        }
        if (qs > e || s > qe) {
            return 10000000;
        }

        int mid = (s + e) / 2;
        return Math.min(getMinimumOverRange(segmentTree, qs, qe, s, mid, 2 * pos + 1),
                getMinimumOverRange(segmentTree, qs, qe, mid+1, e, 2 * pos + 2));
    }

    private static void formSegmentTree(int[] a, int[] segmentTree, int s, int e, int pos) {
        if (e - s == 0) {
            segmentTree[pos] = a[s];
            return;

        }

        int mid = (s + e) / 2;

        formSegmentTree(a, segmentTree, s, mid, 2 * pos + 1);
        formSegmentTree(a, segmentTree, mid+1, e, 2 * pos + 2);

        segmentTree[pos] = Math.min(segmentTree[2 * pos + 1], segmentTree[2 * pos + 2]);

    }

}