LeetCode14种模式（一）：快慢指针_leetcode快慢指针-CSDN博客

本文链接：https://blog.csdn.net/K_Xin/article/details/107272993

本文探讨了使用快慢指针解决LeetCode中的数组和链表问题，如移除数组特定值、处理排序数组重复项、判断链表环及找相交链表起点等。通过快慢指针的配合，可以有效地解决这类问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数组移除特定值

算法思想：fast指针用于搜索数组，slow指针代表新数组末尾

移除元素
给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。

在这里插入图片描述

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

移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

在这里插入图片描述

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

删除排序数组中的重复项
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

在这里插入图片描述

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

删除排序数组中的重复项 II
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素最多出现两次，返回移除后数组的新长度。

在这里插入图片描述

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

链表有循环

环形链表
给定一个链表，判断链表中是否有环。

class Solution {
public:
    bool hasCycle(ListNode *head) {
        if (!head) return false;

        ListNode *slow = head, *fast = head;
        while ( fast != NULL && fast->next != NULL ) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast) return true;
        }
        
        return false;
    }
};

环形链表 II
给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if (!head) return nullptr;
        
        ListNode *slow = head, *fast = head;
        while ( fast != nullptr && fast->next != nullptr ) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast) break;
        }
        if (fast == nullptr || fast->next == nullptr)   return nullptr;

        fast = head;
        while (slow != fast) {
            slow = slow->next;
            fast = fast->next;
        }
        
        return fast;
    }
};

寻找重复数
给定一个包含 n + 1 个整数的数组 nums，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个重复的整数。假设只有一个重复的整数，找出这个重复的数。

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        int slow = nums[0], fast = nums[nums[0]];
        while (slow != fast) {
            slow = nums[slow];
            fast = nums[nums[fast]];
        }

        fast = 0;
        while (slow != fast) {
            slow = nums[slow];
            fast = nums[fast];
        }
        return fast;
    }
};

相交链表
编写一个程序，找到两个单链表相交的起始节点。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (headA == nullptr || headB == nullptr) return nullptr;

        ListNode *a = headA, *b = headB;
        while (a != b) {
            if (a) a = a->next;
            else a=headB;
            if (b) b = b->next;
            else b=headA;
        }

        return a;
    }
};