C++ day4 链表 两两交换链表中的节点 删除链表的倒数第N个节点 面试：链表相交 环形链表Ⅱ

题目1：24 两两链表交换链表中的节点

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

对题目的理解：两两交换链表中相邻节点（只进行节点交换）

关键在于终止遍历判断条件

节点数量要分奇偶：
对于奇数个节点，最后一个不做交换，当cur->next->next==NULL终止遍历

对于偶数个节点，当cur->next==NULL终止遍历

对于一组数据来说，整个操作（需要涉及到原链表的第3个节点）

设置中间临时变量法

注意这里的cur=dummyhead，因为要对head进行操作，所以要直到head的前面节点，即dummyhead.

• 时间复杂度：O(n)
• 空间复杂度：O(1

  /**
   * Definition for singly-linked list.
   * struct ListNode {
   *     int val;
   *     ListNode *next;
   *     ListNode() : val(0), next(nullptr) {}
   *     ListNode(int x) : val(x), next(nullptr) {}
   *     ListNode(int x, ListNode *next) : val(x), next(next) {}
   * };
   */
  class Solution {
  public:
      ListNode* swapPairs(ListNode* head) {
          ListNode* dummyhead = new ListNode(0);
          dummyhead->next = head;
          ListNode* cur = dummyhead;
          ListNode* temp;
          ListNode* temp1;
          while(cur->next!=nullptr&&cur->next->next!=nullptr)
          //循环条件顺序不能变，若顺序颠倒，则可能出现cur->next为空的现象，那么cur->next->next就是对空指针进行操作
          //并且这里一定要是&&,只有当这两个都不为空的时候，才能进行循环，因为后面会用到这两个值
          {
              temp = cur->next;  //第一个节点
              temp1 = cur->next->next->next;//第三个节点
              cur->next = cur->next->next;
              cur->next->next = temp;
              temp->next = temp1;//也可以写成 cur->next->next->next = temp1;
              cur = cur->next->next;
          }
          return dummyhead->next;
  
  
      }
  };

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

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

对题目的理解 ：删除链表的第N个节点

自己的思路

循环各个节点并计数，倒数节点位置与正数节点位置满足一个等式关系，计数的同时计算其对于倒数的位置，将计算得出的倒数位置与target比较，若相等，则执行删除节点的操作，若不等，则继续向下计数。

Q1:问题在于自己想的过于简单了，因为无法知道链表的整个长度，所以这条路走不通

A1:其实整个链表的长度是可以知道的，可以遍历整个链表，进行计数。

但是最终的结果需要进行分类讨论，因为最后的节点的删除与中间节点的删除，过程有点不太一样。

还有最关键的一点是cur一定要指向当前要删除节点的前一个结点！！！

综上。利用这种方法，步骤繁琐，条件过多，不推荐

使用双指针思想会更便于操作

双指针法

定义fast指针和slow指针，指向dummyhead

首先让fast指针先走n+1步，然后fast与slow同时向后走，直到fast指向了NULL，此时slow指针指向了要删除的第n个节点的前一个节点

之所以要让fast走n+1步，而不是n步，是因为要使得slow指针指向要删除的节点的前一个节点。

• 时间复杂度: O(n)
• 空间复杂度: O(1)

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyhead = new ListNode(0);
        ListNode* fast = dummyhead;
        ListNode* slow = dummyhead;
        dummyhead->next = head;
        // while(n--&&fast!=NULL)
        // {
        //    fast = fast->next;
        // }
        // fast = fast->next;//在n很大，超出链表长度时,fast必然已经指向了null,fast = fast->next对空指针操作
        n++;
        while(n--&&fast!=NULL){
            fast = fast->next;
        }//此时fast走到了n+1的位置
        
        //同时移动fast和slow，直到fast指向了NULL
        while(fast!=NULL){
            fast = fast->next;
            slow = slow->next;
        }
        //当fast=NULL时，此时slow指向了要删节点的前一个结点
        slow->next = slow->next->next;
        // ListNode *tmp = slow->next;  //C++释放内存的逻辑
        // slow->next = tmp->next;
        // delete tmp;
        return dummyhead->next;
    }
};

题目3：面试题 02.07.链表相交

题目链接：链表相交

对题目的理解

找出两个单链表起始交点，若没有交点，返回NULL, 即求两个链表交点节点的指针，一定要是指针相等，不是数值相等

步骤：

i）求出两个链表的长度，并求出两个链表长度的差值，

ii）让curA移动到，和curB 末尾对齐的位置,此时，就可以比较curA和curB是否相同，

iii）如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。

• 时间复杂度：O(n + m)  求了A和B两个链表的长度，所以加起来m+n
• 空间复杂度：O(1)

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        //定义两个指针指向A,B链表的头节点
        ListNode* curA = headA;
        ListNode* curB = headB;
        //求得两个链表的长度
        int lenA = 0, lenB = 0;
        while(curA!=NULL){
            lenA++;
            curA = curA->next;
        }
        while(curB!=NULL){
            lenB++;
            curB = curB->next;
        }    
        //注意这里curA,curB已经移动到链表的最后一个节点处了，后续进行操作仍然需要从head处开始，所以将curA,curB移动到head
        curA = headA;
        curB = headB;
        //求得两个链表长度的差值
        //因为会出现lenAlenA){
            swap(lenA,lenB);
            swap(curA,curB);
        }
        int dek = lenA - lenB;
        //将最长链表A的指针curA移到与B的指针curB相同的位置
        while(dek--){
            curA = curA->next;//前面已经判断果curA!=NULL了，所以这里的循环就不需要再判断了
        }
        //同时移动curA和curB
        while(curA!=NULL){
            if(curA == curB){
                return curA;
            }
            else {
                curA =curA->next;
                curB = curB->next;
            }   
        }
        return NULL;
        
    }
};

！！！！注意在求解完两个链表的长度之后，一定要将curA,curB重新移动到headA,headB处，进行后续的操作

还有就是求解两个链表的长度差时，一定要知道哪个链表长，这样才能顺利求长度差，所以使用swap函数，交换lenA与lenB的值，这样使得链表A永远是长度最长的那个链表，这样便于计算编程。

题目4：142  环形链表Ⅱ

题目链接：142. 环形链表 II - 力扣（LeetCode）

对题目的理解

返回链表开始入环的第一个节点，如果没有，则返回NULL；

pos表示链表尾接到链表中的位置（pos从0开始计）

拆解题目

• 判断链表是否环
• 如果有环，如何找到这个环的入口

i）判断链表是否有环，需要定义一个双指针，fast和slow，开始都指向head，令fast指针每次走两步（两个节点），slow指针每次走一步（一个节点），fast相对于slow每次只走一步（一个节点），那么如果有环的话，在环内，一定是fast追赶slow的过程中，fast会遇到slow，所以，fast一定会遇到slow ，且fast至少走一圈，才能实现追赶slow的情况，才会和slow相遇。

假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。

fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2；

相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。

slow等于x+y而不等于x+y+n(y+z)的原因：

将整个环形展平，在slow第一次到达环形入口时，fast位于环形内的某一位置，当slow走一圈时，fast所走路长定位slow的两倍，其fast相对slow走一步，那么fast定会和slow在slow走一圈之前（也就是fast走第一圈）相遇（红色虚线）

要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。

推演出x==z,那么再定义两个指针index1和index2，将index1放置在head，index2放置在fast和slow相遇的点，让index1与index2以相同的步数前进，那么index1和index2一定会在环形节点的入口相遇。

• 时间复杂度: O(n)，快慢指针相遇前，指针走的次数小于链表长度，快慢指针相遇后，两个index指针走的次数也小于链表长度，总体为走的次数小于 2n
• 空间复杂度: O(1)

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        //首先判断是否有环
        //定义两个指针fast  slow，判断是否会相遇
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast!=NULL&&fast->next!=NULL){  //由于fast一次走两步，所以还需要判断fast->next不为空
            fast = fast->next->next;//fast一次走两步
            slow = slow->next;//slow一次走一步
            if(fast == slow){//快慢指针相遇
                ListNode* index1 = head;
                ListNode* index2 = fast;//等于slow也是一样的，因为在这个点相遇
                while(index1!=index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return NULL;    
    }
};