一、題目說明

Given an array of integers, return indices of the two numbers such that they add up to a specific target.
You may assume that each input would have exactly one solution.

Example:
Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].
查看原題;
查看我的Github項目地址;
題目很簡單：給定一個int數(shù)組和一個目標值，返回數(shù)組中兩個數(shù)之和等于目標值的這兩個數(shù)的索引。

二、解題

2.1 窮舉法

這是首先想到的方法，也是最簡單直接的方法。
遍歷所有兩個數(shù)之和，找到等于目標值的兩個數(shù)即可。
代碼如下：

public static int[] twoSumByExhaustive(int[] arr, int target) {
    int[] result = new int[2];
    for (int i = 0; i < arr.length; i++) {
        for (int j = i+1; j < arr.length; j++) {
            if (arr[i] + arr[j] == target) {
                result[0] = i;
                result[1] = j;
                break;
            }
        }
    }
    return result;
}

很多算法都可以用窮舉法解決，但是作為一個有理想有追求的程序猿，怎可滿足于此。

2.2 以空間換時間

問：求兩個數(shù)之和等于目標值有其他的描述方式么？
答：有，也可以說是求目標值和其中一個數(shù)之差在數(shù)組中的位置。
于是，很自然我們想到了以空間換取時間，用HashMap存儲之差，然后循環(huán)數(shù)組找到等于差的數(shù)。
代碼如下：

public static int[] twoSumByMap(int[] nums, int target) {
    int[] result = new int[2];
    Map<Integer, Integer> map = new HashMap();
    for (int i = 0; i < nums.length; i++) {
        if (map.containsKey(nums[i])) {
            result[0] = map.get(nums[i]);
            result[1] = i;
        } else {
            map.put(target - nums[i], i);
        }
    }
    return result;
}

2.3 排序后再查找

問：假如數(shù)組是有序的，那么是不是可以更快的找到結(jié)果？
答：如果是有序數(shù)組，那就可以一趟循環(huán)二路查找結(jié)果，自然更快。
但是這會有幾個問題：
1.排序的消耗？
可以采用快排等高性能排序算法
2.排序后如何返回正確的索引？
可以HashMap存鍵值對，然后查找索引。但是如果鍵是相同的數(shù)，索引就會出錯。
可以copy一份原數(shù)組，查找索引。
代碼如下：

public static int[] twoSumBySort(int[] nums, int target) {
    int[] result = new int[2];
//  int[] copyNums = nums.clone();
    int[] copyNums = new int[nums.length];
    System.arraycopy(nums, 0, copyNums, 0, nums.length);
//  可以自己寫排序算法
    Arrays.sort(nums);
    int sIndex = 0;
    int eIndex = nums.length - 1;
    for (int i = 0; i < nums.length; i++) {
        if (nums[sIndex] + nums[eIndex] == target) {
            result[0] = nums[sIndex];
            result[1] = nums[eIndex];
            break;
        } else if (nums[sIndex] + nums[eIndex] > target) {
            eIndex--;
        } else {
            sIndex++;
        }

    }

    boolean fGit = false;
    for (int i = 0; i < copyNums.length; i++) {
        if (!fGit && copyNums[i] == result[0]) {
            sIndex = i;
            fGit = true;
        } else if (copyNums[i] == result[1]) {
            eIndex = i;
        }
    }
    if (sIndex > eIndex) {
        result[0] = eIndex;
        result[1] = sIndex;
    } else {
        result[0] = sIndex;
        result[1] = eIndex;
    }

    return result;
}