LeetCode力扣算法题 ：两数之和 、三数之和问题

两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

2 <= nums.length <= 103
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

方法一：用Hashmap(最快)

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> map = new HashMap<>();
        int[] indexs = new int[2];
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(target-nums[i])){
                indexs[1]=i;
                indexs[0]=map.get(target-nums[i]);
                return  indexs;
            }
            map.put(nums[i],i);
        }
        return indexs;
    }
}

三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

 public List<List<Integer>> threeSum(int[] nums) {
        //1.给数组排序
        Arrays.sort(nums);
        //2.指定三个指针i，j，k，固定k在最左，i在k右1，j在最右，移动完i，j后再移动k
        int k = 0;
        int i = 0;
        int j = 0;
        List<List<Integer>> res = new ArrayList<>();
        //2.1固定k，左右加逼移动i，j
        for (k = 0; k < nums.length - 2; k++) {
            i = k + 1;
            j = nums.length - 1;
            while (nums[k] <= 0) {  //num[k]>0，直接结束
                if (k > 0 && nums[k] == nums[k - 1]) {  //移动k过后num[k]如果与移动前num[k-1]相等,跳出本次while，直接k右移
                    break;
                }
                if (i >= j) {  //若i>=j,k直接右移
                    break;
                }
                //移动i，j
                for (i = k + 1, j = nums.length - 1; i < j; ) {
                //计算等于0，将其保存至结果集合，i右移，j左移，并用continue跳出本次循环，否则ij会带着移动后的值继续执行下面的代码，漏掉许多情况。
                    if (nums[k] + nums[i] + nums[j] == 0) {
                        res.add(Arrays.asList(nums[k], nums[i], nums[j]));
                        i++;
                        j--;
                        continue;
                    }
                    if (nums[k] + nums[i] + nums[j] > 0) {
                        j--;
                        while (true) {
                        //重复，则j再左移，但一定要大于i，否则有可能越界
                            if (nums[j] != nums[j + 1]) {
                                break;
                            }
                            if (nums[j] == nums[j + 1] ) {
                                j--;
                                if ( i >= j){ break;}
                            }
                        }
                        continue;
                    }
                    if (nums[k] + nums[i] + nums[k] < 0) {
                        i++;
                        while (true) {
                        //重复，则i再右移，但一定要小于j，否则有可能越界，比如{-3，-2，-2,0，0}
                            if (nums[i] != nums[i - 1]) {
                                break;
                            }
                            if (nums[i] == nums[i - 1] ) {
                                i++;
                                if ( i >= j){ break;}
                            }
                        }
                        continue;
                    }
                }
            }
        }
        //对集合进行去重得到最终结果
        List<List<Integer>> collect = res.stream().distinct().collect(Collectors.toList());
        return collect;
    }