描述

给定一个整数数组，找到两个数的差等于目标值。index1必须小于index2。注意返回的index1和index2不是0-based。

注意事项

保证只有一个答案。

样例

给定的数组为 [2,7,15,24]，目标值为 5，返回 [1,2] (7 - 2 = 5)

思路

同向指针的做法，定义 Pair 是为了在达到排序目的的同时记住原先顺序的下标，输出要求输出原本的下标

代码

class Pair {
    public int idx, num;
    public Pair(int i, int n) {
        this.idx = i;
        this.num = n;
    }
}

public class Solution {
    /*
     * @param nums an array of Integer
     * @param target an integer
     * @return [index1 + 1, index2 + 1] (index1 < index2)
     */
    public int[] twoSum7(int[] nums, int target) {
        int[] indexs = new int[2];
        // 异常情况
        if (nums == null || nums.length < 2)
            return indexs;

        if (target < 0) {
            target = -target;
        }

        // pairs 数组初始化
        int n = nums.length;
        Pair[] pairs = new Pair[n];
        for (int i = 0; i < n; ++i) {
            pairs[i] = new Pair(i, nums[i]);
        }

        // 重写排序方法排序，从小到大排序
        Arrays.sort(pairs, new Comparator<Pair>(){
            public int compare(Pair p1, Pair p2){
                return p1.num - p2.num;
            } 
        });

        // 找出符合条件的下标
        int j = 0;
        for (int i = 0; i < n; ++i) {
            // 防止 target 等于 0 时，i 和 j 为同一个数
            // 保证 i 和 j 不是相同数
            if (i == j) {
                j++;
            }
            // 固定 i 如果差值小于 target 不断增大 j
            // 如果突然差值大于 target 了则固定 j 通过 for 循环增大 i
            while (j < n && pairs[j].num - pairs[i].num < target) {
                j++;
            }

            // 保证结果的元素输出顺序是按照升序排列的
            if (j < n && pairs[j].num - pairs[i].num == target) {
                // +1 是题目的下标要求
                indexs[0] = pairs[i].idx + 1;
                indexs[1] = pairs[j].idx + 1;
                if (indexs[0] > indexs[1]) {
                    int temp = indexs[0];
                    indexs[0] = indexs[1];
                    indexs[1] = temp;
                }
                return indexs;
            }
        }
        return indexs;
    }
}