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

 

目录

 两两交换链表中的节点

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

 链表相交

小结：

环形链表

知识点1：判断链表是否有环？

双指针法（快慢指针）

知识点2：如果有环，如何找到环入口？

---

两两交换链表中的节点

题目链接：24. 两两交换链表中的节点 - 力扣（LeetCode）

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表

关键点在于想清楚交换过程

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(head == NULL || head->next == NULL){
            return head;// 如果链表为空或只有一个节点，则无需交换 
        }
        // 添加虚拟头结点
        ListNode* dummpyHead = new ListNode(0);
        dummpyHead->next = head;
        ListNode* cur = dummpyHead;// 使用 cur 来遍历链表 
        while(cur->next != NULL && cur->next->next != NULL){
            ListNode* first = cur->next;// 第一个节点 
            ListNode* second = cur->next->next;// 第二个节点

            // 交换节点
            cur->next = second;
            first->next = second->next;// 第一个节点指向第二个节点的下一个节点
            second->next = first;// 第二个节点指向第一个节点
            
            // 移动 cur 到已处理好的链表的末尾
            cur = first;
        }
        head = dummpyHead->next;
        delete dummpyHead;
        return head;
    }
};

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

题目链接：19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

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

难点:如何找到倒数第n个节点

自己的解法：遍历链表，记录链表的长度，再找到第（size - n）个节点

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

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = head;
        while(n--) {
            fast = fast->next;
        }
        while (fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next; 
        
        // ListNode *tmp = slow->next;  C++释放内存的逻辑
        // slow->next = tmp->next;
        // delete tmp;
        
        return dummyHead->next;
    }
};

 链表相交

题目链接：面试题 02.07. 链表相交 - 力扣（LeetCode）

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

思路：

1. 遍历链表，求出A、B的长度
2. 求出长度差step
3. 尾部对齐，让较长的链表先走step
4. 然后同时遍历
   • 若两指针相同，说明相交
   • 若为空，说明没有相交

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != NULL) { // 求链表A的长度
            lenA++;
            curA = curA->next;
        }
        while (curB != NULL) { // 求链表B的长度
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            swap (lenA, lenB);
            swap (curA, curB);
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap--) {
            curA = curA->next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != NULL) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

小结：

删除链表的倒数第N个节点 和 链表相交，两道题的思路很相似，都有一种对齐的思想。

对齐：让一个指针先走x步，然后两个链表再同时遍历

环形链表

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

主要考察两知识点：

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

知识点1：判断链表是否有环？

我一开始以为只要，遍历不到NULL（即链表的末尾），就可以说明链表中不存在环。后来，我发现这种想法是错误的。判断条件while( cur != NULL) 。如果链表中存在环，那么程序会陷入while的死循环，cur 不可能等于NULL。所以，简单的判断，遍历到NULL是无法判断的。也说明采用单个指针是无法判断的。

双指针法（快慢指针）

快指针：每次移动两个节点 ；慢指针：每次移动一个节点 ; 两者的相对速度就是一个节点.

如果存在环，慢指针可以视作不动(相对静止)，快指针以一个节点的移动速度靠近慢指针,两个指针一定会相遇。

知识点2：如果有环，如何找到环入口？

这里有点像小学的追击问题。我们可以知道，快指针和慢指针的速度不同，走的路程也不相同，但是两者的时间相同。同时，快指针的速度 = 慢指针速度 * 2 ，路程 = 速度 * 时间 。所以，相遇的时候，快指针的路程 = 2 * 慢指针的路程。由于，两指针的相对速度是1，所以在慢指针刚进入环的时候，快指针相当于抢跑了 头结点到入口的距离。

从上图的推导过程中，我们也可以发现，其实和圈数没有关系，我们把相遇之前的路程都设为了M，无论跑了多少圈都是M

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

/**
 * 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) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，此时从head 和 相遇点，同时查找直至相遇
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }
};

注意：while(fast != NULL && fast->next != NULL)

fast != NULL是确保fast->next 不会出现空指针异常。fast->next != NULL 是确保 ( fast->next ) -> next 不会出现空指针异常