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

24. 两两交换链表中的节点、 19.删除链表的倒数第N个节点、142.环形链表II面试题 02.07. 链表相交

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

题目要求我们交换两两节点，很显然，我们可以应题目，交换节点即可，当然，我们不交换节点，直接交换值显然也可以

不交换节点，只交换值

当我们只交换值，不交换节点时，这道题就变成了简简单单的两值互换的题目，每次互换，我们只需让指针向后移动两位即可。
首先，我们需要判断当前指针和下一个指针是否存在，因为当前指针和下一个指针不存在时，我们显然不能对空指针进行操作。

再将指针向后移动两位即可。

代码

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        int temp;
        ListNode *p=head;
        while(p&&p->next)
        {
            temp=p->val;
            p->val = p->next->val;
            p->next->val = temp;
            p = p->next->next;
        }
        return head;
    }
};

交换节点

如果想要交换节点，我们需要定义一个虚拟节点，据此我们可以不用再讨论头节点的特殊性，将遍历指针指向这个虚拟节点，每次只需交换p节点后面两个节点即可。

我们定义一个新的临时指针，指向p的下一位，防止交换时导致指针丢失

此后让p指针等于temp即可一直遍历下去

代码

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* vir_head = new(ListNode);
        vir_head->next = head;
        ListNode* p = vir_head;
        while(p->next&&p->next->next)
        {
            ListNode* temp = p->next;
            p->next = temp->next;
            temp->next = p->next->next;
            p->next->next = temp;
            p = temp;
        }
        return vir_head->next;
    }
};

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

题目要求是删除倒数第k个节点，然而链表的长度是未知的，因此，我们无法得知遍历的节点是否处于倒数第几个位置，对此我们可以进行两次遍历，第一次遍历计算链表的长度，进而求得删除正向第n-k个元素。
同时，我们也可以设置快慢指针，使其间隔k个元素，遍历快指针，当快指针指向末尾时，慢指针所指即为删除指针的前一个元素。

此时只需要将slow的next指向slow的next的next即可
但是据此，我们讨论的都是一般情况，举个例子，当数组都有一个元素时，我们还要删除这个元素时，这样slow->next将不复存在，因此我们可以利用虚拟头节点的方式对上述情况进行优化，这样就不用担心这种情况了。

代码

 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* vir_head = new(ListNode);
        vir_head->next = head;
        ListNode* p_fast = vir_head;
        ListNode* p_slow = vir_head;
        while(n--)
        {
            p_fast=p_fast->next;
        }
        while(p_fast->next)
        {
            p_fast = p_fast->next;
            p_slow = p_slow->next;
        }
        p_slow->next = p_slow->next->next;
        return vir_head->next;
    }
};

142.环形链表II

如果一个链表不存在环形链表，那么这个链表的尽头就是null
如果一个链表存在环，那么我们如果遍历这个链表就是一直遍历下去

判断是否存在环

假设环中有个指针p，我们从p出发，以每次走一的速度，那么我们绕一圈后会再次遇到这个指针p。
我们引入两个指针fast和slow，为了确保两个指针都在环内，因此，我们必须给这两个指针都定义一个速度，然而想让他们相遇，就让他们有相对速度，对此，我们让slow每次走一个节点，让fast走两个节点，如果这两个指针相遇了，就证明这个链表有环的存在。

确定入口位置

据上述公式，我们假如让两个指针分别从起点处和第一次相遇点处出发，以相同的速度沿着路径前进，那么起始点的指针会在绕环若干圈后遇到另一个指针。

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

面试题 02.07. 链表相交

链表相交，指的是两个链表从某个位置开始指向了同一个节点，两个链表从该位置开始，后面的节点都相同，根据该性质，我们可以先求出两个链表长度的差值，并初始化两个指针。让他们初始指向不同的位置开始遍历，这个不同的位置值的是两个指针的错开，保证这两个指针后面具有相同的元素个数，即可以同时遍历到相同的节点，并能同时访问完链表，当两个指向公共节点后，就返回该节点，如果不存在这个公共节点，就返回空指针。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *p1 = headA;
        ListNode *p2 = headB;
        while(p1&&p2)
        {
            p1=p1->next;
            p2 = p2->next;
        }
        int num = 0;
        if(p1)
        {
            while(p1)
            {
                p1=p1->next;
                num++;
            }
            p1 = headA;
            p2 = headB;
            while(num--)
            {
                p1 = p1->next;
            }
        }
        else
        {
            while(p2)
            {
                p2=p2->next;
                num++;
            }
            p1=headA;
            p2 = headB;
            while(num--)
            {
                p2 = p2->next;
            }
        }
        while(p1&&p2)
        {
            if(p1 != p2)
                {
                    p1 = p1->next;
                    p2 = p2->next;
                }
                if(p1 == p2)
                    return p1;
        }
        return  nullptr;
    }
};