前言
在打卡了力扣的两数之和、三数之和以及四数之和之后，我打算对这个类型的题目进行一个简单的总结，来一次性理解透彻这方面的问题！
题目描述
下面首先我们一个一个的来分析两数之和、三数之和、四数之和以及他们所采用的方法，并最后对这些做总结，延申到其他的n数之和
1. 两数之和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
思路整理：
分析题目我们可以知道，这道题目的要求就是在一个数组中找到两个数据使得这两个数据的和为我们需要的目标值，但是同一个位置上的数据不能同时使用两次。
方法一：我们可以采用暴力求解的方式，采用双重循环，对数组进行遍历，最后求得数据之和
class Solution {
public int[] twoSum(int[] nums, int target) {
for(int i=0;i<nums.length-1;i++){
for(int j=i+1;j<nums.length;j++){
if(nums[i]+nums[j]==target)
return new int[]{i, j};
}
}
return new int[0];
}
}方法二：使用Hash表，之所以可以这么使用，就是因为我们之前的暴力破解的方式的时间似乎都是花费在了求target-nums[i]上，那么有没有一种可能，我们可以先判断target-nums[i]是不是存在，然后再进行查找呢？
我们使用HashMap的方式，存储键值对，然后我们使用一层的for循环进行查找，如果我们存在当前位置的值与目标值的差的数据的话，我们就返回target-nums[i]对应的值（也就是对应的位置）和当前的i；如果不存在就加入进去，以此类推，最后会得到我们想要的结果！
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
for (int i = 0; i < nums.length; ++i) {
if (hashtable.containsKey(target - nums[i])) {
return new int[]{hashtable.get(target - nums[i]), i};
}
hashtable.put(nums[i], i);
}
return new int[0];
}
}
错误方法：使用双指针的方式 × 这里不可以使用双指针，因为他需要的是返回数组下标，所以不能这么使用！你排序之后就会打乱数组下标，最后得到的结果必然错误！
2. 三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
对于这个题目，我们可以发现这个题目和我们的两数之和其实是很相像的，两者的不同在于这道题目需要的是得到目标三元组，也就是具体的值，但是两数之和是得到下标。
那么对于这个题目我们有下面的方法
方法一：三重暴力求解！前面对于两数之和，我们使用双重暴力求解的方法得到了最后的结果，然后我们可以使用数组或者集合进行封装【但是我这里写出来的暴力求解的方式还是存在问题，就是没有去重，在力扣里面45 / 311】
class Solution {
public static List<List<Integer>> threeSum(int[] nums) {
//创建一个二维集合来装载我们想要的数据，他相比于二维数组来说，功能更加的强大
List<List<Integer>> ans=new ArrayList();
int n=nums.length;
if(nums.length<3) return ans;
for(int i=0;i<n-2;i++){
for(int j=i+1;j<n-1;j++){
for(int m=j+1;m<n;m++){
if(nums[i]+nums[j]+nums[m]==0)
{ ansans.add(Arrays.asList(nums[i],nums[L],nums[R])); }
}
}
}
return ans;
}
}改进版本的暴力求解---添加去重
class Solution {
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;
}
}方法二：双指针【好了，其实上面的暴力求解并不重要，因为大部分人都可以想得到，我们这里需要做的就是我在两数之和里面也提到过的双指针的方法】
双指针的基本思路就是固定一个数据，然后后面两个数据进行运算，如果后面两个数据与固定的这个数据的和小于0，那么前面的数据就要往后移，否则，后面的数据往前移动，以此类推！如果数据正好等于0，那么就需要判断前面的数据的后一位和它想不想等，相等就后移，后面的数据也要做这样的操作，然后操作完之后两个数据还要同时向前向后移动一次！最后就可以得到我们想要的结果了！
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> ans=new ArrayList();
int n=nums.length;
if(n<3) return ans;
Arrays.sort(nums);
for (int i = 0; i < len ; i++) {
if(nums[i] > 0) break; // 如果当前数字大于0，则三数之和一定大于0，所以结束循环
if(i > 0 && nums[i] == nums[i-1]) continue; // 去重
int L = i+1;
int R = len-1;
while(L < R){
int sum = nums[i] + nums[L] + nums[R];
if(sum == 0){
ans.add(Arrays.asList(nums[i],nums[L],nums[R]));
while (L<R && nums[L] == nums[L+1]) L++; // 去重
while (L<R && nums[R] == nums[R-1]) R--; // 去重
L++;
R--;
}
else if (sum < 0) L++;
else if (sum > 0) R--;
}
}
return ans;
}
}3. 四数之和
给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
方式一：暴力求解
这个题目当然还是可以使用暴力求解的方式，但是是时间复杂度已经高达O(N^4)，那么这里就不作演示
方式二：双指针
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> quadruplets = new ArrayList<List<Integer>>();
if (nums == null || nums.length < 4) {
return quadruplets;
}
Arrays.sort(nums);
int length = nums.length;
for (int i = 0; i < length - 3; i++) {
if (i > 0 && nums[i] == nums[i - 1]) {
continue;
}
if ((long) nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) {
break;
}
if ((long) nums[i] + nums[length - 3] + nums[length - 2] + nums[length - 1] < target) {
continue;
}
for (int j = i + 1; j < length - 2; j++) {
if (j > i + 1 && nums[j] == nums[j - 1]) {
continue;
}
if ((long) nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) {
break;
}
if ((long) nums[i] + nums[j] + nums[length - 2] + nums[length - 1] < target) {
continue;
}
int left = j + 1, right = length - 1;
while (left < right) {
int sum = nums[i] + nums[j] + nums[left] + nums[right];
if (sum == target) {
quadruplets.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
while (left < right && nums[left] == nums[left + 1]) {
left++;
}
left++;
while (left < right && nums[right] == nums[right - 1]) {
right--;
}
right--;
} else if (sum < target) {
left++;
} else {
right--;
}
}
}
}
return quadruplets;
}
}
这里使用双指针实际上和三数之和差不多，三数之和是首先固定一个数据，但是在这里是固定两个数据，然后再对后面的数据进行双指针的操作，相比之下只是多了一层for循环的嵌套而已。
总结
做完了上面的三个题目，我们可以在有如下总结：
1. 其实我们看到的很多的题目都可以使用暴力求解，但是就是因为我们追求更高的要求，开发出来了其他的方式，我们一般都会选择空间换时间的方式
2. 我们什么时候可以使用双指针的方式进行求解？
通过这几道题目，我们可以知道，双指针的作用在于它可以简化操作，可以帮助我们更快的找到答案！所以，当我们遇到需要对数组进行遍历的时候我们都可以使用双指针，无论是求和、查值等等！
348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
