代码随想录训练营第四天|快慢指针

原创已于 2024-09-04 14:04:43 修改 · 391 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构 #链表

于 2024-08-17 16:37:19 首次发布

24. 两两交换链表中的节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode dummy=ListNode(-1);
        dummy.next=head;
        ListNode *cur=&dummy, *first, *second, *third;
        while(cur&&cur->next&&cur->next->next){
            first=cur->next;
            second=first->next;
            third=second->next;           
            
            first->next=third;
            second->next=first;
            cur->next=second;

            cur=cur->next->next;
        }
        return dummy.next;
    }
};

正序修改结果也对，但是修改过程存在成环的现象。

19.删除链表的倒数第N个节点

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

1.使用虚拟头解决要删除的元素在头部的问题

2.slow要指向待删除元素的上一位，所以fast要提前移动【n+1】步。

面试题 02.07. 链表相交

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        auto h1=headA, h2=headB;
        while(h1!=h2){
            h1=h1?h1->next:headB;
            h2=h2?h2->next:headA;
        }
        return h1;
        
    }
};

采用两个指针，遍历两个链表，当遍历指针走到当前链表尽头后，指向另一个链表头部。

1.如下图所示，若两链表相交，则这两个指针必定会在交点处相遇，因为m+l+n=n+l+m;

2.如下图所示，若两链表不相交，则这两个指针遍历过程不会相遇（否则说明n中有环，不符题意），直到二者同时到达了末尾（nullptr），因为n+m=m+n;

142.环形链表II

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        auto fast=head,slow=head;
        bool flag=false;
        while(fast&&fast->next){
            slow=slow->next;
            fast=fast->next->next;
            if(fast==slow){
                flag=true;
                break;
            }
        }
        if(!flag)
            return nullptr;
        fast=head;
        while(fast!=slow){
            fast=fast->next;
            slow=slow->next;
        }
        return slow;
        
    }
};

利用套圈法判断成环，因为快指针每次走两步，慢指针每次走一步，追击速度是1，假设当前两指针距离为m，圈长为n，追击路程就是m+n，则经过（m+n）次运动，快慢指针一定相遇。