Leetcode-threeSum

力控 三数之和 题解分享

三数之和

做了三次 次次忘记 次次做法不同【facepalm】

这不是一道难题吧

分享一下这一有趣的经历

第一次

当时比较暴力 没有什么参考价值 只能说能通过测试

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
         Arrays.sort(nums);
        List<List<Integer>> list_three = new ArrayList<>();
        HashMap<Integer,Integer> map = new HashMap<>();
        if (nums.length < 3){
            return list_three;
        }
        int i;
        int j = 1;
        int k = 2; // 规定i<j<k
        int h;
        for (;k<nums.length;k++){
            map.put(nums[k],k);//若有重复，不断把记录索引变为更大的值
        }
        boolean flag1 = false;
        boolean flag2 = false;
        for (;j<nums.length-1;j++){
            if (j > 1 && nums[j] == nums[j-1] && flag1){
                boolean re_flag = false;
                for (int index = 0;index < j-1;index++){
                    if (nums[j-1] == nums[index]){
                        re_flag = true; //表示这个元素在之前出现过了
                    }
                }
                if(map.containsKey(-(2*nums[j])) && !re_flag){
                    if (map.get(-2*(nums[j])) > j){
                        list_three.add(new ArrayList<>(Arrays.asList(nums[j], nums[j],-2*nums[j])));
                    }
                }
                if (j+1 < nums.length-1){
                    continue;
                }else{
                    break;
                }
            }
            flag1 = false;
            for (i = 0;i<j;i++){
                if (i > 0 && nums[i] == nums[i-1] && flag2){
                    if (i+1 < j){
                        continue;
                    }else{
                        break;
                    }
                }
                flag2 = false;
                if (map.containsKey(-(nums[i]+nums[j]))){
                    h = map.get(-(nums[i]+nums[j]));
                    if (h> j){
                        list_three.add(new ArrayList<>(Arrays.asList(nums[i], nums[j], nums[h])));
                        flag2 = true;
                        flag1 = true;
                    }
                }

            }
        }
       
        return list_three;
    }
}

第二次

双指针的写法 比较经典

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        if (nums.length < 3) {
            return res;
        }
        Arrays.sort(nums);
        for (int i  = 0 ; i < nums.length - 2 ; i ++) {
            //去重
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            //剪枝操作
            //最左边的值太小了
            if (nums[i] + nums[nums.length - 1] + nums[nums.length - 2] < 0) {
                continue;
            }
            // 最左边的值太大了
            if (nums[i] > 0) {
                break;
            }
            //规定i < j < k
            int j = i + 1;
            int k = nums.length - 1;

            while (j < k) {
                int tempNum = nums[i] + nums[j] + nums[k];
                if (tempNum > 0 ) {
                    k --;
                }else if (tempNum < 0 ) {
                    j ++;
                }else {
                    res.add(Arrays.asList(nums[i] , nums[j] , nums[k]));
                    j ++;
                    k --;
                    while (j < k && (nums[j] == nums[j - 1])) {
                        j ++;
                    }
                    while (j < k && (nums[k] == nums[k + 1])) {
                        k --;
                    }
                }
            }
        }
        return res;

    }
}

第三次

多层for 配合 hashmap

class Solution {
     public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();

        Arrays.sort(nums);
        Map<Integer , Integer> map = new HashMap<>();
        for (int index = 0 ; index < nums.length ; index ++) {
            map.put(nums[index] , index);
        }
       

        for (int i = 0 ; i  < nums.length - 2 ; i ++) {
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            if (nums [i] > 0 ){
                break;
            }
            for (int j = i + 1 ; j  < nums.length - 1 ; j ++) {
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;
                }
                if (nums[i] + nums[j] > 0) {
                    break;
                }

                int target = - (nums[i] + nums[j]);
                if (map.containsKey( target )) {
                    int index = map.get(target);
                    if (index > j) {
                        res.add(Arrays.asList(nums[i] , nums[j] , target));
                    }
                }
            }
        }
        return res;
    }
}