一：双指针

1、同向快慢指针

适合原地调换一个数组的元素们的位置，使用for循环，声明两个下标，同向移动，一个移的快，一个移的慢。

快的指针用来往前走，慢的用来停在目标数据上。典型的案例：283. 移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

输入: nums = [0,1,0,3,12]

输出: [1,3,12,0,0]

var moveZeroes = function(nums) {

let slowIndex = 0;

for (let fastIndex = 0; fastIndex < nums.length; fastIndex++) {

if (nums[fastIndex] !== 0) {

[nums[slowIndex], nums[fastIndex]] = [nums[fastIndex], nums[slowIndex]];

slowIndex++; // 如果遇到0，慢指针不再往前走

}

}

};

2、相反方向的指针

同一个数据，开发一个指针，结尾一个指针。一个往左一个往右，向中间靠拢。适合解决回文串类问题。实例：125. 验证回文串

var isPalindrome = function(s) {

let newS = s.toLowerCase();

newS = newS.replace(/[^a-z0-9]/g,"");

// 核心思想开始

let left = 0,right = newS.length-1;

while(left < right){

if(newS[left] !== newS[right]){

return false;

}

left++;

right--;

}

return true;

};

3、一个数据对应一个指针

双指针适用于获取两个数组中的相同元素，使用while语句。

首先需要把两个数组排序，比较两个指针的值。如果相同将值推进结果数据，并将两个指针都挪动一位；如果不同，将值小的指针挪动一位；

将值小的数组指针挪动一位，是因为两个数组都是从小到大的排序的。值小的数组往前走，才有可能和值大的数组的项趋近或相同。

一直到某个数组遍历结束即可，典型实例1：349. 两个数组的交集

题目：

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]

输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]

输出：[9,4]

解释：[4,9] 也是可通过的

var intersection = function(nums1, nums2) {

// 先滤重

nums1.sort((a, b) => a - b);

nums2.sort((a, b) => a - b);

const result = new Set();

let first = 0, second = 0;

while (first < nums1.length && second < nums2.length) {

if(nums1[first] === nums2[second]){

result.add(nums1[first]);

first++;

second++;

}else if(nums1[first] > nums2[second]){

second++;

}else{

first++;

}

}

return [...result];

};

案例2: 392. 判断子序列 

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

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

示例 1：

输入：s = "abc", t = "ahbgdc"

输出：true

示例 2：

输入：s = "axc", t = "ahbgdc"

输出：false

// 整体思路是把父串整个匹配一遍。刚开始两个指针都从0开始，当两个字符相同时，指针都加一。如果不同父串加一，如果子串被全部包含，那么最终子串的下标要等于子串长度才行

var isSubsequence = function(s, t) {

let sIndex = 0;

let tIndex = 0;

let sLength = s.length;

let tLength = t.length;

while(tIndex < tLength && sIndex < sLength){

if(s.charAt(sIndex) === t.charAt(tIndex)){

sIndex++;

}

tIndex++;

}

if(sIndex == sLength){

return true;

}else{

return false;

}

};

二：快慢指针跟双指针的区别与相同点？

1、区别

使用场景不同。快慢指针使用于一个数组，双指针适用于两个数组。适用的遍历方法不同。快慢指针适合for循环，双指针适合while循环。

2、相同点

都属于对数组的操作算法都是操作两个下标 

三：双向映射

我们常用哈希表实现映射关系，有时双向映射技巧解决问题效率很高。

双向映射常使用两个Map，分别存放两组数据相反的映射关系。然后便利数据，查看相反两个映射关系是否都符合。

比如力扣：290. 单词规律

给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。

这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。

示例1:

输入: pattern = "abba", s = "dog cat cat dog"

输出: true

示例 2:

输入:pattern = "abba", s = "dog cat cat fish"

输出: false

示例 3:

输入: pattern = "aaaa", s = "dog cat cat dog"

输出: false

var wordPattern = function(pattern, s) {

sArr = s.split(" ");

let p2s = new Map(); // pattern对s的映射

let s2p = new Map(); // s对pattern的映射

if(pattern.length !== sArr.length){

return false;

}

for (let i = 0; i < pattern.length; i++) {

let p = p2s.has(pattern[i]) && p2s.get(pattern[i]) !== sArr[i];

let s = s2p.has(sArr[i]) && s2p.get(sArr[i]) !== pattern[i];

if(p || s){

return false;

}

p2s.set(pattern[i],sArr[i]); // 分别存放相反的映射关系

s2p.set(sArr[i],pattern[i]); // 分别存放相反的映射关系

}

return true;

};

四：回溯算法

例如，在一个集合S中，找到所有和为target的子集的问题，我们可以通过回溯算法来求解。我们可以定义一个空集合subset来存储每一个满足条件的子集，并从集合的第一个元素开始遍历。在遍历的过程中，我们递归地从当前位置开始寻找满足条件的子集，如果找到了一个满足条件的子集，就加入到subset集合中，并回溯到上一个状态，继续查找满足条件的解，如果遍历整个集合，仍然没有找到满足条件的子集，则不断回溯，直到找到满足的子集或者遍历整个集合。这样就可以找到所有满足的子集了。

五：算法技巧

1、判断数组中连续3个值满足条件？

我想到的是用一个数组装满足条件的值的下标，当数组长度大于2时，判断当前值是不是等于上一个值加一，上上那个值加2。

还是力扣官解厉害，他们用一个变量0计算。每次符合条件就加一，但是下一个循环不符合条件就赋0.当变量等于3时，就是有连续的3个值满足条件。实例如下

551. 学生出勤记录 I

var checkRecord = function(s) {

let absents = 0, lates = 0;

const n = s.length;

for (let i = 0; i < n; i++) {

const c = s[i];

if (c === 'A') {

absents++;

if (absents >= 2) {

return false;

}

}

// 奇迹从这里开始

if (c === 'L') {

lates++;

if (lates >= 3) {

return false;

}

} else {

lates = 0;

}

}

return true;

};

2、层级关系用栈

当涉及多层时，需要层层深入，从最里层开始算。这时可以使用数组，一层一层的push，然后从数组最后一个执行，一个个pop。模拟往外一层一层处理。

394. 字符串解码​​​​​​

3、获取某个字母的下标？

比如a是24个字母的第一个，下标0。b的下标是1，c的下标是2。如果动态获取呢？

"c".charCodeAt() - "a".charCodeAt();

即通过某个字母的编码减去a的编码，差值就是该字母在24位字母中的下标。 

六：矩阵类题目

1、生成指定矩阵

生成指定n行、m列的矩阵。需要两层循环，第一层生成n个数组，第二层给生成的数组插入m个值即可。

PS：实践

理论需要配合实践才能真正掌握，

哥们全栈写了一套个人博客 ，代码开源，欢迎大家来玩