双指针
- 一般指针：两指针同一方向或不同方向
- 对撞指针：两指针相互聚拢
-
快慢指针：一快一慢
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;
};视频解说：传送门
发表回复