力扣（LeetCode） 1.两数之和（java）

题目

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。

输入：nums = [1,4,6,8,12], target = 14
输出：[2,3]
解释：因为 nums[2] + nums[3] == 14 ，返回 [2, 3] 。

第一种：嵌套for循环

public static void main(String[] args) {
        TwoSum twoSum = new TwoSum();

        int nums[] = {1,4,6,8,12};
        int[] result = twoSum.twoSum(nums, 14);
        System.out.println(Arrays.toString(result));
    }

    //时间复杂度 O(n2) 空间复杂度：O(1)
    public int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i+1; j < nums.length; j++) {
                if ((nums[i]+nums[j]) == target) {
                    return new int[]{i,j};
                }
            }
        }
        throw new RuntimeException("没有结果");
    }

第二种：空间换时间（HashMap） 

public static void main(String[] args) {
        TwoSum twoSum = new TwoSum();

        int nums[] = {1,4,6,8,12};
        int[] result2 = twoSum.twoSum2(nums, 14);
        System.out.println(Arrays.toString(result2));
    }


    //时间复杂度 O(n) 空间复杂度：O(n)
    public int[] twoSum2(int[] nums, int target) {
        //牺牲空间换取时间
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int diff = target - nums[i];
            if (map.containsKey(diff) && map.get(diff) != i) {
                return new int[]{map.get(diff), i};
            }
            map.put(nums[i], i);
        }

        throw new RuntimeException("没有结果");
    }

LeetCode测试结果

第三种：进一步压缩循环次数

public class TwoSum {

    public static void main(String[] args) {
        TwoSum twoSum = new TwoSum();

        int nums[] = {1,4,6,8,12};
        int[] result = twoSum.twoSum(nums, 14);
        System.out.println(Arrays.toString(result));
    }

    //进一步压缩循环次数
    public int[] twoSum(int[] nums, int target) {
        //牺牲空间换取时间
        HashMap<Integer, Integer> map = new HashMap<>();
        int i = 0;
        int j = nums.length-1;
        while (i<=j) {
            if (map.containsKey(target-nums[i])) {
                return new int[]{map.get(target-nums[i]), i};
            } else {
                map.put(nums[i], i);
            }
            if (map.containsKey(target-nums[j])) {
                return new int[]{map.get(target-nums[j]), j};
            } else {
                map.put(nums[j], j);
            }
            i++;
            j--;
        }
        throw new RuntimeException("没有结果");
    }

}

LeetCode测试结果