面试专题训练之“双指针”

一、需要思考的问题包括以下几点：

双指针是什么，什么时候需要用到双指针

通用的模板是什么

实现过程中需要注意的细节有哪些

常见的双指针题型有哪些

 

 

二、模板整理

 

 

三、专题训练

1.Leetcode283

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n = nums.size();
        int j = 0;
        for (int i = 0; i < n; i++) {
            if (nums[i] != 0) nums[j++] = nums[i];
        }
        while (j < n) {
            nums[j++] = 0;
        }
    }
};

题意：给定一个数组，把 0 移动到末尾的位置，剩下非 0 的数的相对位置保持不变。

题解：相当于有两个指针，都是从头开始。一个指向为 0 的值，一个指向非 0 的值。然后进行交换。

 

2.Leetcode1248

class Solution {
public:
    int numberOfSubarrays(vector<int>& nums, int k) {
        vector<int> ind;
        int n = nums.size(), ans = 0;
        ind.push_back(-1);
        for (int i = 0; i < n; i++) {
            if (nums[i] % 2 == 1) ind.push_back(i);
        }
        ind.push_back(n);
        int m = ind.size();
        for (int i = 1; i+k-1 < m-1; i++) {
            int l = ind[i];
            int r = ind[i+k-1];
            int leftGap = l - ind[i-1];
            int rightGap = ind[i+k] - r;
            ans += leftGap * rightGap;
        }
        return ans;
    }
};

class Solution {
public:
    int numberOfSubarrays(vector<int>& nums, int k) {
        return atMost(nums, k) - atMost(nums, k-1);
    }
    
    int atMost(vector<int>& nums, int k) {
        int ans = 0, l = 0, n = nums.size();
        for (int r = 0; r < n; r++) {
            k -= (nums[r] & 1);
            while (k < 0) {
                k += (nums[l++] & 1);
            }
            ans += (r - l + 1);
        }
        return ans;
    }
};

题意：给定一个长度为 n 的数组，求有多少个子数组满足其中包含 k 个奇数。

题解：

1：将所有奇数的下标保存起来，目的在于能够快速找到恰好包含 k 个奇数的子数组（/窗口），然后将该窗口向左右延申，但是不能破坏之前所满足的条件，在延申的过程中的窗口都是答案。

2：添加函数 atMost 表示对于给定的数组，最多包含 k 个奇数的子数组有多少。这样原问题的答案就变成了 atMost(k) - atMost(k-1)。在统计子数组个数时，设置两个指针，右指针一直往右延申，每次延申一格，然后看当前的子数组 [l, r] 是否满足条件，如果不满足条件，则右移左指针直至符合条件，然后更新答案。

 

3.Leetcode350

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int, int> mp;
        for (int num : nums1) mp[num]++;
        vector<int> ans;
        int n = nums2.size();
        for (int i = 0; i < n; i++) {
            int num = nums2[i];
            if (mp[num] > 0) {
                ans.push_back(num);
                mp[num]--;
            }
        }
        return ans;
    }
};

题意：给定两个数组，求两个数组的交集

题解：

方法1：用 unordered_map 存一个数组的数据，然后遍历另外一个数组去判断 map 中是否存在那个数。

方法2：先对两个数组进行排序，然后对于每个数组设置指针指向头部，比较并后移。

 

4.Leetcode16

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        int n = nums.size();
        int ans = nums[0] + nums[1] + nums[2];
        for (int i = 0; i < n-2; i++) {
            int j = i+1, k = n-1;
            while (j < k) {
                int sum = nums[i] + nums[j] + nums[k];
                if (abs(target-sum) < abs(target-ans)) ans = sum;
                if (sum < target) j++;
                else if (sum == target) return sum;
                else k--;
            }
        }
        return ans;
    }
};

题意：给定一个数组 nums，从中取出三个数，使得取出的三个数的和最接近给定的 target 值，问该值是多少。

题解：“三指针”，用 for i = [0 ~ n-2] 先确定第一个指针的位置，然后剩下两个指针，分别设定为 l = i+1, r = n-1。在根据其nums[i]+nums[l]+nums[r] 的结果更新答案。

 

5.Leetcode75

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int n = nums.size();
        int one, two, three;
        one = two = three = 0;
        for (int i = 0; i < n; i++) {
            if (nums[i] == 0) {
                nums[three++] = 2;
                nums[two++] = 1;
                nums[one++] = 0;
            } else if (nums[i] == 1) {
                nums[three++] = 2;
                nums[two++] = 1;
            } else {
                nums[three++] = 2;
            }
        }
    }
};

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int n = nums.size();
        int i, j, k;
        i = j = 0, k = n - 1;
        while (j <= k) {
            if (nums[j] == 0) swap(nums[i++], nums[j++]);
            else if (nums[j] == 1) j++;
            else swap(nums[j], nums[k--]);
        }
    }
};

题意：给定一个只包含数字 1 2 3 的数组 nums，只遍历一遍实现原地更新。

题解：

1.记值为 0 的数字个数为 a，值为 1 的数字个数为 b，值为 2 的数字个数为 c. 这样可以保证 [0, a) 的位置的值全为 0，[a, a+b) 的位置的值全为 1，[a+b, a+b+c) 的位置的值全为 2。我们用变量 one 代表值 <= 0 的数的个数（/位置），用变量 two 代表值 <= 1 的数的个数，用变量 three 代表值 <= 2 的数的个数。这样每次访问到 nums[i] == 0 时，那么我们需要按照 three -> two -> one 的顺序依次更新各个值。 每次访问到 nums[i] == 1 时，那么我们需要按照 three -> two 的顺序依次更新各个值。 每次访问到 nums[i] == 2 时，那么我们需要按照 three  的顺序依次更新各个值。 这样可以保证先前暂时被写到前面位置的大值被覆盖。

2.“三指针”，用 i 代表值为 0 的数的位置，j 代表值为 1 的数的位置，k 代表值为 2 的数的位置。初始时 i = j = 0, k = n-1. 在整个过程中移动 j 的值，遇到 0，就交换 nums[i++] 和 nums[j++] 确保值 0 一定可以放到前面。遇到 1，则 j++。遇到 2，就交换 nums[j] 和 nums[k--]，确保值 2 一定放在最后。即 0 是从开头往后增长，2 是从最后往前增长，而 1 是根据 0 和 2 的位置调整变动的。

 

7.Leetcode19

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if (n == 0) return head->next;
        ListNode* fast = head;
        ListNode* slow = head;
        for (int i = 0; i < n; i++) fast = fast->next;
        if (fast == NULL) return slow->next;
        while (fast->next != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;
        return head;
    }
};

题意：给定一个链表，去掉倒数第 k 个数。

题解：这里只给出了 one pass 的解法。因为要将倒数第 k 个数删掉，这里我们采用“快慢指针” 的做法，让快指针先走 k 个数。这样就能保证当快指针走到末尾时，满指针所在的位置就是要去掉的位置。

 

8.Leetcode424

class Solution {
public:
    bool check(string &s, int k, int num) {
        int mp[26];
        memset(mp, 0, sizeof(mp));
        int cnt = 0;
        int n = s.size();
        for (int i = 0; i < n; i++) {
            mp[s[i]-'A']++;
            if (i >= num) mp[s[i-num]-'A']--;
            for (int j = 0; j < 26; j++) {
                cnt = max(cnt, mp[j]);
            }
            if (i >= num-1 && cnt+k >= num) return true;
        }
        return false;
    }

    int characterReplacement(string s, int k) {
        int n = s.size();
        if (n <= k) return n;
        int l = k, r = n+1;
        while (l < r) {
            int mid = l + (r-l)/2;
            if (mid == l) {
                if (check(s, k, mid+1))  l = mid+1;
                break;
            }
            if (check(s, k, mid)) l = mid;
            else r = mid-1;
        }
        return l;
    }
};

class Solution {
public:
    int characterReplacement(string s, int k) {
        int n = s.size();
        if (n <= k) return n;
        int i = 0, ans = 0, maxx = 0;
        unordered_map<int, int> mp;
        for (int j = 0; j < n; j++) {
            maxx = max(maxx, ++mp[s[j]]);
            if (j-i+1 <= maxx+k) ans = j-i+1;
            else mp[s[i++]]--;
        }
        return ans;
    }
};

题意：给定一个字符串 s，和一个整数 k，k 表示可以对字符串任意位置进行最多 k 次的改变。求经过改变后能够得到的最长子串，其中子串中所有字符一样。

题解：

1.二分答案，然后用固定长度的窗口去判断二分的结果是否满足条件。

2.只需要遍历一遍，移动右指针，当不满足条件时移动左指针，注意窗口只能增大不减小，所有左指针每次最多只能向右边移动一格。

 

9.Leetcode632

class Solution {
public:
    struct cmp
    {
        bool operator()(pair<int, int> a, pair<int, int> b)
        {
            if (a.first == b.first) return a.second > b.second;
            return a.first > b.first;
        }
    };
    
    vector<int> smallestRange(vector<vector<int>>& nums) {
        int n = nums.size();
        vector<int> cnt(n);
        vector<int> ind(n);
        priority_queue<pair<int, int>, vector<pair<int, int>>, cmp> pq;
        while (!pq.empty()) pq.pop();
        int l = INT_MAX, r = INT_MIN;
        for (int i = 0; i < n; i++) {
            int m = nums[i].size();
            cnt[i] = m-1;
            ind[i] = 0;
            pq.push(make_pair(nums[i][0], i));
            l = min(l, nums[i][0]);
            r = max(r, nums[i][0]);
        }
        int ans = r - l;
        vector<int> res{l, r};
        while (true) {
            pair<int, int> p = pq.top();
            pq.pop();
            int pos = p.second;
            if (ind[pos] < cnt[pos]) {
                int val = nums[pos][++ind[pos]];
                if (val > r) r = val;
                pq.push(make_pair(val, pos));
                l = pq.top().first;
                if (r-l < ans) {
                    ans = r-l;
                    res[0] = l;
                    res[1] = r;
                }
            } else {
                break;
            }
        }
        return res;
    }
};

题意：给定 k 个已经排好序的数组，求一个范围最小的区间 [a, b]，使得每个数组都有数落在区间 [a, b] 内。

题解：先从每个数组中取出最小的数，按照 (value, position) 这样的组合（其中 value 代表值，position 代表该值属于第几个数组）存入到优先队列中。每次取出 value 最小的 pair，将该 pair 所处数组中 下一个位置的值加入到该优先队列中，同时每次将当前优先队列中最大值和最小值的差值用来更新最后的答案。直到任意一个数组取完为止。

 

10.Leetcode1234

class Solution {
public:
    int change(char c) {
        if (c == 'Q') return 0;
        else if (c == 'W') return 1;
        else if (c == 'E') return 2;
        return 3;
    }
    int balancedString(string s) {
        int n = s.size(), ans = INT_MAX;
        vector<int> cnt(4, 0); 
        int target = n / 4;
        for (int i = 0; i < n; i++) {
            cnt[change(s[i])]++;
        }
        int need = 4;
        for (int i = 0; i < 4; i++) {
            cnt[i] -= target;
            if (cnt[i] <= 0) need--;
        }
        if (need == 0) return 0;
        for (int i = 0, j = 0; i <= j && j < n; j++) {
            if ((--cnt[change(s[j])]) == 0) need--;
            while (i < j) {
                if ((cnt[change(s[i])]+1) <= 0) {
                    cnt[change(s[i++])]++;
                } else {
                    break;
                }
            }
            if (need == 0) ans = min(ans, j-i+1);
        }
        return ans;
    }
};

class Solution {
public:
    int balancedString(string s) {
        int balancedString(string s) {
        unordered_map<int, int> count;
        int n = s.length(), res = n, i = 0, k = n / 4;
        for (int j = 0; j < n; ++j) {
            count[s[j]]++;
        }
        for (int j = 0; j < n; ++j) {
            count[s[j]]--;
            while (i < n && count['Q'] <= k && count['W'] <= k && count['E'] <= k && count['R'] <= k) {
                res = min(res, j - i + 1);
                count[s[i++]] += 1;
            }
        }
        return res;
    }
    }
};

题意：给定一个只包含 "Q" "W" "E" "R" 四个字符的字符串，选取其中一个子串，将子串进行相同长度的字符替换。使得最后得到的字符串每个字符的数量相同。求满足条件的最小的子串的长度。

题解：记最后每个字符的数量为 k，维护一个滑动窗口，需要保证滑动窗口之外的字符他们各自的数量 < k。因为求最小的子串长度，所有右指针每次移动一位，而左指针移动到刚好满足条件为止。

 

11.Leetcode209

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        int ans = INT_MAX;
        int sum = 0;
        for (int i = 0, j = 0; i <= j && j < n; j++) {
            sum += nums[j];
            while (sum >= s && i <= j) {
                if (sum >= s) ans = min(ans, j-i+1);
                sum -= nums[i++];
            }
        }
        return ans == INT_MAX? 0 : ans;
    }
};

题意：给定一个正整数数组和一个正整数 s，选取位置连续子数组，使得子数组中数的和 >= s，求当满足条件时，子数组最短的长度是多少。

题解：双指针。维护的窗口满足 sum >= s。因为求最小值，每次右数组移动一位，左数组移动到直到不满足条件为止。

 

12.Leetcode845

class Solution {
public:
    int longestMountain(vector<int>& A) {
        int n = A.size();
        vector<int> vi;
        vi.push_back(-1);
        for (int i = 1; i < n-1; i++) {
            if (A[i] > A[i-1] && A[i] > A[i+1])  vi.push_back(i);   
        }
        vi.push_back(n);
        int m = vi.size();
        int ans = 0;
        for (int i = 1; i < m-1; i++) {
            int l = vi[i-1], r = vi[i+1];
            int k = vi[i]-1, j = vi[i]+1;
            while (k > l) {
                if (A[k] < A[k+1]) k--;
                else break;
            }
            while (j < r) {
                if (A[j] < A[j-1]) j++;
                else break;
            }
            ans = max(ans, j-k-1);
        }
        return ans;
    }
};

class Solution {
public:
    int longestMountain(vector<int>& A) {
        int n = A.size(), ans = 0;
        vector<int> up(n, 0), down(n, 0);
        for (int i = n-2; i >= 0; i--) {
            if (A[i] > A[i+1]) down[i] = down[i+1] + 1;
        }
        for (int i = 1; i < n; i++) {
            if (A[i] > A[i-1]) up[i] = up[i-1] + 1;
            if (up[i] != 0 && down[i] != 0) ans = max(ans, up[i]+down[i]+1);
        }
        return ans;
    }
};

class Solution {
public:
    int longestMountain(vector<int>& A) {
        int n = A.size(), ans = 0, down = 0, up = 0;
        for (int i = 1; i < n; i++) {
            if ((down && A[i-1] < A[i]) || A[i-1] == A[i]) down = up = 0;
            down += A[i] < A[i-1];
            up += A[i] > A[i-1];
            if (up && down) ans = max(ans, up+down+1);
        }
        return ans;
    }
};

题意：给定一个数组，求最长的 “mountain” 长度。

题解：

1. 将所有满足 a[i] > a[i-1] && a[i] > a[i+1] 的位置 i 保存起来，从位置 i 向两侧延申。

2. 维护两个数组 up, down。从后往前扫一次，更新 down 数组，if (A[i] > A[i+1]) down[i] = donw[i+1] + 1；从前往后扫一次，更新 up 数组，if (A[i] > A[i-1]) up[i] = up[i-1] + 1。up[i] + down[i] + 1 表示以 i 为峰顶满足条件的 “mountain” 长度。

3. one way 做法。维护两个整数变量 up 和 down，和上面所表示的含义一样。在指针向右移动的过程中同时维护 down 和 up 变量，同时更新答案。当遇到新的“mountain” 时重置 up 和 down 的值。

 

13.Leetcode713

class Solution {
public:
    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
        if (k == 0) return 0;
        int n = nums.size(), i = 0, res = 0;
        long long ans = 1;
        for (int j = 0; j < n; j++) {
            ans *= nums[j];  
            if (ans >= k) {
                while (i <= j && ans >= k) ans /= nums[i++];
            }
            res += (j-i+1);
        }
        return res;
    }
};

题意：给定一个数组 nums，求有多少个连续的子数组满足子数组中所有元素的和小于给定的数 k

题解：右指针每次向右移动一格，左指针移动到恰好满足条件的位置。假设当前右指针的位置为 j, 左指针的位置为 i。则所有 [k, j] (i <= k < j) 的位置都满足条件。