代码随想录训练营第四天|24.两两交换链表的节点 19.删除链表的倒数第N个节点 160. 链表相交

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

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

解题思路  

设置虚拟头节点，这样不用每次都考虑头结点。此题通过画图有助于理解。

代码实现

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
         ListNode* dummyHead = new ListNode(0);    // 设置一个虚拟头结点
        dummyHead->next = head;          // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode* cur = dummyHead;
        while(cur->next != nullptr && cur->next->next != nullptr) {
            ListNode* temp = cur->next; // 记录临时节点
            ListNode* temp1 = cur->next->next->next; // 记录临时节点

            cur->next = cur->next->next;    
            cur->next->next = temp;          
            cur->next->next->next = temp1;  

            cur = cur->next->next; // cur移动两位，准备下一轮交换
        }
        return dummyHead->next;



    }
};

复杂度分析

• 时间复杂度：O(n)，其中 n 是链表的节点数量。需要对每个节点进行更新指针的操作。

• 空间复杂度：O(1)

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

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

解题思路  

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

细节注意

强烈推荐Carl老师解题思路，太清晰了！

「代码随想录」双指针 | 删除链表的倒数第N个节点 - 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

1. fast首先走n + 1步 ，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的        上 一个节点（方便做删除操作）。要删除一个节点，必须找到该节点的前一个节点。

2.  定义fast指针和slow指针，初始值为虚拟头结点。

代码实现

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

Leetcode 160.链表相交

题目链接  160. 相交链表 - 力扣（LeetCode）

解题思路

设「第一个公共节点」为 node ，「链表 headA」的节点数量为a ，「链表 headB」的节点数量为 b ，「两链表的公共尾部」的节点数量为 c ，则有：

头节点 headA 到 node 前，共有 a−c 个节点；
头节点 headB 到 node 前，共有b−c 个节点；

指针 A 先遍历完链表 headA ，再开始遍历链表 headB ，当走到 node 时，共走步数为：a+(b−c)

指针 B 先遍历完链表 headB ，再开始遍历链表 headA ，当走到 node 时，共走步数为：b+(a−c)

如下式所示，此时指针 A , B 重合，并有两种情况：a+(b−c)=b+(a−c)

代码实现

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    
    if(headA==NULL||headB==NULL)
    {
        return NULL;
    }
    struct ListNode* a = headA;
    struct  ListNode* b = headB;
    while(a!=b)
    {
        a = a==NULL?headB:a->next;
        b = b==NULL?headA:b->next;
    }
    return a;
    
}