多指针问题

多指针问题

---

75.颜色分类

1574.删除最短的子数组使剩余数组有序

很多时候多指针（双指针，三指针）能极大的帮助我们降低时间复杂度。

比如求链表到数第N个节点，以及判断链表中是否有环。

今天我们看LeetCode 75.颜色分类，原型是荷兰国旗问题。

---

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

注意:
不能使用代码库中的排序函数来解决这道题。

示例:

输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]

---

我们用三个指针（p0, p2 和curr）来分别追踪0的最右边界，2的最左边界和当前考虑的元素。

此题思路很直观，本解法的思路是沿着数组移动 curr 指针，若nums[curr] = 0，则将其与 nums[p0]互换；若 nums[curr] = 2 ，则与 nums[p2]互换。

但是细节很需要注意，细节往往能致人于死地。

1. 中间指针curr起始位置为0，不是1，为什么？
2. 若nums[curr]==0，则与nums[p0]互换时curr++，而nums[curr]==1，curr不需要–，为什么？

这两个问题实质是相同的，我们需要让curr在p0前面，去接近p1，相当于给你一个方向，你去前进。这样理解会不会好些。

class Solution {
public:
    void sortColors(vector<int>& nums) {
        if(!nums.size()) return;
        int begin = 0, mid =0, end = nums.size()-1;
        while(begin<=mid && mid<=end)
        {
            // mid = begin;
            if(nums[mid]==0)
            {
                swap(nums[mid],nums[begin]);
                begin++;
                mid ++;
            }
            else if(nums[mid]==2)
            {
                swap(nums[mid],nums[end]);
                end--;
            }
            else mid ++;
            
        }
    }
};

---

1574. 删除最短的子数组使剩余数组有序

给你一个整数数组 arr ，请你删除一个子数组（可以为空），使得 arr 中剩下的元素是 非递减 的。

一个子数组指的是原数组中连续的一个子序列。

请你返回满足题目要求的最短子数组的长度。

示例 1：

输入：arr = [1,2,3,10,4,2,3,5]
输出：3
解释：我们需要删除的最短子数组是 [10,4,2] ，长度为 3 。剩余元素形成非递减数组 [1,2,3,3,5] 。

另一个正确的解为删除子数组 [3,10,4] 。
示例 2：

输入：arr = [5,4,3,2,1]
输出：4
解释：由于数组是严格递减的，我们只能保留一个元素。所以我们需要删除长度为 4 的子数组，要么删除 [5,4,3,2]，要么删除 [4,3,2,1]。

示例 3：

输入：arr = [1,2,3]
输出：0
解释：数组已经是非递减的了，我们不需要删除任何元素。

示例 4：

输入：arr = [1]
输出：0

提示：

1 <= arr.length <= 10^5
0 <= arr[i] <= 10^9

---

双指针，先找出最大有序前缀pre和最大有序后缀suf, 若pre==n则表示全部有序，若pre == suf && suf == 0则表示全部逆序

前缀指针i和后缀指针j，i从0开始，j从后缀起点开始,

• 如果arr[i] <= arr[j]，则表示[0:i]和[j:-1]可以形成升序，计算值并和min比较

  然后前缀指针右移，选择更大的值进行比较

• 如果arr[i] > arr[j]，则表示后缀值过小，后缀向后移直到能形成升序

「左指针是用来缩小距离，右指针是用来组成非降序」！

class Solution {
public:
    int findLengthOfShortestSubarray(vector<int>& arr) {
    if(arr.size()==1) return 0;
    //双指针，先找出最大有序前缀pre和最大有序后缀suf
    //若pre==n则表示全部有序，若pre == suf && suf == 0则表示全部逆序
    // 前缀指针i和后缀指针j，i从0开始，j从后缀起点开始
    // 如果arr[i] <= arr[j]，则表示[0:i]和[j:-1]可以形成升序，计算值并和min比较
    //然后前缀指针右移，选择更大的值进行比较
    // 如果arr[i] > arr[j]，则表示后缀值过小，后缀向后移直到能形成升序
    //前缀指针的作用是缩小距离，后缀指针作用是形成升序
    int n = arr.size();
    int pre = 0, suf = n-1;//分别记录最长前缀的下标和最长后缀的下标
    while(pre+1<n && arr[pre] <= arr[pre+1]) pre++;
    while(suf>0 && arr[suf-1] <= arr[suf]) suf--;
    if(pre+1 == n) return 0;//全部升序
    if(suf == 0) return 1;//全部逆序
    int i = 0, j = suf;
    
    //只选择前缀或后缀需要删除的最小数量
    int res = min(n-pre-1, suf);
    while(i<=pre && j<n  && i <= j)
    if(arr[i] <= arr[j]) 
            res = min(res,j-(++i));
    else j++;
    return res;
    
    }
};

时间复杂度: $O(N)$,

空间复杂度：$O(1)$