Lintcode: Interval Minimum Number

Given an integer array (index from 0 to n-1, where n is the size of this array), and an query list. Each query has two integers [start, end]. For each query, calculate the minimum number between index start and end in the given array, return the result list.

Have you met this question in a real interview? Yes
Example
For array [1,2,7,8,5], and queries [(1,2),(0,4),(2,4)], return [2,1,5]

Note
We suggest you finish problem Segment Tree Build, Segment Tree Query and Segment Tree Modify first.

Challenge
O(logN) time for each query

SegmentTree time complexity: build O(N), query O(logN), update O(logN),      space cost O(NlogN)

/**
 * Definition of Interval:
 * public classs Interval {
 *     int start, end;
 *     Interval(int start, int end) {
 *         this.start = start;
 *         this.end = end;
 *     }
 */
public class Solution {
    /**
     *@param A, queries: Given an integer array and an query list
     *@return: The result list
     */
    public class SegmentTreeNode {
        int min;
        int start;
        int end;
        SegmentTreeNode left;
        SegmentTreeNode right;
        public SegmentTreeNode(int start, int end) {
            this.start = start;
            this.end = end;
            this.min = Integer.MAX_VALUE;
            this.left = null;
            this.right = null;
        }
    } 
    
    SegmentTreeNode root;
     
    public ArrayList<Integer> intervalMinNumber(int[] A, 
                                                ArrayList<Interval> queries) {
        // write your code here
        ArrayList<Integer> res = new ArrayList<Integer>();
        root = buildTree(A, 0, A.length-1);
        query(res, queries);
        return res;
    }
    
    public SegmentTreeNode buildTree(int[] A, int start, int end) {
        SegmentTreeNode cur = new SegmentTreeNode(start, end);
        if (start == end) {
            cur.min = A[start];
        }
        else {
            int mid = (start+end)/2;
            cur.left = buildTree(A, start, mid);
            cur.right = buildTree(A, mid+1, end);
            cur.min = Math.min(cur.left.min, cur.right.min);
        }
        return cur;
    }
    
    public void query(ArrayList<Integer> res, ArrayList<Interval> queries) {
        for (Interval interval : queries) {
            int result = queryTree(root, interval.start, interval.end);
            res.add(result);
        }
    }
    
    public int queryTree(SegmentTreeNode cur, int start, int end) {
        if (start==cur.start && end==cur.end) {
            return cur.min;
        }
        int mid = (cur.start + cur.end)/2;
        if (end <= mid) return queryTree(cur.left, start, end);
        else if (start > mid) return queryTree(cur.right, start, end);
        else return Math.min(queryTree(cur.left, start, mid), queryTree(cur.right, mid+1, end));
    }
}