代码随想录算法训练营Day4 | ● 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II

代码随想录算法训练营Day4 | 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II

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

题目链接：LeetCode 24. 两两交换链表中的节点

思路：

画图法

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode();
        dummyHead->next = head;
        ListNode* cur = dummyHead;
      //  ListNode* tmp;
        while(cur->next && cur->next->next){
            ListNode* tmp = cur->next;
            ListNode* tmp1 = cur->next->next->next;

            cur->next = cur->next->next;
            cur->next->next = tmp;
            cur->next->next->next = tmp1;

            cur = cur->next->next;
        }
        ListNode* result = dummyHead->next;
        delete dummyHead;
        return result;
    }
};

注意 ：

1. cur->next和cur->next->next为关键节点需要保存
2. 注意删除dummyHead

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

题目链接：19.删除链表的倒数第N个节点

思路：
快慢指针法，快指针先走n+1步，然后慢指针出发。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode();
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead; 
        while (n-- && fast){
            fast = fast->next;
        }
        fast = fast->next;
        while(fast){
            slow = slow->next;
            fast = fast->next;
        }

        slow->next = slow->next->next;
        ListNode* result = dummyHead->next;
        delete dummyHead;

        return result;
    }
};

注意 ：

1. 快指针先走n步，再走1步
2. slow指针指向被删除元素的前一个元素。

LeetCode 160.链表相交

题目链接：LeetCode 160.链表相交

思路：
1.先获取链表长度
2.将A设置为长链表
3.如果有交集，返回，否则返回NULL

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int len_A = 0, len_B = 0;
        ListNode* cur_A = headA;
        ListNode* cur_B = headB;
        while(cur_A){
            cur_A = cur_A->next;
            len_A ++;
        }
        while(cur_B){
            cur_B = cur_B->next;
            len_B ++;
        }


        cur_A = headA;
        cur_B = headB;
        
        if (len_B>len_A){
            swap(len_A,len_B);
            swap(cur_A,cur_B);
        }
        int diff_len = len_A - len_B;


        while(diff_len--){
            cur_A = cur_A->next;
        }

        while(cur_A){
            if (cur_A == cur_B){
                return cur_A;
            }
            cur_A=cur_A->next;
            cur_B=cur_B->next;
        }
        return NULL;
    }
};

注意 ：

1. swap函数的用法
2. 如何将A设置为长链表
3. 长链表先移动长度差值

LeetCode 142.环形链表II

题目链接：LeetCode 142.环形链表II

思路：
1.快慢指针，快指针2步，慢指针1步，若相遇，则有环
2.慢指针从起点出发，快指针从相遇点出发，每次同时移动1步，相遇点即为环的入口。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* slow = head;
        ListNode* fast = head;
        while (fast && fast->next){
            slow = slow->next;
            fast = fast->next->next;

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

注意 ：

1. 边界条件 fast以及fast->next需要有意义
2. 相交则必有环，因此必相遇。