LeetCode 1 -- Two Sum

Given an array of integers, find two numbers such that they add up to a specific target number.

The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.

You may assume that each input would have exactly one solution.

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2

---

主要有两种思路，一种是暴力破解，循环寻找答案，算法复杂度为O(n²)，空间复杂度为O(1)；另一种思路是先排序再查找，不同排序查找方法可能会有不同结果。

暴力破解的代码很简单，提交上去直接超时了。需要考虑各种边界以及不存在结果的情况，后面改进

代码一：

public class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int length = numbers.length;
        int result[] = new int[2];
        for(int i = 0 ; i < length ; i++){
            if( numbers[i] < target)
            {
                for ( int j = i + 1 ;j < length ;j++){
                    if( numbers[i] + numbers[j] == target ){
                        result[0] = i + 1;
                        result[1] = j + 1;
                    }
                }
            }
        }
        return result;
    }
}

第二种排序可以采用双指针的方式

代码二：

public class Solution {

    static class Pair implements Comparable<Pair> {
        int value, index;
        public Pair(int v, int id) {
            value = v;
            index = id;
        }

        @Override
        public int compareTo(Pair b) {
            return this.value - b.value;
        }
    }

    public static int[] twoSum(int[] numbers, int target) {
        int[] res = new int[2];
        Pair[] pairs = new Pair[numbers.length];

        // get pairs and sort
        for (int i = 0; i < numbers.length; ++i) {
            pairs[i] = new Pair(numbers[i], i + 1);
        }
        Arrays.sort(pairs);

        // two points
        int left = 0, right = numbers.length - 1, sum = 0;
        while (left < right) {
            sum = pairs[left].value + pairs[right].value;
            if (sum == target) {
                res[0] = pairs[left].index;
                res[1] = pairs[right].index;
                if (res[0] > res[1]) {
                    // swap them
                    res[0] ^= res[1];
                    res[1] ^= res[0];
                    res[0] ^= res[1];
                }
                break;
            } else if (sum > target) {
                --right;
            } else {
                ++left;
            }
        }

        return res;
    }
}

也可以采用哈希表，

代码三：

public class Solution {
    public static int[] twoSum(int[] numbers, int target) {
        int[] res = new int[2];
        HashMap<Integer, Integer> nums = new HashMap<Integer, Integer>();

        for (int i = 0; i < numbers.length; ++i) {
            // add i-th number
            Integer a = nums.get(numbers[i]);
            if (a == null)
                nums.put(numbers[i], i);

            // find (target - numbers[i])
            a = nums.get(target - numbers[i]);
            if (a != null && a < i) {
                res[0] = a + 1;
                res[1] = i + 1;
                break;
            }
        }
        return res;
    }
}

时间复杂度为O(n),空间复杂度为O(n)