算法刷题总结（三）双指针

算法解释

双指针：用两个指针来同时遍历，协同完成任务。

常见题型

• 两个指针分别指向两个数组：归并两个有序数组
• 两个指针指向同一个数组：
  • 同方向：快慢指针、滑动窗口
  • 反方向：对有序数组进行搜索

题目

leetcode 167. 两数之和 II - 输入有序数组

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        // 双指针、指向同一有序数组的反方向
        int slow = 0, high = numbers.size() - 1;
        while(slow < high)
        {
            if(numbers[slow] + numbers[high] == target) break; //跳出，最后再return
            else if(numbers[slow] + numbers[high] > target) --high;
            else if(numbers[slow] + numbers[high] < target) ++slow;
        }
        return vector<int> {slow + 1, high + 1}; //注意写法
    }
};

leetcode 88. 合并两个有序数组

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        // 双指针，分别指向两个有序数组
        // 要求不用额外的空间，而是加到nums1的末尾。为了避免数据交换和挪动，我们从后往前来排。
        int i = m - 1, j = n - 1, cur = m + n - 1;
        while(i >= 0 && j >= 0)
        {
            if(nums1[i] >= nums2[j])
            {
                nums1[cur] = nums1[i];
                --cur;
                --i;
            }
            else
            {
                nums1[cur] = nums2[j];
                --cur;
                --j;
            }
        }
        // 如果有还没处理完的i或j，就一起加过来（i的已经在nums1里了，就只处理还剩下j的就行了）
        while(j >= 0)
        {
            nums1[cur] = nums2[j];
            --cur;
            --j;
        }
    }
};

leetcode 141. 判断链表中是否有环

快慢指针的相遇：快指针每次走两步，慢指针每次走一步。如果存在环，快指针会先进入环里，慢指针后来进入环里，形成一个追及问题，因为二者的速度差是1，快指针最后一定会追上慢指针；如果没有环，快指针会走到nullptr。

class Solution {
public:
    bool hasCycle(ListNode *head) {
        // 双指针，快慢指针 Time O(n), Space O(1)
        // AlgoCasts讲解：https://algocasts.io/episodes/q2m52Gzn
        ListNode *fast = head, *slow = head;
        while(fast && fast->next)
        {
            fast = fast->next->next;
            slow = slow->next;
            if(fast == slow) return true;
        }
        return false;
    }
};

leetcode 142. 判断链表中是否有环，如果有环返回环的开始节点

快慢指针的两次相遇：
（1）先判断有没有环。快指针从头结点开始每次走2步，慢指针从头结点开始每次走1步。如果存在环，快指针会先进入环里，慢指针后来进入环里，形成一个追及问题，因为二者的速度差是1，快指针最后一定会追上慢指针；如果没有环，快指针会走到nullptr。
（2）如果有环，找到环的起始点。快指针从头结点开始每次走1步，慢指针从第一次相遇点开始每次走1步。最终快慢指针相遇的点就是环的开始节点。因为它距离头结点是kb+d，距离快慢指针第一次相遇点的距离是d。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        // 双指针，快慢指针
        // 先通过快慢指针的第一次相遇判断单链表是否有环，再通过快慢指针的第二次相遇点找到环的第一个结点
        // AlgoCasts讲解：https://algocasts.io/episodes/nwp85DW7

        // 判断是否有环
        ListNode *slow = head, *fast = head;
        bool hasCycleFlag = false;
        while(fast && fast->next)
        {
            fast = fast->next->next;
            slow = slow->next;
            if(fast == slow)
            {
                hasCycleFlag = true;
                break; //很重要！！！不然fast和slow继续在while里往后走
            }
        }
        // 有环，找到环的第一个结点
        if(hasCycleFlag)
        {
            fast = head;
            while(fast != slow)
            {
                fast = fast->next;
                slow = slow->next;
            }
            return slow;
        }
        // 没环，返回nullptr
        return nullptr;
    }
};

leetcode 76. 最小覆盖子串

class Solution {
public:
    string minWindow(string s, string t) {
        // 双指针，滑动窗口
        // 讲解视频：https://algocasts.io/episodes/6emEOnpV
        // 思路：用l和r分别标记滑动窗口的左侧和右侧，先滑动右侧直至窗口中包含t的所有字符（也即count减到0）；再滑动左侧不断缩小并记录下满足条件的最小窗口大小，直至不满足条件（count又不为0了)，再去滑动右侧重复整个过程。
        // Time O(n), Space O(m)，n是字符串长度，m是字符集大小
        if(s.empty()) return "";
        int l = 0, r = 0, min_l = 0, min_size = INT_MAX, count = t.length();
         // hash存放的是t中各字符的个数 减 s的滑动窗口中各字符的个数；如果是t中需要的字符，hash里对应的值为正，如果非t中需要的字符，hash里对应的值为负或0。
        vector<int> hash(128, 0); // ASCII码有128个字符，其数值从0～127，可以直接作为下标。扩展ASCII码有256个字符。
        for(int i = 0; i < t.length(); ++i)
        {
            ++hash[t[i]];
        }

        // 用滑动窗口找最小窗口
        while(r < s.length())
        {
            if(count != 0)
            {
                if(hash[s[r]] > 0) --count; //查看是不是需要的元素
                --hash[s[r]]; //不能在这里改动了r，要在最后改动
            }
            while(count == 0) //用while
            {
                if(r - l + 1 < min_size)
                {
                    min_size = r - l + 1;
                    min_l = l;
                }
                ++hash[s[l]];
                if(hash[s[l]] > 0) ++count;
                ++l;
            }
            ++r;
        }
        return min_size == INT_MAX ? "" : s.substr(min_l, min_size);//如果min_size未改变的话
    }
};