代码随想录算法训练营第四天 | 24. 两两交换链表中的节点

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

题目链接:https://leetcode.cn/problems/swap-nodes-in-pairs/
解法：这一题使用快慢指针就可以解决。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head == nullptr){
            return nullptr;
        }
        ListNode *fast = head->next;
        ListNode *slow = head;
        int tmp;
        while(slow->next != nullptr){
            tmp = slow->val;
            slow->val = fast->val;
            fast->val = tmp;
            if(slow->next->next == nullptr){
                break;
            }
            slow = slow->next->next;
            fast = fast->next->next;
        }
        return head;
    }
};

二、19. 删除链表的倒数第 N 个结点

题目链接:https://leetcode.cn/problems/remove-nth-node-from-end-of-list/
解题思路：快慢指针，先让fast指针走n+1步，然后再两个同时走，当fast指针为空时，说明slow指针的next指针已经指向要删除的节点了，再进行删除操作即可。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode *fast = dummyHead;
        ListNode *slow = dummyHead;
        //fast指针先走n+1步
        while(n-- && fast->next!=nullptr){
            fast = fast->next;
        }
        fast = fast->next;
        while(fast!=nullptr){
            fast = fast->next;
            slow = slow->next;
        }
        ListNode *tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp; 
        return dummyHead->next;
    }
};

三、160. 相交链表

题目链接：https://leetcode.cn/problems/intersection-of-two-linked-lists/
解题思路:

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        //1、先求解两个链表的长度
        //2、移动较长的链表的指针到和较短指针的尾部
        //3、开始判断是否有交点，两个指针同时移动一步
        ListNode *curA = headA;
        ListNode *curB = headB;
        ListNode *curA1 = headA;
        ListNode *curB1 = headB;
        int lengthA = 0;
        int lengthB = 0;
        int step = 0;
        while(curA){
            curA = curA->next;
            lengthA++;
        }
        while(curB){
            curB = curB->next;
            lengthB++;
        }
        step = abs(lengthA-lengthB);
        if(lengthA > lengthB){
            while(step--){
                curA1 = curA1->next;
            }
        }else{
            while(step--){
                curB1 = curB1->next;
            }
        }
        while(curA1 && curB1){
            if(curA1 == curB1){
                return curA1;
            }else{
                curA1 = curA1->next;
                curB1 = curB1->next;
            }
        }
        return nullptr;
    }
};

四、142. 环形链表 II

题目链接：https://leetcode.cn/problems/linked-list-cycle-ii/
解题思路:
https://programmercarl.com/0142.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8II.html#%E6%80%9D%E8%B7%AF
总结：
1、判断是否有环：快慢指针，一个每次移动两步，一个每次移动一步，等到两个相遇时代表有环
2、在有环的状态下记录相遇的位置Index1,再记录头节点index2,同时移动两个指针，相遇的时候就是入环的节点。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast = head;
        ListNode *slow  = head;
        while(fast != nullptr && fast->next != nullptr){
    //    1、判断有环
            fast = fast->next->next;
            slow = slow->next;
    //    2、在有环条件下找到入环节点
            if(slow == fast){
                ListNode *index1 = fast;
                ListNode *index2 = head;
                while(index1 != index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2;
            }
        }
        return nullptr;
    }
};

五、总结

链表相关的题目使用指针相关写起来比较容易出错，后面得多训练链表相关的题目。
还有第四题的需要一些数学去推理，这个能力比较弱，后面需要加强。