你一个由 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
你可以按 任意顺序 返回答案 。
示例 1：
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]示例 2：
输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]提示：
- 1 <= nums.length <= 200
- -109 <= nums[i] <= 109
- -109 <= target <= 109
思路：
- 函数定义：fourSum 函数接收两个参数：一个整数数组 nums 和一个目标值 target。
- 排序：首先对数组 nums 进行排序，以便使用双指针法。
- 初始化结果数组：定义一个空数组 results 用于存储所有满足条件的四元组。
- 外层循环：使用变量 i 从 0 到 nums.length - 3 进行循环，因为至少需要选择 4 个元素，所以循环的上限是数组长度减去 3。
- 跳过重复元素：如果当前元素 nums[i] 与前一个元素相同，则跳过，避免产生重复的四元组。
- 次外层循环：使用变量 j 从 i + 1 到 nums.length - 2 进行循环，选择与 i 不同的第二个元素。
- 双指针法：初始化两个指针 k 和 l 分别指向 j + 1 和 nums.length - 1，用于在剩余的数组部分寻找和为 target 的两个元素。
- 和的比较：计算当前 i、j、k、l 指向的元素的和，与 target 进行比较： 如果和等于 target，则将这四个元素作为一个四元组添加到结果数组中，并跳过 k 和 l 指针处的重复元素。 如果和小于 target，则将 k 指针向右移动，增加和的值。 如果和大于 target，则将 l 指针向左移动，减少和的值。
- 返回结果：循环结束后，返回包含所有满足条件的四元组的数组 results。
这个算法的思路是通过排序和双指针法来减少搜索空间，提高查找效率。排序可以保证我们按照顺序查找，双指针法则可以避免在已经排序的数组中进行不必要的重复搜索。
代码中的关键点：
- 使用排序来简化问题，使得可以使用双指针法。
- 通过跳过重复元素来避免产生重复的四元组。
- 使用双指针法在已排序的数组中高效地寻找满足条件的两个元素。
/**
* @param {number[]} nums
* @param {number} target
* @return {number[][]}
*/
const fourSum = (nums, target) => {
function fourSum(nums, target) {
nums.sort((a, b) => a - b);
let results = [];
for (let i = 0; i < nums.length - 3; i++) {
if (i > 0 && nums[i] === nums[i - 1]) {
continue; // 跳过重复的元素
}
for (let j = i + 1; j < nums.length - 2; j++) {
if (j > i + 1 && nums[j] === nums[j - 1]) {
continue; // 跳过重复的元素
}
let k = j + 1;
let l = nums.length - 1;
while (k < l) {
let sum = nums[i] + nums[j] + nums[k] + nums[l];
if (sum === target) {
results.push([nums[i], nums[j], nums[k], nums[l]]);
while (k < l && nums[k] === nums[k + 1]) {
k++; // 跳过重复的元素
}
while (k < l && nums[l] === nums[l - 1]) {
l--; // 跳过重复的元素
}
} else if (sum < target) {
k++;
} else {
l--;
}
}
}
}
return results;
}