代码随想录训练营第四天：24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 .链表相交 142.环形链表II

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

题干

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

注意

1. 如果链表正好有偶数个节点（例如四个节点）那就只需要1,2交换，3,4交换即可
2. 如果链表有奇数个节点，那就放弃最后一个，前偶数个节点交换即可

解题思路

首先还是添加一个虚拟头节点dummyhead，

操作步骤如下：

1. 让dummyhead指向2号节点
2. 让2号节点指向1号节点
3. 一号节点再指向三号节点

最后将链表展平就是下面的形式

至此我们就成功的交换了链表的头两个节点

代码实现

注意点：

1. 循环条件的设置

while(cur->next != nullptr && cur->next->next != nullptr) 

cur初始化时指向虚拟头结点，每次循环向后移动两个节点，如果是偶数个节点，那么cur->next是NULL，如果是奇数个节点，cur->next->next是NULL，此处的判断条件必须先判断cur->next再判断cur->next->next，如果反过来，偶数个节点时，cur->next->next就是对空指针进行指针操作，就会报错，
在C++中，如果在 while 循环的条件中使用逻辑与运算符 (&&)，第一个条件为假时，第二个条件不会被判断。这种行为称为短路求值（short-circuit evaluation）。

代码步骤如下：

1. 设置新的虚拟头结点
2. 虚拟头结点指向head
3. 定义一个新指针 cur，指向虚拟头结点
4. 循环判断，进入循环
5. 记录临时节点，cur->next，cur->next->next->next
6. 改变节点指向
7. cur 移动两位，准备下一轮交换
8. return dummyhead->next

操作过程图示

此处也可以写成 cur->next = cur->next->next;

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode *dummyhead = new ListNode(0);
        dummyhead->next = head;
        ListNode *cur = dummyhead;
        while(cur->next != nullptr && cur->next->next != nullptr)
        {
            ListNode *temp = cur->next;
            ListNode *temp1 = cur->next->next->next;
            //改变节点指向
            cur->next = temp->next;
           cur->next->next = temp;
           cur->next->next->next = temp1;

           cur = cur->next->next;

        }
        ListNode *result = dummyhead->next;
        delete dummyhead;
        return result;


    }
};

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

题干

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
本题的关键是如何找到倒数第n个节点

使用快慢双指针的方法解决

1. 定义两个快慢指针，fast，slow，同时指向dummyhead
2. 快指针后移n+1个节点，
3. 快慢指针同时移动，直到快指针指向NULL
4. 删除目标节点，注意slow指针指向的是目标节点的前一个节点
5. 定义临时变量，释放内存
6. 返回头结点
   
   
   
   

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

            fast = fast->next;
            
        }
        fast = fast->next;

        while(n-- && fast != nullptr)
        {
            fast = fast->next;
            slow = slow->next;

        }

        ListNode *temp = slow->next;
        slow->next = slow->next->next;
        delete temp;
        
        return dummyhead->next;		//此处不能返回head，因为删除的节点可能是head


    }
};

面试题 02.07. 链表相交

题干

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

本质上就是求两个链表交点节点的指针。 注意：交点不是数值相等，而是指针相等。

解题思路

1. 两个链表，curA指向链表A的头结点，curB指向链表B的头结点：
2. 求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，
3. 此时就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。否则循环退出返回空指针。
   
   
   在C++中，一个函数只能执行一次return语句并返回到调用者。当函数遇到第一个return语句时，它会立即退出函数，并返回指定的值（如果有）。函数中后续的代码（包括任何其他return语句）将不会被执行。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *cura = headA;
        ListNode *curb = headB;
        //求两个链表的长度
        int lenA = 0;
        int lenB = 0;

        while(cura != nullptr)
        {
            cura = cura->next;
            lenA ++;
        }
        while(curb != nullptr)
        {
            curb = curb->next;
            lenB ++;
        }

        //cura和curb要先回到初始头指针位置
        cura = headA;
        curb = headB;

        if(lenB > lenA)
        {
            swap(lenA,lenB);
            swap(cura,curb);

        }
        int gap = 0;
        gap = lenA - lenB;

        while(gap--)
        {
            cura = cura->next;
            
        }

        while(cura != nullptr)
        {
            if(cura == curb)
            {
                return cura;
            }
           
            cura = cura->next;
            curb = curb->next;
        }

    return NULL;

        
    }
};

142.环形链表II

题干

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
说明：不允许修改给定的链表。

解题思路

1. 判断环
   定义两个指针，快指针 fast 和慢指针 slow ，快指针每次走两个节点，慢指针每次走一个节点，两个指针的相对速度是每次走一个节点，如果链表存在环，那么两个指针必在环中相遇，
2. 找到环的入口
   假设从头结点到环形入口节点的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。 如图所示：
   
   那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数。
   因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：
   (x + y) * 2 = x + y + n (y + z)
   两边消掉一个（x+y）: x + y = n (y + z)
   因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。
   所以要求x ，将x单独放在左面：x = n (y + z) - y ,
   再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针，当 n为1的时候，公式就化简为 x = z，
   这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点（以同样的速度）， 那么当这两个指针相遇的时候就是环形入口的节点。
   也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。
   让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。
   

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast = head;
        ListNode *slow = head;
        while(fast != nullptr && fast->next != nullptr)
        {
            fast = fast->next->next;
            slow = slow->next;
            if(fast == slow)
            {
                ListNode *index1 = fast;
                ListNode *index2 = head;
                
                while(index1 != index2)
                {
                    index1 = index1->next;
                    index2 = index2->next;
                    
                }
                return index1;	//返回1和2都行

            }
        }
        return nullptr;
    }
};