三數之和

LintCode57 三數之和
解題思路：先對陣列排序，然後開始遍歷，對於陣列中的每一個元素，用兩指標往中間夾，直到找出所有的解。時間複雜度 O(n^2).

ps：為什麼會想到對陣列元素進行排序呢，排序是為了讓元素之間呈現出某種規律，處理起來會簡單很多。所以，當你覺得一個似乎無從下手的問題的時候，不妨嘗試去尋找或製造一種“規律”，排序是手段之一。

public class Solution {
    /**
     * @param numbers : Give an array numbers of n integer
     * @return : Find all unique triplets in the array which gives the sum of zero.
     */
 

    public ArrayList<ArrayList<Integer>> threeSum(int[] numbers) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        Arrays.sort(numbers);
        for (int i = 0; i < numbers.length; ++i) {
            int l = i + 1, r = numbers.length - 1
 
;
            while (l < r) {
                ArrayList<Integer> stepRes = new ArrayList<Integer>();
                int sum = numbers[i] + numbers[l] + numbers[r];
                if (sum == 0) {
                    stepRes.add(numbers[i]);
                    stepRes.add(numbers[l]);
                    stepRes.add(numbers[r]);
                    if
 
 (!res.contains(stepRes)) // 去重
                        res.add(stepRes);
                }
                if (sum <= 0) ++l;
                else --r;
            }
        }
        return res;
    }
}

最接近的三數之和

public class Solution {
    /**
     * @param numbers: Give an array numbers of n integer
     * @param target : An integer
     * @return : return the sum of the three integers, the sum closest target.
     */
    
    public int threeSumClosest(int[] numbers, int target) {
        // if (numbers == null || numbers.length == 0) return 0;
        int res = Integer.MAX_VALUE;
        Arrays.sort(numbers); 
        for (int i = 0; i < numbers.length; ++i) { 
            int l = i + 1, r = numbers.length - 1;
            while (l < r) {
                int sum = numbers[i] + numbers[l] + numbers[r];
                if (Math.abs(sum - target) < Math.abs(res - target)) res = sum;
                if (sum <= target) ++l;
                else --r;
            }
        }
        return res;
    }
}

兩數之和

LintCode56 兩數之和
解題思路：使用一個雜湊表記錄，比如說輸入資料 [2,7,11,15], 9
9 - 2 = 7, 讓 7 作為 key, 下標+1作為value, 這樣遍歷到陣列中的 7 時就找到解了
非嚴格情況下，雜湊表的查詢的插入操作都可以認為是在 O(1) 時間完成的，所以這個解法的時間複雜度為 O(n).

public class Solution {
    /*
     * @param numbers : An array of Integer
     * @param target : target = numbers[index1] + numbers[index2]
     * @return : [index1 + 1, index2 + 1] (index1 < index2)
     */
    public int[] twoSum(int[] numbers, int target) {
        int[] res = new int[2];
        Hashtable<Integer, Integer> hash = new Hashtable<Integer, Integer>();
        for (int i = 0; i < numbers.length; ++i) {
            if (hash.containsKey(numbers[i])) {
                res[0] = hash.get(numbers[i]);
                res[1] = i + 1;
                return res;
            }
            hash.put(target - numbers[i], i + 1);
        }
        return res;
    }
}

注意：這裡不能使用類似以上兩題的解法，因為題目要求返回下標，而排序會丟棄陣列元素的下標資訊，因此不能排序。