双指针类型解题汇总

1  最接近的三数之和

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

示例：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

提示：

3 <= nums.length <= 10^3

-10^3 <= nums[i] <= 10^3

-10^4 <= target <= 10^4

思路：

先按照升序排序，然后分别从左往右依次选择一个基础点 i（0 <= i <= nums.length - 3），在基础点的右侧用双指针去不断的找最小的差值。

假设基础点是 i，初始化的时候，双指针分别是：

• left：i + 1，基础点右边一位。

• right: nums.length - 1 数组最后一位。

然后求此时的和，如果和大于 target，那么可以把右指针左移一位，去试试更小一点的值，反之则把左指针右移。

在这个过程中，不断更新全局的最小差值 min，和此时记录下来的和 res。

最后返回 res 即可。

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
let threeSumClosest = function (nums, target) {
    let n = nums.length
    if (n === 3) {
        return getSum(nums)
    }
    // !!!!!先升序排序 此为解题的前置条件
    nums.sort((a, b) => a - b)

    let min = Infinity // 和 target 的最小差
    let res

    // 从左往右依次尝试定一个基础指针 右边至少再保留两位 否则无法凑成3个
    // !!!!!  注意i要<=nums.length
    for (let i = 0; i <= nums.length - 3; i++) {
        let basic = nums[i]
        let left = i + 1; // 左指针先从 i 右侧的第一位开始尝试
        let right = n - 1 // 右指针先从数组最后一项开始尝试

        while (left < right) {
            let sum = basic + nums[left] + nums[right] // 三数求和
            // 更新最小差
            let diff = Math.abs(sum - target)
            if (diff < min) {
                min = diff
                res = sum
            }
            if (sum < target) {
                // 求出的和如果小于目标值的话 可以尝试把左指针右移 扩大值
                left++
            } else if (sum > target) {
                // 反之则右指针左移
                right--
            } else {
                // 相等的话 差就为0 一定是答案
                return sum
            }
        }
    }

    return res
};

function getSum(nums) {
    return nums.reduce((total, cur) => total + cur, 0)
}

2  通过删除字母匹配到字典里最长单词

给定一个字符串和一个字符串字典，找到字典里面最长的字符串，该字符串可以通过删除给定字符串的某些字符来得到。如果答案不止一个，返回长度最长且字典顺序最小的字符串。如果答案不存在，则返回空字符串。

示例 1:

输入:
s = "abpcplea", d = ["ale","apple","monkey","plea"]

输出:
"apple"
示例 2:

输入:
s = "abpcplea", d = ["a","b","c"]

输出:
"a"
说明:

所有输入的字符串只包含小写字母。
字典的大小不会超过 1000。
所有输入的字符串长度不会超过 1000。

思路：

为数组 d 中的每个单词分别生成指针，指向那个单词目前已经匹配到的字符下标。然后对 s 进行一次遍历，每轮循环中都对 d 中所有指针的下一位进行匹配，如果匹配到了，则那个单词的指针后移。

一旦某个单词指针移动到那个字母的最后一位了，就和全局的 find 变量比较，先比较长度，后比较字典序，记录下来，最后返回即可。

/**
 * @param {string} s
 * @param {string[]} d
 * @return {string}
 */
let findLongestWord = function (s, d) {
  let n = d.length
  let points = Array(n).fill(-1)

  let find = ""
  for (let i = 0; i < s.length; i++) {
    let char = s[i]
    for (let j = 0; j < n; j++) {
      let targetChar = d[j][points[j] + 1]
      if (char === targetChar) {
        points[j]++
        let word = d[j]
        let wl = d[j].length
        if (points[j] === wl - 1) {
          let fl = find.length
          if (wl > fl || (wl === fl && word < find)) {
            find = word
          }
        }
      }
    }
  }

  return find
}

3   判断子序列

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长（长度 ~= 500,000），而 s 是个短字符串（长度 <=100）。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

示例 1:
s = "abc", t = "ahbgdc"

返回 true.

示例 2:
s = "axc", t = "ahbgdc"

返回 false.

 思路：

判断字符串 s 是否是字符串 t 的子序列，我们可以建立一个 i 指针指向「当前 s 已经在 t 中成功匹配的字符下标后一位」。之后开始遍历 t 字符串，每当在 t 中发现 i 指针指向的目标字符时，就可以把 i 往后前进一位。

• 一旦i === t.length ，就代表 t 中的字符串全部按顺序在 s 中找到了，返回 true。

• 当遍历 s 结束后，就返回 false，因为 i 此时并没有成功走 t 的最后一位。

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
let isSubsequence = function (s, t) {
    let sl = s.length
    if (!sl) {
        return true
    }

    let i = 0
    for (let j = 0; j < t.length; j++) {
        let target = s[i]
        let cur = t[j]
        if (cur === target) {
            i++
            if (i === sl) {
                return true
            }
        }
    }

    return false
};

 4  分发饼干

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 i ，都有一个胃口值 gi ，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j ，都有一个尺寸 sj 。如果 sj >= gi ，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

注意：

你可以假设胃口值为正。 一个小朋友最多只能拥有一块饼干。

示例 1:

输入: [1,2,3], [1,1]

输出: 1

解释: 
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。
示例 2:

输入: [1,2], [1,2,3]

输出: 2

解释: 
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.

思路：

把饼干和孩子的需求都排序好，然后从最小的饼干分配给需求最小的孩子开始，不断的尝试新的饼干和新的孩子，这样能保证每个分给孩子的饼干都恰到好处的不浪费，又满足需求。

利用双指针不断的更新 i 孩子的需求下标和 j饼干的值，直到两者有其一达到了终点位置：

1. 如果当前的饼干不满足孩子的胃口，那么把 j++ 寻找下一个饼干，不用担心这个饼干被浪费，因为这个饼干更不可能满足下一个孩子（胃口更大）。

2. 如果满足，那么 i++; j++; count++ 记录当前的成功数量，继续寻找下一个孩子和下一个饼干。

/**
 * @param {number[]} g
 * @param {number[]} s
 * @return {number}
 */
let findContentChildren = function (g, s) {
  g.sort((a, b) => a - b)
  s.sort((a, b) => a - b)

  let i = 0
  let j = 0

  let count = 0
  while (j < s.length && i < g.length) {
    let need = g[i]
    let cookie = s[j]

    if (cookie >= need) {
      count++
      i++
      j++
    } else {
      j++
    }
  }

  return count
}

5  验证回文串

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

说明：本题中，我们将空字符串定义为有效的回文串。

示例 1:

输入: "A man, a plan, a canal: Panama"
输出: true

思路：

先根据题目给出的条件，通过正则把不匹配字符去掉，然后转小写。

建立双指针 i, j 分别指向头和尾，然后两个指针不断的向中间靠近，每前进一步就对比两端的字符串是否相等，如果不相等则直接返回 false。

如果直到 i >= j 也就是指针对撞了，都没有返回 false，那就说明符合「回文」的定义，返回 true。

/**
 * @param {string} s
 * @return {boolean}
 */
let isPalindrome = function(s) {
    s = s.replace(/[^0-9a-zA-Z]/g, '').toLowerCase()
    let i = 0
    let j = s.length - 1

    while(i < j) {
        let head = s[i]
        let tail = s[j]

        if (head !== tail) {
            return false
        }else {
            i++
            j--
        }
    }
    return true
};