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

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

思路：在不允许更改节点内容的前提下，要交换a和b两个节点，需要current指向a前面的一个节点。

时间复杂度：O(n)

空间复杂度：O(1)

 

 

  注意：使用虚拟头结点，可以统一操作。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0,head);
        ListNode* cur = dummyHead;
        while(cur->next && cur->next->next){
            ListNode* front = cur->next->next;
            ListNode* rear = cur->next;
            ListNode* tmp = front->next;
            cur->next = front;
            rear->next = front->next;
            front->next = rear;
            cur = rear;
        }
        return dummyHead->next;

    }
};

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

思路：双指针。如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。

时间复杂度：O(n)

空间复杂度：O(1)

 

 

注意：同样，有虚拟头结点，可以统一删除操作。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0,head);
        ListNode* fast = dummyHead;
        ListNode* slow = dummyHead;
        //fast移动n-1次
        for(int i = 0;i < n + 1;i++){
            fast = fast->next;
        }
        //fast和slow一起移动，直到fast为null，此时slow指向待删除节点的前一个节点。
        while(fast){
            fast = fast->next;
            slow = slow->next;
        }
        //删除
        ListNode* p = slow->next;
        slow->next = p->next;
        delete(p);
        return dummyHead->next;
    }
};

面试题 02.07. 链表相交

思路：将两个链表对齐，从对齐的位置开始同时遍历两个链表，判断两个指针是否相等。

时间复杂度：O(n)

空间复杂度：O(1)

 举例：

 

 注意：

1.比较节点相等的条件不正确，应该比较节点本身，而不是 next 指针。错误代码：

if(p->next == q->next){
    return p->next;
}

2.p 应该移动 abs(lenA - lenB) 步，而不是 lenB - lenA 步。错误代码：

//p移动lenB-lenA次
for(int i = 0;i < lenB-lenA; i++){
    p = p->next;
}

代码实现：

class Solution {
public:

    int getLen(ListNode *head){
        ListNode* p = head;
        int len = 0;
        while(p){
            len++;
            p = p->next;
        }
        return len;
    }
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {

        int lenA = getLen(headA);
        int lenB = getLen(headB);
        ListNode* p;
        ListNode* q;
        if(lenA >= lenB){
            p = headA;
            q = headB;
        }
        else{
            p = headB;
            q = headA;
        }
        //p移动lenB-lenA次
        for(int i = 0;i < abs(lenB-lenA); i++){
            p = p->next;
        }
        while(p && q){
            if(p == q){
                return p;
            }
            p = p->next;
            q = q->next;
        }
        return NULL;
    }
};

142.环形链表II 

思路：这道题目，不仅考察对链表的操作，而且还需要一些数学运算。主要考察两知识点：

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

时间复杂度：O(n)

空间复杂度：O(1)

 分析：

1.判断链表是否环。快慢指针法，fast每次移走两步，slow每次移走一步，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。理由：fast和slow相对运动，fast每次比slow多走一步，是追赶slow的过程，因此，如果有环，一定可以相遇。

2.如果有环，如何找到这个环的入口。

 x+y+n(y+z)=2(x+y)

x+y=n(y+z)

x=n(y+z)-y

x=(n-1)(y+z)+y+z-y

x=(n-1)(y+z)+z

从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点，那么当这两个指针相遇的时候就是环形入口的节点。

代码实现：

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){ //快慢指针相遇，说明有环
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while(index1 != index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        //没有环
        return NULL;
    }
};