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

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

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyhead = new ListNode(0);
        dummyhead->next = head;
        ListNode* cur = dummyhead;
        while (cur->next != NULL && cur->next->next != NULL) {
            ListNode* temp = cur->next;
            ListNode* temp1 = cur->next->next->next;
            cur->next = cur->next->next; // 赋值运算从右至左
            cur->next->next = temp;
            temp->next = temp1;

            cur = cur->next->next; // 右移两位 进行下次交换
        }
        return dummyhead->next; // 返回头结点时 原head发生了变化 因此返回dummyhead->next
    }
};

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

 ListNode* dummyHead = new ListNode(0); // 设置一个虚拟头结点
        dummyHead->next = head;

ListNode* dummyhead = new ListNode(0,head);

二者等价

方法一：计算链表长度

class Solution {
public:
    int gerSize(ListNode* head) {
        int size = 0;
        while (head) {
            head = head->next;
            size++;
        }
        return size;
    }
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyhead = new ListNode(0, head);
        ListNode* cur = dummyhead;
        int size = gerSize(head);
        // int num = (size - n); num为下标
        // while (num--) {
        //     cur = cur->next;
        // }
        for (int i = 1; i < size - n + 1; i++) {
            cur = cur->next;
        }
        ListNode* temp = cur->next;
        cur->next = cur->next->next;
        delete temp;
        return dummyhead->next;
    }
};

方法二：双指针法

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyhead = new ListNode(0, head);
        ListNode* slow = dummyhead;
        ListNode* fast = dummyhead;
        for (int i = 0; i < n + 1; i++) {
            fast = fast->next;
        }
        while (fast) {
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* temp = slow->next;
        slow->next = temp->next;
        delete temp;
        return dummyhead->next;//注意！！！
                 //虽然head指针本身没有变，但由于删减节点链表结构发生变化，不能直接返回head
                 //还存在删减节点为头结点的情况，显然head变化
    
};

面试题 02.07. 链表相交

class Solution {
public:
    int getSize(ListNode* head) {
        int size = 0;
        while (head) {
            head = head->next;
            size++;
        }
        return size;
    }
    ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
        int sizeA = getSize(headA);
        int sizeB = getSize(headB);
        ListNode* curA = headA;
        ListNode* curB = headB;
        if (sizeA > sizeB) {
            for (int i = 0; i < sizeA - sizeB; i++) {
                curA = curA->next;
            }
        } 
        else {
            for (int i = 0; i < sizeB - sizeA; i++) {
                curB = curB->next;
            }
        }
        while (curA != NULL) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

142.环形链表II

分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环

相遇点到入口距离=头结点到入口距离 

相遇后 重新定义指针 一个从头结点开始走，一个从相遇点开始走，到入口点汇合 返回入口节点

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