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

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

文章讲解：代码随想录

视频讲解：帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点_哔哩哔哩_bilibili

题目链接：. - 力扣（LeetCode）

解题思路：

        1.写循环，每次循环处理两个节点。因为要获取处理的两个节点，以用来改变它们的next，因此指针需要位于要处理两个节点的前面一个节点，接着定义temp临时变量存储节点，后面改变每个节点的next后即可。

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

关键点：

        1.循环的结束条件。要把cur->next写在cur->next->next前面，反过来写当cur->next为空时就会出现空指针错误。

        2.用好temp变量保存指针。本题需要保存的指针较多。

c++代码：

/**
 * 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 * cur = new ListNode();
        ListNode * dummyHead = cur;
        cur->next = head;
        ListNode * temp = new ListNode();
        ListNode * temp1 = new ListNode();
        
        while(cur->next != NULL && cur->next->next != NULL)
        {
            temp = cur->next; 
            temp1 = cur->next->next->next;
            cur->next = cur->next->next;
            cur->next->next = temp;
            temp->next = temp1;
            cur = cur->next->next;
        }
        return dummyHead->next;
    }
};

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

文章讲解：代码随想录

视频讲解：链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点_哔哩哔哩_bilibili

题目链接：. - 力扣（LeetCode）

解题思路：

        1.双指针法。快指针向后移动n位，然后每次快慢同时向后移动一位，当快指针的next是NULL时，表示快指针移动到了最后一位，慢指针移动到了要删除节点的前一位。此时慢指针进行删除即可。

关键点：

        1.快指针比慢指针多走n次的思路。

c++代码：

/**
 * 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();
        dummyHead->next = head;
        ListNode * fast = dummyHead;
        ListNode * slow = dummyHead;
        //让快指针先往前移动n个位置。
        //leecode中n的取值范围不会大于链表长度，fast != NULL 不加也可以
        while(n-- && fast != NULL)
            fast = fast->next;
        
        while(fast->next != NULL)
        {   
            fast = fast->next;
            slow = slow->next;
        }
        ListNode * temp = slow->next;
        slow->next = slow->next->next;
        delete temp;
        return dummyHead->next;
    }
};

面试题 02.07. 链表相交

文章讲解：代码随想录

视频讲解：无

题目链接：. - 力扣（LeetCode）

解题思路：

        1.从相交节点开始后面的节点都相同。那么相交节点可以从短链表方向寻找。将指针移向结点，从该结点开始，链表剩余长度都为短链表的长度。此时每次进行两个指针的判断。若不相同则两个指针一起向后移动。

关键点：

        1.值相同不代表指针相同。leecode中用值表示结点只是为了方便演示。实际上判断是否指向同一结点需要进行==判断。

c++代码：

/**
 * 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) 
    {
        ListNode * curA = headA;
        ListNode * curB = headB;
        int lenA = 0,lenB = 0;
        //求链表A长度
        while(curA != NULL)
        {
            lenA++;
            curA = curA->next;
        }

        //求链表B的长度
        while(curB != NULL)
        {
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        if(lenB > lenA)
        {
            swap(lenA,lenB);
            swap(curA,curB);
        }
        int gap = lenA - lenB;
        while(gap--)
            curA = curA->next;
        while(curA != NULL)
        {
            if(curA == curB)
            {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;

    }
};

142.环形链表Ⅱ

文章讲解：代码随想录

视频讲解：把环形链表讲清楚！ 如何判断环形链表？如何找到环形链表的入口？ LeetCode：142.环形链表II_哔哩哔哩_bilibili

题目链接：. - 力扣（LeetCode）

解题思路：

        1.画图，用数学方法对不同的距离假设未知数x、y...获得快慢指针相遇时走过距离的等式，通过推导等式，得出从相遇点开始，在环中走到环入口的距离是从head结点走到环入口距离的n倍的结论(n>=1)，因此从相遇开始，再安排两个指针，分别从相遇点和起始点以相同速度前进，一定会在某个时候在入口处相遇。

关键点：

        1.分析出距离相等的结论。(具体结论上述已说)

c++代码：

/**
 * 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)
        {
            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 index2;
            }
        }
        return NULL;
    }
};