代码随想录day04-链表|24. 两两交换链表中的节点 、19.删除链表的倒数第N个节点 、 面试题 02.07. 链表相交 、142.环形链表II

参考：代码随想录

1.1 两两交换链表中的节点

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

题目描述：

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

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

方法：

• 首先使用虚拟头结点，这样处理第一个结点就会方便很多。
• 然后是交换节点，就正常模拟交换过程就行了。
  刚开始想的是 不断摘下第偶数个节点，插在它前一个节点的前面，但是 前一个节点不太好找，所以转化一下变成：
  不断摘下第奇数个节点，插在它后一个节点的后面，这个过程就需要三个指针来完成，pre, cur 和 post。
  

代码：

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        // 如果链表为空或者链表中只有一个元素，那么就返回
        if (head == NULL || head->next == NULL) {
            return head;
        }
        // 不断摘下第偶数个节点，插在它前一个节点的前面
        // 前一个节点不太好找，所以转化一下变成：
        // 不断摘下第奇数个节点，插在它后一个节点的后面
        ListNode dummyHead = ListNode(0, head); // 虚拟头结点
        ListNode *pre = &dummyHead, *cur = dummyHead.next, *post;
        // 当可交换节点有2个时才进行交换
        while (cur != NULL && cur->next != NULL) {
            post = cur->next;
            // 如果能凑成一对互换，那么就把pre后面的两个节点交换
            // 先摘下第一个结点
            pre->next = post;
            // 再把cur插到post的后面
            cur->next = post->next;
            post->next = cur;
            // pre与cur都前进一步
            pre = cur;
            cur = cur->next;
        }
        return dummyHead.next;
    }
};

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

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

题目描述：

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

示例 ：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

方法：

设快慢指针，开始都指向虚拟头结点，快指针走n个之后，慢指针再走;
当快指针走到头为空时，慢指针所指的就是倒数第n个节点。

代码：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode dummyHead = ListNode(0, head);
        ListNode *fast = &dummyHead; // 快指针
        // 快指针先走n步
        while (fast != NULL && n) {
            fast = fast->next;
            n--;
        }
        // 如果 fast 为空的时候 n不为 0，说明 n 不合法，返回
        if (fast == NULL && n > 0) {
            return head;
        }
        ListNode *low = &dummyHead, *pre = &dummyHead; // 慢指针还有前一个指针
        // 慢指针再走，当快指针走到头为空时，慢指针所指的就是倒数第n个节点
        while (fast != NULL) {
            pre = low;
            low = low->next;
            fast = fast->next;
        }
        // 删除倒数第n个节点
        pre->next = low->next;
        delete low;
        return dummyHead.next;
    }
};

1.3 链表相交

链接： 面试题 02.07. 链表相交

题目描述：

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

题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。

方法：

先计算两个链表的长度，将他们尾端对齐之后，再一个一个结点比较是否相等。

代码：

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // 先计算两个链表的长度，将他们尾端对齐之后，再一个一个结点比较是否相等
        int len1 = getLen(headA), len2 = getLen(headB);
        ListNode *shortLink, *longLink;
        if (len1 > len2) {
            longLink = headA;
            shortLink = headB;
        } else {
            longLink = headB;
            shortLink = headA;
        }
        int offset = max(len1, len2) - min(len1, len2);
        // 长度移动offset个单位
        while (offset) {
            longLink = longLink->next;
            offset--;
        }
        // 两个链表长度相等的时候，开始比较
        while (longLink != shortLink) {
            longLink = longLink->next;
            shortLink = shortLink->next;
        }
        return longLink;
    }
    
    // 获取链表长度
    int getLen(ListNode *head) {
        int len = 0;
        ListNode *p = head;
        while (p != NULL) {
            len++;
            p = p->next;
        }
        return len;
    }

};

1.4 环形链表

链接： 142.环形链表II

题目描述：

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

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

方法：

使用快慢指针。

• 1. 判断是否有环：
  快指针每次走两步，慢指针每次走一步，如果快慢指针相遇，那么就说明链表中有环;

• 2.找环的入口：
  让 p指向开始节点，p和slow同步向前移动，如果slow和 p 相遇的位置就是环的入口。

分析：

（1）为什么fast 走两个节点，slow走一个节点，有环的话，一定会在环内相遇呢，而不是永远的错开呢？

这是因为fast是走两步，slow是走一步，其实相对于slow来说，fast每次比slow多走一步，是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合。

（2）如果有环，如何找到这个环的入口？

让 fast指向开始节点，和slow同步向前移动，他们相遇的位置就是环的入口。

代码：

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        // 用快慢指针判断是否有环，快指针每次走两步，慢指针每次走一步，如果快慢指针相遇，那么就说明链表中有环
        ListNode *fast = head, *slow = head;
        while (fast != NULL && fast->next != NULL) {
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) {
                // 说明链表中有环，找环的入口:
                // 让 p指向开始节点，p和slow同步向前移动，如果slow和 p相遇的位置就是环的入口
                ListNode *p = head;
                while (p != slow) {
                    slow = slow->next;
                    p = p->next;
                }
                return p;
            }
        }
        return NULL;
    }
};