Java implementação LeetCode 436 para encontrar a faixa direita

436. Olhando para a faixa direita

Dado um conjunto de intervalos, para cada secção de i, j verifica se existe um intervalo, o qual é igual a ou maior do que o ponto do ponto final da secção de i, j, em que i podem ser referidos para a partida "lado direito".

Para qualquer intervalo, o mínimo de intervalo de índice j satisfaz a condição de suas necessidades de armazenamento, o que significa que há um j ponto de partida intervalo mínimo pode fazê-lo "à direita" gama. Se o intervalo j não existe, a secção de armazenamento i -1. Finalmente, você precisa de um conjunto de gama valor de saída de um valor armazenado.

Nota:

Você pode supor que o fim do intervalo é sempre maior do que o seu ponto de partida.
Você pode assumir que essas seções não têm o mesmo ponto de partida.
Exemplo 1:

Entrada: [[1,2]]
Saída: [-1]

Explicação: apenas um intervalo de recolha, a saída de -1.
Exemplo 2:

Entrada: [[3,4], [2,3], [1,2]]
Saída: [-1, 0, 1]

Explicação: Secção de [3,4], a condição não for satisfeita "lado direito".
Para a [2,3], no intervalo [3,4] ter mínima ponto de partida "direita";
a [1,2], no intervalo [2,3] tendo a menor "direita" ponto de partida.
Exemplo 3:

Entrada: [[1,4], [2,3], [3,4]]
Saída: [-1, 2, -1]

Explicação: secção no intervalo [1,4], e [3,4], a condição não é satisfeita "lado direito".
Para a [2,3], no intervalo [3,4] mínimo "direita" ponto de partida.

class Solution {
    public int[] findRightInterval(int[][] intervals) {
        int length = intervals.length;
        int[] res = new int[length];
        MyNode[] list = new MyNode[length];
        for (int i = 0; i < length; i++) {
            list[i] = new MyNode(intervals[i][0], intervals[i][1], i);
        }
        Arrays.sort(list, new Comparator<MyNode>() {
            public int compare(MyNode a, MyNode b) {
                return a.start - b.start;
            }
        });
        for (int i = 0; i < length; i++) {
            res[list[i].index] = greater(list, 0, length - 1, list[i].end);
        }
        return res;
    }

    class MyNode {
        int start;   // 区间的起点
        int end;     // 区间的终点
        int index;   // 在原数组的下标

        public MyNode(int start, int end, int index) {
            this.start = start;
            this.end = end;
            this.index = index;
        }
    }

    // 二分查找第一个区间的起点大于等于target的数组元素的下标，数组是升序排序，范围是[left,right]
    private int greater(MyNode[] list, int left, int right, int target) {
        while (left <= right) {
            int mid = (left + right) >>> 1;
            if (list[mid].start < target) {
                left = mid + 1;
            } else {
                if (mid - 1 >= left && list[mid - 1].start >= target) {
                    right = mid - 1;
                } else {
                    return list[mid].index;
                }
            }
        }
        return -1;        // list[right].start<target
    }
}