codetop标签双指针题目大全解析(四)，双指针刷穿地心！！！！！

1.长度最小的子数组

考滑动窗口的
要注意是大于等于不是等于
看错题目一顿调

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int left = 0;
        int right = 0;
        int sum = 0;
        int len = INT_MAX;
        while(right < nums.size()){
            sum += nums[right];
            right++;
            while(sum >= target){
                len = min(len, right - left);
                sum -= nums[left];
                left ++;
            }
        }
        return len == INT_MAX ? 0 : len;
    }
};

2.移动零

非0元素前移，这和秒杀双指针里面的移除特定元素是一样的
最后别忘了填充
二刷debug：秒

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        //非0前移
        int slow = 0;
        for(int fast = 0; fast < nums.size(); fast ++){
            if(nums[fast] != 0){
                nums[slow] = nums[fast];
                slow++;
            }
        }
        //剩下部分填充0
        for(; slow < nums.size(); slow ++) nums[slow] = 0;
    }
};

3.盛水最多的容器

双指针秒杀里面的原题

class Solution {
public:
    int maxArea(vector<int>& height) {
        int left = 0, right = height.size() - 1;
        int r = 0;
        while(left < right){
            r = max(r, min(height[right], height[left]) * (right - left));
            if(height[left] < height[right]) left ++;
            else right --;
        }
        return r;
    }
};

4.旋转链表

整体思路是，将链表头尾连起来，再在新的表尾处砍断
里面有非常多的小细节，比如 k = k % length;
寻找新的表尾：成环右移k个，说明链表倒数第k个会变成表头，for (int i = 0; i < length - k - 1; i++)可以定位到表头前面一个也就是表尾

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if (!head || !head->next || k == 0) return head;
        // 第一步：计算链表长度并形成环形链表
        ListNode* lastNode = head;
        int length = 1;
        while (lastNode->next) {
            lastNode = lastNode->next;
            length++;
        }
        lastNode->next = head; // 形成环形链表

        // 第二步：计算实际需要移动的步数
        k = k % length;
        if (k == 0) {
            lastNode->next = NULL; // 恢复链表
            return head;
        }
        // 第三步：找到新的头节点和尾节点
        ListNode* newTail = head;
        for (int i = 0; i < length - k - 1; i++) {
            newTail = newTail->next;
        }
        ListNode* newHead = newTail->next;

        // 断开链表
        newTail->next = NULL;

        return newHead;
    }
};

二刷debug：换了一个写法，用快慢指针做，需要注意的是快指针停下来的地方不应该是null，而是head

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(!head || !head->next || k == 0) return head;//检查链表是否为空或不需要旋转
        ListNode* fast = head;
        ListNode* slow = head;

        ListNode* p = head;
        int len = 1;
        while(p->next){
            p = p->next;
            len ++;
        }
        p->next = head;
        //倒数第 n 个节点变成尾节点
        k = k % len;
        for(int i = 0; i < k; i ++) fast = fast->next;
        while(fast->next != head){//这里是head而不是null
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* newHead = slow->next;
        slow->next = nullptr;
        return newHead;

    }
};

5.最接近的三数之和

别人写的代码怎么这么优雅┭┮﹏┭┮
重点在于判断最近的，用abs绝对值
if(abs(target - close) < abs(target - closeNum)) closeNum = close
close是当前的三个元素，closeNum是最接近的，初始化为nums[0] + nums[1] + nums[2]

这个return的是和，重复不重复只是降低复杂度，不会改变答案，不用像三数之和一样死扣不重复

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        int closeNum = nums[0] + nums[1] + nums[2];
        for(int i = 0; i < nums.size(); i ++){
            if(i && nums[i] == nums[i - 1]) continue;
            int left = i + 1, right = nums.size() - 1;
            while(left < right){
                int close = nums[i] + nums[left] + nums[right];
                if(abs(target - close) < abs(target - closeNum)) closeNum = close;
                if(close > target) right--;
                else if(close < target) left++;
                else return target;
            }
        }
        return closeNum;
    }
};

6.删除有序数组中的重复项

快慢指针，一开始没能灵活应用，还得练
二刷debug：不会

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int slow = 0, fast = 1;
        while(fast < nums.size()){
            if(nums[slow] == nums[fast]){
                fast++;
            }else{
                slow++;
                nums[slow] = nums[fast];
            }
        }
        return slow + 1;
    }
};

7.返回倒数第k个节点的值

假如链表长度是k，返回倒数第k个的情况要留意处理
这题题目给的k一定是合理的！

class Solution {
public:
    int kthToLast(ListNode* head, int k) {
        ListNode* slow = head;
        ListNode* fast = head;
        
        // fast 指针先前进 k 步
        for (int i = 0; i < k; i++) {
            fast = fast->next;
        }
        
        // 同时前进 slow 和 fast，直到 fast 到达链表末尾
        while (fast != nullptr) {
            fast = fast->next;
            slow = slow->next;
        }
        
        // 此时 slow 所指向的即为倒数第 k 个节点
        return slow->val;
    }
};

8.四数之和

双指针秒杀原题
二刷忘记了一些细节，longlong和需要排序sort

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> res;
        for(int i = 0; i < nums.size(); i ++){
            if(i && nums[i] == nums[i - 1]) continue;
            for(int j = i + 1; j < nums.size(); j ++){
                if(j > i + 1 && nums[j] == nums[j - 1]) continue;
                for(int k = j + 1, u = nums.size() - 1; k < u; k ++){//双指针
                    if(k > j + 1 && nums[k] == nums[k - 1]) continue;           
                    while(k < u && (long long)nums[i] + nums[j] + nums[k] + nums[u] > target) u--;
                    if(k < u && (long long)nums[i] + nums[j] + nums[k] + nums[u] == target) res.push_back({nums[i], nums[j], nums[k], nums[u]});
                }
            }
        }
        return res;
    }
};

9.验证回文串

先把所有字符转化成小写，并过滤掉空格和标点这类字符。然后对剩下的字符执行双指针中的两端向中心的双指针算法即可。

新学到的库函数：

1. isalnum( c )：isalnum 检查字符c是不是字母或者数字，如果是的话，返回true，不是的话返回false
2. tolower( c )：tolower 将字符 c 转换为小写字母。如果 c 本身是小写字母或非字母字符，返回值将与 c 相同。

class Solution {
public:
    bool isPalindrome(string s) {
        string sb;
        for(int i = 0; i < s.size(); i ++){
            char c = s[i];
            if(isalnum(c)){
                sb += tolower(c);
            }
        }
        
		//双指针两头往中间验证
        s = sb;
        int left = 0, right = sb.size() - 1;
        while(left < right){
            if(sb[left] != sb[right]) return false;
            left++;
            right--;
        }
        return true;


    }
};