共计 6913 个字符，预计需要花费 18 分钟才能阅读完成。
双指针
- 一般指针：两指针同一方向或不同方向
- 对撞指针：两指针相互聚拢
-
快慢指针：一快一慢
141. 环形链表 (easy)
给你一个链表的头节点 head，判断链表中是否有环。
如果链表中有某个节点，能够通过间断跟踪 next 指针再次达到，则链表中存在环。为了示意给定链表中的环，评测零碎外部应用整数 pos 来示意链表尾连贯到链表中的地位（索引从 0 开始）。留神：pos 不作为参数进行传递。仅仅是为了标识链表的理论状况。
如果链表中存在环，则返回 true。否则，返回 false。
示例 1：
输出：head = [3,2,0,-4], pos = 1
输入：true
解释：链表中有一个环，其尾部连贯到第二个节点。
示例 2：输出：head = [1,2], pos = 0
输入：true
解释：链表中有一个环，其尾部连贯到第一个节点。
示例 3：输出：head = [1], pos = -1
输入：false
解释：链表中没有环。提醒：
链表中节点的数目范畴是 [0, 104]
-105 <= Node.val <= 105
pos 为 -1 或者链表中的一个 无效索引。进阶：你能用 O(1)（即，常量）内存解决此问题吗？
办法 1. 哈希表或 set:
动画过大，点击查看
- 思路：筹备一个 map 或者 set，而后循环链表，每次遍历到一个节点的时候，判断以后节点是否在 map 中存在，如果不存在就把以后节点退出 map 中，如果存在的话阐明之前拜访过此节点，也就阐明了这条链表有环。
- 复杂度剖析：工夫复杂度
O(n)，n 是链表的数量，最差的状况下每个节点都要遍历。空间复杂度O(n)，n 是存储遍历过的节点的 map 或者 set
js:
var hasCycle = (head) => {let map = new Map();
while (head) {if (map.has(head)) return true;// 如果以后节点在 map 中存在就阐明有环
map.set(head, true);// 否则就退出 map
head = head.next;// 迭代节点
}
return false;// 循环实现发现没有反复节点，阐明没环
};办法 2. 快慢指针
动画过大，点击查看
- 思路：筹备两个指针 fast 和 slow，循环链表，slow 指针初始也指向 head，每次循环向前走一步，fast 指针初始指向 head，每次循环向前两步，如果没有环，则快指针会到达起点，如果有环，那么快指针会追上慢指针
- 复杂度：工夫复杂度
O(n)，空间复杂度O(1)
js:
var hasCycle = function (head) {
// 设置快慢指针
let slow = head;
let fast = head;
// 如果没有环，则快指针会到达起点，否则继续移动双指针
while (fast && fast.next) {
slow = slow.next;
fast = fast.next.next;
// 快慢指针相遇，阐明含有环
if (slow == fast) {return true;}
}
return false;
};142. 环形链表 II (medium)
给定一个链表的头节点 head，返回链表开始入环的第一个节点。如果链表无环，则返回 null。
如果链表中有某个节点，能够通过间断跟踪 next 指针再次达到，则链表中存在环。为了示意给定链表中的环，评测零碎外部应用整数 pos 来示意链表尾连贯到链表中的地位（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。留神：pos 不作为参数进行传递，仅仅是为了标识链表的理论状况。
不容许批改 链表。
示例 1：
输出：head = [3,2,0,-4], pos = 1
输入：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连贯到第二个节点。
示例 2：输出：head = [1,2], pos = 0
输入：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连贯到第一个节点。
示例 3：输出：head = [1], pos = -1
输入：返回 null
解释：链表中没有环。提醒：
链表中节点的数目范畴在范畴 [0, 104] 内
-105 <= Node.val <= 105
pos 的值为 -1 或者链表中的一个无效索引进阶：你是否能够应用 O(1) 空间解决此题？
办法 1. 哈希表
- 思路：遍历链表，将节点退出一个 set 中，每次判断以后节点是否在 set 中，如果存在反复的节点，这个节点就是入环节点
- 复杂度：工夫复杂度
O(n)，空间复杂度O(n)
js：
var detectCycle = function(head) {const visited = new Set();
while (head !== null) {// 终止条件，如果没有环 跳出循环
if (visited.has(head)) {// 如果存在反复的节点，这个节点就是入环节点
return head;
}
visited.add(head);// 将节点退出 set 中
head = head.next;
}
return null;
};办法 2. 快慢指针
动画过大，点击查看
- 思路：慢指针挪动两步，快指针挪动一步，相遇之后，快指针变成头指针，而后每次快慢指针各走一步直到相遇，相遇的节点就是入环节点
- 复杂度：工夫复杂度
O(n)，空间复杂度O(1)
js：
var detectCycle = function(head) {if (head === null) {return null;}
let slow = head, fast = head;
while (fast !== null) {
slow = slow.next;// 慢指针挪动两步，快指针挪动一步
if (fast.next !== null) {fast = fast.next.next;} else {return null;// 如果没有环 之间返回 null}
if (fast === slow) {// 有环
let fast = head;
// 快指针指向头节点，而后每次快慢指针各走一步直到相遇，相遇的节点就是入环节点
while (fast !== slow) {
fast = fast.next;
slow = slow.next;
}
return fast;
}
}
return null;
};15. 三数之和 (medium)
给你一个整数数组 nums，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k，同时还满足 nums[i] + nums[j] + nums[k] == 0。请
你返回所有和为 0 且不反复的三元组。
留神：答案中不能够蕴含反复的三元组。
示例 1：
输出：nums = [-1,0,1,2,-1,-4]
输入：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0。
不同的三元组是 [-1,0,1] 和 [-1,-1,2]。
留神，输入的程序和三元组的程序并不重要。
示例 2：输出：nums = [0,1,1]
输入：[]
解释：惟一可能的三元组和不为 0。
示例 3：输出：nums = [0,0,0]
输入：[[0,0,0]]
解释：惟一可能的三元组和为 0。提醒：
3 <= nums.length <= 3000
-105 <= nums[i] <= 105
办法 1. 暴力求解，对于三个数字，循环 3 次，别离计算和，工夫复杂度O(n^3)
办法 2.c=-(a+b): 确定了 a 和 b，那就能够想两数之和一样，在 map 中寻找-(a+b)，缩小一层循环，工夫复杂度O(n^2)，空间复杂度O(n)。
办法 3. 排序而后查找
动画过大，点击查看
- 思路：先排序数组，数组长度必须大于 3，循环数组，如果以后循环到了 i 索引，则定义两个指针
L = i+1，和R = nums.length-1, 如果和sum=nums[i] + nums[L] + nums[R]小于 0，则向右挪动左指针，如果 sum 大于 0，则左移右指针，如果 sum 等于 0，则正好找到了这 3 个数，而后在尝试L++,R--，持续寻找两头是否有三个数之和等于 0，留神在循环的过程中遇见雷同的三个数须要去重。 - 复杂度剖析：工夫复杂度
O(n^2)，n 为数组的长度。空间复杂度O(logn)，即排序所须要的空间
js:
var threeSum = function(nums) {let ans = [];
const len = nums.length;
if(nums == null || len < 3) return ans;// 数组的长度大于 3
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){// 尽管外面还有两个循环，然而整体的 L 和 R 挪动的工夫内复杂度还是 o(n)
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;
};160. 相交链表（easy）
给你两个单链表的头节点 headA 和 headB，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null。
图示两个链表在节点 c1 开始相交：
题目数据 保障 整个链式构造中不存在环。
留神，函数返回后果后，链表必须 放弃其原始构造。
自定义评测：
评测零碎 的输出如下（你设计的程序 不实用 此输出）：
intersectVal – 相交的起始节点的值。如果不存在相交节点，这一值为 0
listA – 第一个链表
listB – 第二个链表
skipA – 在 listA 中（从头节点开始）跳到穿插节点的节点数
skipB – 在 listB 中（从头节点开始）跳到穿插节点的节点数
评测零碎将依据这些输出创立链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序可能正确返回相交节点，那么你的解决方案将被 视作正确答案。示例 1：
输出：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输入：Intersected at ‘8’
解释：相交节点的值为 8（留神，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请留神相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的地位，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向雷同的地位。示例 2：
输出：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输入：Intersected at ‘2’
解释：相交节点的值为 2（留神，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
示例 3：输出：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输入：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
因为这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 能够是任意值。
这两个链表不相交，因而返回 null。提醒：
listA 中节点数目为 m
listB 中节点数目为 n
1 <= m, n <= 3 * 104
1 <= Node.val <= 105
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]进阶：你是否设计一个工夫复杂度 O(m + n)、仅用 O(1) 内存的解决方案？
办法 1: 哈希表
- 思路：将链表 A 存入 set 中，第一个雷同的节点就是重合的节点
- 复杂度：工夫复杂度
O(m+n)，m、n 别离是两个链表的长度。空间复杂度O(m)
js：
var getIntersectionNode = function(headA, headB) {const visited = new Set();
let temp = headA;
while (temp !== null) {// 将链表 A 存入 set 中
visited.add(temp);
temp = temp.next;
}
temp = headB;
while (temp !== null) {if (visited.has(temp)) {// 第一个雷同的节点就是重合的节点
return temp;
}
temp = temp.next;
}
return null;
};办法 2: 双指
动画过大，点击查看
- 思路：用双指针 pA、pB 循环俩个链表，链表 A 循环完结就循环链表 B，链表 A 循环完结就循环链表 B，当
pA == pB时就是交点，因为两个指针挪动的步数一样 - 复杂度：工夫复杂度
O(m+n)，m、n 别离是两个链表的长度。空间复杂度O(1)
js：
var getIntersectionNode = function(headA, headB) {if (headA === null || headB === null) {return null;}
let pA = headA, pB = headB;
while (pA !== pB) {
pA = pA === null ? headB : pA.next;// 链表 A 循环完结就循环链表 B
pB = pB === null ? headA : pB.next;// 链表 A 循环完结就循环链表 B
}
return pA;// 当 pA == pB 时就是交点
};11. 盛最多水的容器（medium）
给定一个长度为 n 的整数数组 height。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i])。
找出其中的两条线，使得它们与 x 轴独特形成的容器能够包容最多的水。
返回容器能够贮存的最大水量。
阐明：你不能歪斜容器。
示例 1：
输出：[1,8,6,2,5,4,8,3,7]
输入：49
解释：图中垂直线代表输出数组 [1,8,6,2,5,4,8,3,7]。在此状况下，容器可能包容水（示意为蓝色局部）的最大值为 49。
示例 2：输出：height = [1,1]
输入：1提醒：
n == height.length
2 <= n <= 105
0 <= height[i] <= 104
办法 1: 双指针
动画过大，点击查看
- 思路：用双指针 i，j 循环 height 数，i，j 对应高度较小的那个先向内挪动，一直计算面积，更新最大面积
- 复杂度：工夫复杂度
O(n)，n 是数组 height 的长度，遍历一次。空间复杂度O(1)
js：
var maxArea = function(height) {
let max = 0;
for (let i = 0, j = height.length - 1; i < j;) {// 双指针 i，j 循环 height 数组
//i，j 较小的那个先向内挪动 如果高的指针先挪动，那必定不如以后的面积大
const minHeight = height[i] < height[j] ? height[i++] : height[j--];
const area = (j - i + 1) * minHeight;// 计算面积
max = Math.max(max, area);// 更新最大面积
}
return max;
};876. 链表的两头结点（easy)
给定一个头结点为 head 的非空单链表，返回链表的两头结点。
如果有两个两头结点，则返回第二个两头结点。
示例 1：
输出：[1,2,3,4,5]
输入：此列表中的结点 3 (序列化模式：[3,4,5])
返回的结点值为 3。(测评系统对该结点序列化表述是 [3,4,5])。
留神，咱们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.
示例 2：输出：[1,2,3,4,5,6]
输入：此列表中的结点 4 (序列化模式：[4,5,6])
因为该列表有两个两头结点，值别离为 3 和 4，咱们返回第二个结点。提醒：
给定链表的结点数介于 1 和 100 之间。
- 思路：快慢指针遍历，直到快指针达到最初
- 复杂度：工夫复杂度
O(n)，空间复杂度O(1)
js：
var middleNode = function(head) {
slow = fast = head;
while (fast && fast.next) {// 快慢指针遍历，直到快指针达到最初
slow = slow.next;
fast = fast.next.next;
}
return slow;
};视频解说：传送门
