版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/hang404/article/details/84896175
题目描述：
给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：
答案中不可以包含重复的四元组。
示例：
给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
满足要求的四元组集合为：
[
[-1, 0, 0, 1],
[-2, -1, 1, 2],
[-2, 0, 0, 2]
]
题目解答：
方法1：双指针
采用和三数之和相同的方法，先排序，然后外边是两层for循环，里边用双指针。注意需要跳过重复元素。
在该题中有一些优化措施，比如在两层循环之内，前两个数字a, b已经确定，现在我们选择最后两个数字c, d（加上前两个数字a, b）来组成目标四个数字，此时如果比target还小，说明即使后两个数字我们选择最大的，也不能等于target，所以前两个数字a, b选的太小了，所以可以直接增大第二个数字b；如果现在我们选择第二个数字b后边紧接着的两个数字c, d（加上前两个数字a, b）来组成目标四个数字，此时如果比target大，则无论如何也不会等于target，即前两个数字选的太大了，所以可以直接跳出，增大第一个数，第二个数字重新开始。
另外我先过滤了一些不合题意的数字，包括排序后数组最前边的和最后边的。比如最前边的，先假设我们选用最后三个最大的数字，此时加上最前边的数字a，其和比target还小，说明a这个数字太小，无效，需要向后挪动。
运行时间4ms，代码如下。
/**
* Return an array of arrays of size *returnSize.
* Note: The returned array must be malloced, assume caller calls free().
*/
int comp(const void* a, const void* b) {
return (*(int*)a > *(int*)b ? 1 : -1);
}
int** fourSum(int* nums, int numsSize, int target, int* returnSize) {
int n = numsSize, i = 0, j = 0;
if(n < 4)
return NULL;
qsort(nums, n, sizeof(int), comp);
int start = 0, end = 0;
int temp = nums[n - 1] + nums[n - 2] + nums[n - 3];
for(start = 0; start < n - 3 && nums[start] + temp < target; start++) { }
if(start == n - 3)
return NULL;
temp = nums[0] + nums[1] + nums[2];
for(end = n - 1; end > 2 && nums[end] + temp > target; end--) { }
if(end == 2)
return NULL;
// start <= i <= end
n = end - start + 1;
nums += start;
int** result = NULL;
int left = 0, right = 0, size = 0;
for(i = 0; i < n - 3; i++) {
for(j = i + 1; j < n - 2; j++) {
if(nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target)
break;
if(nums[i] + nums[j] + nums[n - 1] + nums[n - 2] < target)
continue;
left = j + 1; right = n - 1;
while(left < right) {
temp = nums[i] + nums[j] + nums[left] + nums[right];
if(temp < target)
left++;
else if(temp > target)
right--;
else {
size++;
result = (int**)realloc(result, size * sizeof(int*));
result[size - 1] = (int*)malloc(4 * sizeof(int));
result[size - 1][0] = nums[i]; result[size - 1][1] = nums[j];
result[size - 1][2] = nums[left]; result[size - 1][3] = nums[right];
while(nums[left] == nums[left + 1])
left++;
while(nums[right] == nums[right - 1])
right--;
left++;
right--;
}
}
while(nums[j] == nums[j + 1])
j++;
}
while(nums[i] == nums[i + 1])
i++;
}
*returnSize = size;
return result;
}
方法2：两组双指针
外边是一组双指针，里边也是一组双指针。注意重复元素的过滤。外层双指针的重复元素过滤不能放在最下边。因为对于右侧的重复元素，有可能在增加了left1之后还能使用，如果直接过滤掉，会导致缺少结果。
运行时间4ms，代码如下。
/**
* Return an array of arrays of size *returnSize.
* Note: The returned array must be malloced, assume caller calls free().
*/
int comp(const void* a, const void* b) {
return (*(int*)a > *(int*)b ? 1 : -1);
}
int** fourSum(int* nums, int numsSize, int target, int* returnSize) {
int n = numsSize, i = 0, j = 0;
if(n < 4)
return NULL;
qsort(nums, n, sizeof(int), comp);
int start = 0, end = 0;
int temp = nums[n - 1] + nums[n - 2] + nums[n - 3];
for(start = 0; start < n - 3 && nums[start] + temp < target; start++) { }
if(start == n - 3)
return NULL;
temp = nums[0] + nums[1] + nums[2];
for(end = n - 1; end > 2 && nums[end] + temp > target; end--) { }
if(end == 2)
return NULL;
// start <= i <= end
n = end - start + 1;
nums += start;
int** result = NULL;
int left1 = 0, right1 = n - 1, t = 0;
int left2 = 0, right2 = 0, size = 0;
while(left1 < right1) {
if(left1 > 0 && nums[left1] == nums[left1 - 1]) {
left1++;
continue;
}
if(right1 < n - 1 && nums[right1] == nums[right1 + 1]) {
right1--;
continue;
}
t = target - nums[left1] - nums[right1];
if(t > 2 * nums[right1]) {
left1++;
continue;
}
if(t < 2 * nums[left1]) {
left1 = 0;
right1--;
continue;
}
left2 = left1 + 1; right2 = right1 - 1;
while(left2 < right2) {
temp = nums[left2] + nums[right2] - t;
if(temp < 0)
left2++;
else if(temp > 0)
right2--;
else {
size++;
result = (int**)realloc(result, size * sizeof(int*));
result[size - 1] = (int*)malloc(4 * sizeof(int));
result[size - 1][0] = nums[left1]; result[size - 1][1] = nums[right1];
result[size - 1][2] = nums[left2]; result[size - 1][3] = nums[right2];
while(nums[left2] == nums[left2 + 1])
left2++;
while(nums[right2] == nums[right2 - 1])
right2--;
left2++;
right2--;
}
}
left1++;
}
*returnSize = size;
return result;
}