「算法学习」：两数之和、三数之和、四数之和JS(双指针)求解

算法题目来源：力扣（LeetCode）

两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

/**
 * @param {number[]} nums 目标数组
 * @param {number} target 目标值
 * @return {number[]}
 */
const twoSum = (nums, target) => {
  const len = nums.length
  const sumCache = {}

  for (let i = 0; i < len; i++) {
    const value = nums[ i ]
    // 计算差值
    const diff = target - value
    // 如果差值已经存在过，直接返回对应的索引
    if (typeof sumCache[ diff ] !== 'undefined') {
      return [ sumCache[ diff ], i ]
    } else {
      // 否则存起来
      sumCache[ value ] = i
    }
  }
}
let nums=[2,7,11,15]
console.log(twoSum(nums,9))
//[0,1]

const twoSum = function(nums, target) {
  const map = new Map();
  //Map特性Map对象保存键值对
  for (let i = 0; i < nums.length; i++) {
  //循环数组，用target减去当前数值
   const diff = target - nums[i];
   if (map.has(diff)) {
   //如果说存在符合条件的值，则说明两者之和为target，返回两者下标
    return [map.get(diff), i];
   }else{
   	map.set(nums[i], i);
   	//否则将这个值存放进去
   }
  }
}

//思路：其实不管是使用了map与否，其实本质都是利用借助Object对象存储来实现的，首先创建一个空object，循环数组，并计算target和当前数值的差值，此时第一次循环时空object里没用目标插值，于是将其插入进去，继续循环，当遇到与目标数值一致时返回下标。注意，此时只会返回第一次符合的结果下标

三数之和

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

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function(nums) {
    let ans = [];
    const len = nums.length;
    if(nums == null || len < 3) return ans; //不足三个元素时候返回
    nums.sort((a, b) => a - b); // 排序
    for (let i = 0; i < len ; i++) {
        if(nums[i] > 0) break; // 如果当前数字大于0，则三数之和一定大于0，所以结束循环
        if(i > 0 && nums[i] == nums[i-1]) continue; // 去重，思路上是以一个元素为基准然后双指针遍历，因此当基准数重复时候去重
        let L = i+1; //左指针
        let R = len-1; //右指针
        while(L < R){
            const sum = nums[i] + nums[L] + nums[R]; //遍历计算总和
            if(sum == 0){
                ans.push([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;
};

最接近的三数之和

给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在恰好一个解

const threeSumClosest = (nums, target) => {
    // 升序排序
    nums.sort((a, b) => a - b);
    // 初始化一个最小值
    let min = Infinity;
    const len = nums.length;
    for (let i = 0; i < len; i++) {
        // 定义左右指针
        let [left, right] = [i + 1, len - 1];
        while (left < right) {
            // 当前三数之和
            const sum = nums[i] + nums[left] + nums[right];
            // 如果当前和更接近，更新最小值
            if (Math.abs(sum - target) < Math.abs(min - target)) {
                min = sum;
            }
            // 根据sum和target的关系，移动指针
            if (sum < target) {
                left++;
            } else if (sum > target) {
                right--;
            } else {
                // sum和target相等，直接返回sum，肯定是最小的了
                return sum;
            }
        }
    }
    // 遍历结束，返回最接近的和
    return min;
};

四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）

var fourSum = function(nums, target) {
	//创建一个空数组用以返回结果
    const quadruplets = [];
    //不足四个元素时候返回
    if (nums.length < 4) {
        return quadruplets;
    }
	//对数组进行排序
    nums.sort((x, y) => x - y);
    const length = nums.length;
    //第一层for循环确定第一个基准数
    for (let i = 0; i < length - 3; i++) {
    	//去重操作，当与前一个元素相同时候直接进入下一次循环
        if (i > 0 && nums[i] === nums[i - 1]) {
            continue;
        }
        //在确定第一个数之后，如果nums[i]+nums[i+1]+nums[i+2]+nums[i+3]>target，
        //说明此时剩下的三个数无论取什么值，四数之和一定大于target，因此退出第一重循环；
        if (nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) {
            break;
        }
        //在确定第一个数之后，如果nums[i]+nums[length-3]+nums[length-2]+nums[length-1]<target
        //说明无论取剩下任何四个数字都不会大于等于target因此第一重循环直接进入下一轮，枚举nums[i+1]；
        if (nums[i] + nums[length - 3] + nums[length - 2] + nums[length - 1] < target) {
            continue;
        }
        //确定第二个基准数
        for (let j = i + 1; j < length - 2; j++) {
        	//第二个数去重
            if (j > i + 1 && nums[j] === nums[j - 1]) {
                continue;
            }
             //在确定第一、二个数之后，如果nums[i]+nums[j]+nums[j+1]+nums[j+2]>target，
        	//说明此时剩下的数无论取什么值，四数之和一定大于target，因此退出第一重循环；
            if (nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) {
                break;
            }
            //在确定第一、二个数之后，如果nums[i] + nums[j] + nums[length - 2] + nums[length - 1<target，
        	//说明此时剩下数无论取什么值，四数之和一定小于target，因此退出第一重循环；
            if (nums[i] + nums[j] + nums[length - 2] + nums[length - 1] < target) {
                continue;
            }
            //左右指针赋值
            let left = j + 1, right = length - 1;
            while (left < right) {
                const sum = nums[i] + nums[j] + nums[left] + nums[right];
                if (sum === target) {
                    quadruplets.push([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;
};