LeetCode笔记:双指针
自大学开始,我便陆陆续续的学习一些 算法和数据结构 方面的内容,同时也开始在一些平台刷题,也会参加一些大大小小的算法竞赛。但是平时刷题缺少目的性、系统性,最终导致算法方面进步缓慢。最终,为了自己的未来,我决定开始在LeetCode上进行系统的学习和练习,同时将刷题的轨迹整理记录,分享出来与大家共勉。
参考资料: labuladong
目录标题
双指针技巧汇总
双指针分为两类,一类是「快慢指针」,一类是「左右指针」。前者解决主要解决链表中的问题,比如典型的判定链表中是否包含环;后者主要解决数组(或者字符串)中的问题,比如二分查找。
一、快慢指针的常见算法
快慢指针一般都初始化指向链表的头结点 head,前进时快指针 fast 在前,慢指针 slow 在后,巧妙解决一些链表中的问题。
1、判定链表中是否含有环
经典解法就是用两个指针,一个每次前进两步,一个每次前进一步。如果不含有环,跑得快的那个指针最终会遇到 null,说明链表不含环;如果含有环,快指针最终会超慢指针一圈,和慢指针相遇,说明链表含有环。
对应力扣:第141题
public class Solution {
public boolean hasCycle(ListNode head) {
ListNode fast,slow;
fast=slow=head;
while (fast!=null && fast.next!=null){
fast=fast.next.next;
slow=slow.next;
if (fast==slow){
return true;
}
}
return false;
}
}
2、已知链表中含有环,返回这个环的起始位置
class Solution {
public ListNode detectCycle(ListNode head) {
ListNode fast,slow;
fast=slow=head;
while (fast!=null && fast.next!=null){
fast=fast.next.next;
slow=slow.next;
}
slow=head;
while (slow!=fast){
fast=fast.next;
slow=slow.next;
}
return slow;
}
}
可以看到,当快慢指针相遇时,让其中任一个指针重新指向头节点,然后让它俩以相同速度前进,再次相遇时所在的节点位置就是环开始的位置。这是为什么呢?
第一次相遇时,假设慢指针 slow 走了 k 步,那么快指针 fast 一定走了 2k 步,也就是说比 slow 多走了 k 步(也就是环的长度)。
设相遇点距环的起点的距离为 m,那么环的起点距头结点 head 的距离为 k - m,也就是说如果从 head 前进 k - m 步就能到达环起点。
巧的是,如果从相遇点继续前进 k - m 步,也恰好到达环起点。
所以,只要我们把快慢指针中的任一个重新指向 head,然后两个指针同速前进,k - m 步后就会相遇,相遇之处就是环的起点了。
3、寻找链表的中点
类似上面的思路,我们还可以让快指针一次前进两步,慢指针一次前进一步,当快指针到达链表尽头时,慢指针就处于链表的中间位置。
ListNode slow, fast;
slow = fast = head;
while (fast != null && fast.next != null) {
fast = fast.next.next;
slow = slow.next;
}
// slow 就在中间位置
return slow;
当链表的长度是奇数时,slow 恰巧停在中点位置;如果长度是偶数,slow 最终的位置是中间偏右:
寻找链表中点的一个重要作用是对链表进行归并排序。
回想数组的归并排序:求中点索引递归地把数组二分,最后合并两个有序数组。对于链表,合并两个有序链表是很简单的,难点就在于二分。
但是现在你学会了找到链表的中点,就能实现链表的二分了。关于归并排序的具体内容本文就不具体展开了。
4、寻找链表的倒数第 k 个元素
我们的思路还是使用快慢指针,让快指针先走 k 步,然后快慢指针开始同速前进。这样当快指针走到链表末尾 null 时,慢指针所在的位置就是倒数第 k 个链表节点(为了简化,假设 k 不会超过链表长度):
ListNode slow, fast;
slow = fast = head;
while (k-- > 0)
fast = fast.next;
while (fast != null) {
slow = slow.next;
fast = fast.next;
}
return slow;
二、左右指针的常用算法
左右指针在数组中实际是指两个索引值,一般初始化为 left = 0, right = nums.length - 1 。
1、二分查找
int searchInsert(int[] nums, int target) {
int n = nums.length;
int left = 0;
int right = n - 1; // 定义target在左闭右闭的区间里,[left, right]
while (left <= right) { // 当left==right,区间[left, right]依然有效
int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
if (nums[middle] > target) {
right = middle - 1; // target 在左区间,所以[left, middle - 1]
} else if (nums[middle] < target) {
left = middle + 1; // target 在右区间,所以[middle + 1, right]
} else { // nums[middle] == target
return middle;
}
}
return -1;
}
2、两数之和
直接看一道 LeetCode 题目吧:
只要数组有序,就应该想到双指针技巧。这道题的解法有点类似二分查找,通过调节 left 和 right 可以调整 sum 的大小:
class Solution {
public int[] twoSum(int[] nums, int target) {
int left=0,right=nums.length-1;
while (left<right){
if (nums[left]+nums[right]==target){
return new int[]{left+1,right+1};
}else if (nums[left]+nums[right]<target){
left++;
}else {
right--;
}
}
return new int[]{-1,-1};
}
}
3、反转数组
void reverse(int[] nums) {
int left = 0;
int right = nums.length - 1;
while (left < right) {
// swap(nums[left], nums[right])
int temp = nums[left];
nums[left] = nums[right];
nums[right] = temp;
left++; right--;
}
}
4、滑动窗口算法
这也许是双指针技巧的最高境界了,如果掌握了此算法,可以解决一大类子字符串匹配的问题,不过「滑动窗口」算法比上述的这些算法稍微复杂些。
幸运的是,这类算法是有框架模板的.
C++版本
/* 滑动窗口算法框架 */
void slidingWindow(string s, string t) {
unordered_map<char, int> need, window;
for (char c : t) need[c]++;
int left = 0, right = 0;
int valid = 0;
while (right < s.size()) {
// c 是将移入窗口的字符
char c = s[right];
// 右移窗口
right++;
// 进行窗口内数据的一系列更新
...
/*** debug 输出的位置 ***/
printf("window: [%d, %d)\n", left, right);
/********************/
// 判断左侧窗口是否要收缩
while (window needs shrink) {
// d 是将移出窗口的字符
char d = s[left];
// 左移窗口
left++;
// 进行窗口内数据的一系列更新
...
}
}
}
其中两处...
表示的更新窗口数据的地方,到时候你直接往里面填就行了。
而且,这两个...
处的操作分别是右移和左移窗口更新操作,等会你会发现它们操作是完全对称的。
Java版本
class Solution2{
/* 滑动窗口算法框架 */
void slidingWindow(String s, String t) {
// 字符需要出现的次数
Map<Character, Integer> needs = new HashMap<Character, Integer>();
// 滑动窗口中字符出现的次数
Map<Character, Integer> window = new HashMap<Character, Integer>();
for (char ch : t.toCharArray())
needs.put(ch, needs.getOrDefault(ch, 0) + 1);
int left = 0, right = 0;
int valid = 0;
while (right < s.length()) {
// c 是将移入窗口的字符
char c = s.charAt(right);
// 如果满足条件就将 c移入窗口中,并进行窗口内数据的一系列更新
if (...)
...
// 右移窗口
right++;
/*** debug 输出的位置 ***/
System.out.println("window: [" + left + ", " + right + ")\n");
/********************/
// 判断左侧窗口是否要收缩
while (window needs shrink){
// d 是将移出窗口的字符
char d = s.charAt(left);
// 如果满足一定条件,进行窗口内数据的一系列更新,使得退出这个 while循环
if (...)
...
// 左移窗口
left++;
}
}
}
}
详细参数说明:
初始化window
和need
两个哈希表,记录窗口中的字符和需要凑齐的字符:
unordered_map<char, int> need, window;
for (char c : t) need[c]++;
然后,使用left
和right
变量初始化窗口的两端,不要忘了,区间[left, right)
是左闭右开的,所以初始情况下窗口没有包含任何元素:
int left = 0, right = 0;
int valid = 0;
while (right < s.size()) {
// 开始滑动
}
其中valid
变量表示窗口中满足need
条件的字符个数,如果valid
和need.size
的大小相同,则说明窗口已满足条件,已经完全覆盖了串T
。
现在开始套模板,只需要思考以下四个问题:
1、 当移动right
扩大窗口,即加入字符时,应该更新哪些数据?
2、 什么条件下,窗口应该暂停扩大,开始移动left
缩小窗口?
3、 当移动left
缩小窗口,即移出字符时,应该更新哪些数据?
4、 我们要的结果应该在扩大窗口时还是缩小窗口时进行更新?
如果一个字符进入窗口,应该增加window
计数器;如果一个字符将移出窗口的时候,应该减少window
计数器;当valid
满足need
时应该收缩窗口;应该在收缩窗口的时候更新最终结果。
作者:耿鬼不会笑
时间:2021年2月