题目描述

思路

分两种：排序之后从两边向中间遍历；哈希表

排序

为了能够排完序之后保留下标信息，需要新定义一个类。在类中保留数字和对应下标，并实现Compareble接口，重写compareTo方法，注意在compareTo方法中只对数字进行比较，而下标不参与比较。我把这个类定义为Data。

定义完这个类之后，由所给数组（nums）新建一个Data数组。然后调用Arrays.sort()对Data数组进行排序。从数组的两端（头指针pre，尾指针post）向中间逼近，寻找加和等于target的两个数。

在寻找的过程中，若pre和post指向的两个数相加小于target，则pre加1；若大于target，则post-1；若等于target，退出循环并返回结果。

java代码如下：

import java.util.Arrays;

class Solution {
    public class Data implements Comparable {
        int index;
        int data;

        Data(int index, int data) {
            this.data = data;
            this.index = index;
        }

        @Override
        public int compareTo(Object o) {
            if (o instanceof Data) {
                Data s = (Data) o;
                if (this.data > s.data)
                    return 1;
                else if (this.data == s.data)
                    return 0;
                else
                    return -1;
            }
            return 0;
        }
    }

    public int[] twoSum(int[] nums, int target) {
        int length = nums.length;
        int pre = 0;
        int post = length - 1;
        int sum = 0;

        Data[] datas = new Data[length];
        for (int i = 0; i < length; i++)
            datas[i] = new Data(i, nums[i]);

        Arrays.sort(datas);

        while (true) {
            sum = datas[pre].data + datas[post].data;
            if (sum == target) {
                break;
            } else if (sum < target) {
                pre = pre + 1;
            } else {
                post = post - 1;
            }
        }

        int[] res = { datas[pre].index, datas[post].index };
        return res;
    }
}

执行用时：6 ms, 在所有 Java 提交中击败了36.96%的用户
内存消耗：38.7 MB, 在所有 Java 提交中击败了32.34%的用户

36%，结果不太好，下一个方法。

哈希表

以数组下标为key，对应位置上的元素为value，创建hashMap，命名为map。

对所给数组nums进行遍历。对每个元素，若与该元素加和为target的那个数是map的一个key，则找到答案，将该元素的下标与那个key对应的value返回；若不是map的一个key，将该元素的<元素值，下标>添加到map中（即使该元素已存在与map中也无所谓，因为题设已说明答案必定唯一）

一次遍历即可得到结果

java代码如下：

import java.util.HashMap;

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int length = nums.length;
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();

        for (int i = 0; i < length; i++) {
            if (map.containsKey(target - nums[i])) {
                int[] res = { i, map.get(target - nums[i]) };
                return res;
            } else {
                map.put(nums[i], i);
            }
        }

        return null;
    }
}

执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：38.7 MB, 在所有 Java 提交中击败了41.46%的用户