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

public class Solution {
    public int[] twoSum(int[] numbers, int target) {
        
    }
}

②乡村英语翻译一下

给你一个数字数组，找出来这里面哪两个数加起来正好是一个给定的数。

你要写的功能 twoSum 应该返回加起来是目标数的两个数字的序列，可是请注意，返回的数字是从小到大排列的，而后返回的数字和索引都不是从零蛋开始地。

你的答案能够是这样事的：

输入：numbers={2, 7, 11, 15}, target=9

输出：index1=1, index2=2

③读题

1：要写一个方法，两个参数，第一个参数是数字数组。第二个是参数是数字，为目标值。返回值是一个排序数组。

2：题目要求只有一个答案，貌似状况明朗了一些。

3：遍历数组是必不可少的，如何减少时间复杂度是该题的核心

④解题

public class Solution {
  //最烂的写法,两层循环，时间复杂度 n*n
    public int[] twoSumLow(int[] numbers, int target) {
        int[] returnArray = new int[2];
        boolean flag = false;
        for (int i = 0, j = numbers.length; i < j; i++) {
            if (flag) {
                break;
            }
            int tempNum1 = numbers[i];
            for (int m = numbers.length - i, n = numbers.length; m < n; m++) {
                int tempNum2 = numbers[m];
                if (tempNum1 + tempNum2 == target) {
                    returnArray[0] = tempNum1 < tempNum2 ? tempNum1 : tempNum2;
                    returnArray[1] = tempNum1 < tempNum2 ? tempNum2 : tempNum1;
                    flag = true;
                    break;
                }
            }
        }
        return returnArray;
    }

    //这个靠谱了吧 ,时间更多的消耗在排序上 时间复杂度 n*log(n)
    public int[] twoSum(int[] numbers, int target) {
        Arrays.sort(numbers);
        int[] returnArray = new int[2];
        int i = 0, j = numbers.length - 1;
        boolean flag = false;
        while (!flag) {
            if (numbers[j] > target || numbers[i] + numbers[j] > target) {
                j--;
            }
            if (numbers[i] + numbers[j] < target) {
                i++;
            }
            if (numbers[i] + numbers[j] == target) {
                returnArray[0] = numbers[i];
                returnArray[1] = numbers[j];
                flag = true;
            }
        }
        return returnArray;
    }

    //理论上作算法题应该禁用语言工具的，不过反过来看用语言工具能帮助咱们增长应用语言的能力不是嘛，时间复杂度 n
    public int[] twoSumHash(int[] numbers, int target) {
        HashMap<Integer, Integer> numbersHash = new HashMap<Integer, Integer>(20000);
        int[] returnArray = new int[2];
        for (int i = 0, j = numbers.length; i < j; i++) {
            int tempNum = numbers[i];
            int key = target - tempNum;
            if (numbersHash.get(key) != null) {
                int otherNum = numbersHash.get(key);
                returnArray[0] = tempNum < otherNum ? tempNum : otherNum;
                returnArray[1] = tempNum < otherNum ? otherNum : tempNum;
                break;
            } else {
                numbersHash.put(tempNum, tempNum);
            }
        }
        return returnArray;
    }

    public static void main(String[] args) {
        TwoSum twoSum = new TwoSum();
        int[] numbers = new int[10000];
        ArrayList<Integer> numList = new ArrayList<Integer>(10000);
        for (int i = 0, j = 10000; i < j; i++) {
            numList.add(i + 1);
        }
        Collections.shuffle(numList);
        for (int i = 0, j = 10000; i < j; i++) {
            numbers[i] = numList.get(i);
        }
        long nowTime = System.currentTimeMillis();
        int[] answerArray = twoSum.twoSum(numbers, 19999);
        System.out.println("use time :" + (System.currentTimeMillis() - nowTime));
        System.out.println("Index1:" + answerArray[0]);
        System.out.println("Index2:" + answerArray[1]);

        long nowTimeLow = System.currentTimeMillis();
        int[] answerArrayLow = twoSum.twoSumLow(numbers, 19999);
        System.out.println("use time :" + (System.currentTimeMillis() - nowTimeLow));
        System.out.println("Index1:" + answerArrayLow[0]);
        System.out.println("Index2:" + answerArrayLow[1]);

        long nowTimeHash = System.currentTimeMillis();
        int[] answerArrayHash = twoSum.twoSumHash(numbers, 19999);
        System.out.println("use time :" + (System.currentTimeMillis() - nowTimeHash));
        System.out.println("Index1:" + answerArrayHash[0]);
        System.out.println("Index2:" + answerArrayHash[1]);
    }
}