算法刷题三：两数之和，三数之和，四数之和

最新推荐文章于 2022-05-14 23:44:08 发布

ZhaoSimonone

最新推荐文章于 2022-05-14 23:44:08 发布

阅读量387

点赞数 4

分类专栏：算法文章标签：数据结构 leetcode java 算法

本文链接：https://blog.csdn.net/qq_42799615/article/details/113076989

版权

算法专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

两数之和

题目链接：LeetCode1.两数之和

题目概要

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

暴力循环法

用两层循环，由于输入只对应着一个答案，因此当nums[i] + nums[j]) == target (i != j)时，立即返回就可以。

public int[] twoSum(int[] nums, int target) {
  if (nums == null || nums.length <= 1) {
    return null;
  }
  for (int i = 0; i < nums.length - 1; ++i) {
    for (int j = i + 1; j < nums.length; ++j) {
      if ((nums[i] + nums[j]) == target && i != j) {
        return new int[]{i, j};
      }
    }
  }
  return null;
}

使用HashMap

使用HashMap，nums[i]作为key，i作为value。一边遍历一边检查map的key，看target - nums[i]是否存在于map的key中。如果不存在，则将当前遍历到的值作为key，下标作为value放入map中。

题目中有一个条件：假设每种输入只会对应一个答案，也就是说一旦找到两个数之和为target，不用多想，它一定是要的答案，然后返回即可。但是到下面的三数之和，四数之和就要考虑其它的因素。

public int[] twoSum(int[] nums, int target) {
  if (nums == null || nums.length == 0) {
    return null;
  }
  Map<Integer, Integer> map = new HashMap<>();
  for (int i = 0; i < nums.length; ++i) {
    if (map.containsKey(target - nums[i])) {
      return new int[]{map.get(target - nums[i]), i};
    } else {
      map.put(nums[i], i);
    }
  }
  return null;
}

三数之和

题目链接：LeetCode15.三数之和

题目概要

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

这个题就比较坑了。

我试了好多次才终于过了。
在这里插入图片描述
坑点一
当nums.length < 3时，不是返回一个null，而是返回一个空的List。平时写代码写习惯了，当输入不满足题意时，直接返回一个null，但是此题要求返回一个空的List（一个空的List和null完全不是一回事，空的List说明该List的引用指向了一块内存地址，只是这块内存地址没有任何数据，null则说明这个引用没有执行任何内存地址）。
在这里插入图片描述

坑点二
去重
比如输入[0,0,0,0,0,0,0,0]。里面的每个值都相同，但最终只能有一组答案。对于去重，我使用了一个Set<String>。每次得到和为0的三个数时，比如[1,2,-3]，先将其转化为字符串"-123"，然后检测set中是否有相同的字符串，如果没有则将其放入答案中，然后将该字符串放入set中。前提是得先将数组进行排序。这样就能避免得到的是[-3,2,1],[1,2,-3]这样的重复答案，但是他们对应的字符串却不相同。
在这里插入图片描述
然后后面就是慢慢的调整算法。
算法的思路：先用Arrays.sort(nums);将数组进行排序。使用三个指针，不断进行挪动。先在一层循环中固定住left。然后判断(nums[left] + nums[mid] + nums[right])是大于0，等于0，还是小于0。如果等于0，那么mid向右移动一个单位，right向右移动一个单位。如果大于0，那么mid保持不动，right向左移动。如果小于0，那么就在一个循环里不断移动mid，直至三数之和不小于0。

按照暴力循环的思路，是需要三层循环，使用三个指针的方式，实际上相当于是将三层循环降为了二层循环。
在这里插入图片描述
代码：

class Solution {
  public List<List<Integer>> threeSum(int[] nums) {
    List<List<Integer>> ans = new ArrayList<>();
    if (nums == null || nums.length < 3) {
      return ans;
    }
    Arrays.sort(nums);
    Set<String> set = new HashSet<>();
    int left = 0;
    while (left < nums.length - 2) {
      if (nums[left] > 0) {
        ++left;
        continue;
      }
      if (left > 0 && (nums[left] == nums[left - 1])) {
        ++left;
        continue;
      }
      int mid = left + 1, right = nums.length - 1;
      while (right - left >= 2 && mid < right) {
        //当mid = left + 1时，如果三数之和加起来大于0，只能移动right指针，
        if ((nums[left] + nums[mid] + nums[right]) > 0) {
          --right;
        } else if ((nums[left] + nums[mid] + nums[right]) == 0) {
          List<Integer> list = addToListAndCheckIsRepeat(nums[left], nums[mid], nums[right], set);
          if (list != null) {
            ans.add(list);
          }
          ++mid;
          --right;
        } else {
          //三数之和小于0则不断移动mid指针,直至三数之和不小于0
          while (mid < right && (nums[left] + nums[mid] + nums[right]) < 0) {
            if ((nums[left] + nums[mid] + nums[right]) == 0) {
              List<Integer> list = addToListAndCheckIsRepeat(nums[left], nums[mid], nums[right], set);
              if (list != null) {
                ans.add(list);
              }
              --right;
              ++mid;
            } else {
              ++mid;
            }
          }
        }
      }
      ++left;
    }
    return ans;
  }

  private List<Integer> addToListAndCheckIsRepeat(int left, int mid, int right, Set<String> set) {
    String tmp = "" + left + mid + right;
    if (!set.contains(tmp)) {
      List<Integer> list = new ArrayList<>();
      list.add(left);
      list.add(mid);
      list.add(right);
      set.add(tmp);
      return list;
    } else {
      set.add(tmp);
      return null;
    }
  }
}

优化方向：

不用Set去重，转化为字符串太费时间。
增加一些去重的判断。比如移动right指针时，发现移动后的值等于移动前的值，那么就继续移动。

四数之和

题目链接：LeetCode18.四数之和

题目概要

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：
答案中不可以包含重复的四元组。

思路与三数之和相似。使用四个指针，将循环次数降低为三次。

class Solution {
  public List<List<Integer>> fourSum(int[] nums, int target) {
    List<List<Integer>> ans = new ArrayList<>();
    if (nums == null || nums.length < 4) {
      return ans;
    }
    Arrays.sort(nums);
    Set<String> set = new HashSet<>();
    for (int i = 0; i <= nums.length - 4; ++i) {
      if (i != 0 && nums[i] == nums[i - 1]) {
        continue;
      }
      //当前i固定的情况下，最小的四个数都要大于target，就不用往后面走了
      if ((nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3]) > target) {
        break;
      }
      //当前i固定的情况下，最大的四个数都要小于target，可以结束当前i开始的循环了，增大i
      if ((nums[i] + nums[nums.length - 3] + nums[nums.length - 2] + nums[nums.length - 1]) < target) {
        continue;
      }
      for (int j = i + 1; j <= nums.length - 3; ++j) {
        int k = j + 1, l = nums.length - 1;
        while (k < l) {
          if ((nums[i] + nums[j] + nums[k] + nums[l]) > target) {
            --l;
          } else if ((nums[i] + nums[j] + nums[k] + nums[l]) == target) {
            List<Integer> list = addToListAndCheckIsRepeat(nums[i], nums[j], nums[k], nums[l], set);
            if (list != null) {
              ans.add(list);
            }
            ++k;
            --l;
          } else if ((nums[i] + nums[j] + nums[k] + nums[l]) < target) {
            while ((k < l) && (nums[i] + nums[j] + nums[k] + nums[l]) < target) {
              ++k;
            }
            if ((k < l) && (nums[i] + nums[j] + nums[k] + nums[l]) == target) {
              List<Integer> list = addToListAndCheckIsRepeat(nums[i], nums[j], nums[k], nums[l], set);
              if (list != null) {
                ans.add(list);
              }
              ++k;
              --l;
            }
          }
        }
      }
    }
    return ans;
  }

  public List<Integer> addToListAndCheckIsRepeat(int i, int j, int k, int l, Set<String> set) {
    List<Integer> list = new ArrayList<>();
    String tmp = "" + i + j + k + l;
    if (!set.contains(tmp)) {
      set.add(tmp);
      list.add(i);
      list.add(j);
      list.add(k);
      list.add(l);
      return list;
    }
    return null;
  }
}