三数之和(暴力和双指针解法)

三数之和

题目链接

https://leetcode-cn.com/problems/3sum/

解法1：暴力

暴力初步（排序 + 三重循环暴力）

这个算法需要三重循环，时间复杂度是O(n^3)

LeetCode给出了313个测试用例，这个暴力解法通过了310个用例

public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> results = new LinkedList<>();
        //排序
        Arrays.sort(nums);
        for(int i = 0; i < nums.length - 2; i++){
            int x = nums[i];
            //去重，假如给的用例是[0, 0, 0, 0],当i第一次遇到0时，为首次遇见没有关系，可如果这次i的循环结束了
            //i+1进入第二次循环，那么这时候还是遇到0，为连续的第二次遇见，这就造成了前后重复，必须要跳过
            if(i > 0 && nums[i - 1] == nums[i]) continue; 
            for(int j = i + 1; j < nums.length - 1; j++){
                int y = nums[j];
                //去重原理同i，j必须大于i + 1，因为j是从i + 1开始的，假如这时开始就后退一步，就去到i的地盘了
                if(j > i + 1 && nums[j - 1] == nums[j]) continue;  
                for(int k = j + 1; k < nums.length; k++){
                    int z = nums[k];
                    if(k > j + 1 && nums[k - 1] == nums[k]) continue;  //去重原理同j
                    if(x + y + z == 0){
                        List<Integer> list = new LinkedList<Integer>();
                        list.add(x);
                        list.add(y);
                        list.add(z);
                        results.add(list);
                    }
                }
            }
        }
        return results;
    }

暴力优化（排序 + 两重循环 + HashMap）

上面的解法用了三重循环，我们优化的方向就是如何减少一层循环，比如减少第三层循环。

可以用HashMap来替代第三重循环，因为第三重for循环是用来查找第三个数的，HashMap一样可以用来查找，而且for循环的查找效率是O(n)，HashMap的查找效率是O(1)，只不过我们需要付出空间作为代价，以空间换时间。用HashMap来替代最后一层for循环就是一个很常见的套路，慢慢的就会见惯不怪了，两数之和那道题也可以尝试一下这个做法。

public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> results = new LinkedList<>();
        //排序
        Arrays.sort(nums);
        //用一个HashMap将所有的元素加进去，这里的keys是nums[i]，value是i
        //如果出现重复的key,那么新出现的value将会覆盖前面的一个value，我们用这个map来替代第三重循环
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++){
            map.put(nums[i], i);
        }
        for(int i = 0; i < nums.length - 2; i++){
            int x = nums[i];
            //去重，假如给的用例是[0, 0, 0, 0],当i第一次遇到0时，为首次遇见没有关系，可如果这次i的循环结束了
            //i+1进入第二次循环，那么这时候还是遇到0，为连续的第二次遇见，这就造成了前后重复，必须要跳过
            if(x > 0) break;
            if(i > 0 && nums[i - 1] == nums[i]) continue; 
            for(int j = i + 1; j < nums.length - 1; j++){
                int y = nums[j];
                if(x + y > 0) break;
                //去重原理同i，j必须大于i + 1，因为j是从i + 1开始的，必须要大于开始值才能后退一步
                if(j > i + 1 && nums[j - 1] == nums[j]) continue;  
                //z为组合需要的那个值
                int z = 0 - x - y;
                //如果map集合里面有这个值，最重要的是要判断它的value（序号）是不是在i和j的后面
                //因为之前的第三重for循环的k是从j + 1开始的，所以它一定会大于j
                if(map.containsKey(z) && map.get(z) > j){
                    List<Integer> list = new LinkedList<Integer>();
                    list.add(x);
                    list.add(y);
                    list.add(z);
                    results.add(list);
                }
            }
        }
        return results;
    }

解法2：双指针

public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> results = new LinkedList<>();
        if(nums.length < 3) return results; //长度小于3,就不存在三数之和了
        //排序
        Arrays.sort(nums);
        for(int i = 0; i < nums.length - 2; i++){
            //小优化：如果第一个数就大于0，那就没必要再查找下去了
            if(nums[i] > 0) break;
            //考虑i的会重复
            if(i > 0 && nums[i - 1] == nums[i]) continue;
            //定义两个指针，left指针，right指针，left为要查找的第二个数的坐标，right为要查找的第三个数的坐标
            int left = i + 1;
            int right = nums.length - 1;
            
            //left指针在这个过程中适当向右移，right指针也可能会向左移，但必须保证left在right的左边
            while(left < right){            
                //三数之和有三种情况，三数之和大于0，三数之和小于0，三数之和等于0
                //1.三数之和大于0，right坐标的那个数太大了，要把它向左移一步
                if(nums[i] + nums[left] + nums[right] > 0){
                    //向左移一步后有可能会等于left指针，也有可能会和后一个值重复，要去重
                    while(left < right && nums[right] == nums[--right]);
                }
                //2.三数之和小于0，因为right坐标的数是三数中最大的，三数之和小于0就是因为左边left的那个数不够给力
                else if(nums[i] + nums[left] + nums[right] < 0){
                    //左指针向右移一步后有可能会等于ringht指针，也有可能会和前一个值重复，要去重
                    while(left < right && nums[left] == nums[++left]);
                }
                //3.三数之和等于0，添加到返回列表里面，并且同时将左指针右移，右指针左移，探索下一组适合的数据
                else if(nums[i] + nums[left] + nums[right] == 0){ 
                    List<Integer> list = new LinkedList<>();
                    list.add(nums[i]);
                    list.add(nums[left]);
                    list.add(nums[right]);
                    results.add(list);
                    while(left < right && nums[left] == nums[++left]);
                    while(left < right && nums[right] == nums[--right]);
                }
            }
        }
        return results;
    }