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

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

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

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

图示：

就是要new一个哑节点（dummyHead），然后cur = hummyHead;然后步骤1，即哑节点的下一个是节点2，cur->next = cur->next->next;然后步骤2，但步骤1中cur的next已经变成了2，不是1了，那我们就无法找到节点1了，于是我们要一开始那一个temp1去标记一下节点1，即temp1 = cur->next让节点2去指向节点1，也就是cur->next->next = temp1;但此时也有同样的问题，那就是节点3也会因为节点2改变指向而丢失，所以节点3我们也要在一开始就标记一下，于是temp2 = cur->next->next->next;这样我们就可以执行上述步骤了。

判断循环什么时候终止：我们是通过cur去操作后面的两个节点进行交换。如果是链表是奇数个，那么cur后来就会有next，但cur->next->next就为空，结束。如果链表为偶数个，那么cur的next就是空，结束。所以循环的终止条件就是cur->next!= nullptr 和cur->next->next!= nullptr.

那为什么是&& 不是|| 呢？一个是对于偶数个结点的判断 一个是奇数个结点 那不应该是||的关系吗？
奇数节点就不需要交换了，所以只有满足后面有偶数个节点的时候才会进入循环

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0,head);
        ListNode* cur = dummyHead;
        while(cur->next!= nullptr&& cur->next->next!= nullptr){
            ListNode* temp1 = cur->next;
            ListNode* temp2 = cur->next->next->next;

            cur->next = cur->next->next;
            cur->next->next = temp1;
            temp1->next = temp2;

            cur = cur->next->next;
        }
        return dummyHead->next;
    }
};

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

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

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

方法1：

首先获取链表长度，根据长度找到要删除的节点的前一个节点，删除对应节点。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(-1,head);
        ListNode* cur = dummyHead;
        int count = 0;
        while(cur->next!= nullptr){
            cur = cur->next;
            count++;
        }
        int k = count-n;
        cur = dummyHead;
        while(k){
            cur = cur->next;
            k--;
        }
        ListNode* temp = cur->next;
        cur->next = temp->next;
        delete temp;
        return dummyHead->next;
    }
};

 方法2：

双指针，让快指针先走n步，然后快慢指针在同时往后走，等快指针结束时，满指针到达指定地点，再进行链表操作。

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

面试题 02.07. 链表相交

面试题02.07.链表相交

方法1：

将链表A节点插入哈希表 中，然后遍历链表B去查找。

时间复杂度：O(m+n)O(m+n)O(m+n)，其中 mmm 和 nnn 是分别是链表 headA\textit{headA}headA 和 headB\textit{headB}headB 的长度。需要遍历两个链表各一次。

空间复杂度：O(m)O(m)O(m)，其中 mmm 是链表 headA\textit{headA}headA 的长度。需要使用哈希集合存储链表 headA\textit{headA}headA 中的全部节点

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        unordered_set<ListNode*> st;
        ListNode* cur1 = headA;
        while(cur1!= nullptr){
            st.insert(cur1);
            cur1 = cur1->next;
        }
        ListNode* cur2 = headB;
        while(cur2!= nullptr){
            if(st.find(cur2)!= st.end()){
                return cur2;
            }
            cur2 = cur2->next;
        }
        return nullptr;
    }
};

方法2：

遍历两个链表长度，相减之后，长的先走几步，然后同时走，相遇时即为相交节点

class Solution {
public:
    int ListLength(ListNode* head){
        if(head == nullptr)return 0;
        ListNode* cur = head;
        int count = 0;
        while(cur!= nullptr){
            count++;
            cur = cur->next;         
        }
        return count;
    }
    ListNode* compare1(ListNode *headA,int lengthA, ListNode *headB,int lengthB){
            int n = lengthA-lengthB;
            ListNode* curA = headA;
            ListNode* curB = headB;
            while(n--){
                curA =curA->next;
            }
            while(curA!= nullptr){
                if(curA == curB){
                    return curA;
                }
                curA = curA->next;
                curB = curB->next;
            }
            return nullptr;
    }
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int lengthA = ListLength(headA);
        int lengthB = ListLength(headB);
        
        if(lengthA>lengthB){
            ListNode* ans= compare1(headA,lengthA, headB,lengthB);
            return ans;
        }   
        if(lengthB>=lengthA){
            ListNode* ans= compare1(headB,lengthB, headA,lengthA);
            return ans;
        }  
        return nullptr;
    }
};

142.环形链表II

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

142.环形链表II

 方法1：哈希

借用unordered_set，将节点插入哈希表，判断下一个节点是否之已经在哈希表中，如果有，就有环，并返回该节点，反之就是没有环。时间复O(n),空间复杂度也为O(n)

lass Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        unordered_set<ListNode*> st;
        ListNode* cur = head;
        while(cur!= nullptr){
            if(st.find(cur)!= st.end()){
                return cur;
            }else{
                st.insert(cur);
                cur = cur->next;
            }
        }
        return nullptr;
    }
};

方法2：双指针-快慢指针

双指针方法

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* temp1 = head;
                ListNode* temp2 = slow;
                while(temp1!= temp2){
                    temp1 = temp1->next;
                    temp2 = temp2->next;
                }
                 return temp2;    
            }
        }
        return nullptr;
    }
};