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

Leetcode 24 两两交换链表中的节点
思路：使用虚拟头节点指向头节点，然后将虚拟头节点指向要交换的第二个数，然后将第二个数指向第一个数，第一个数指向第三个数，即1->2->3变为2->1->3，完成节点的交换。还要判断一下链表长度，奇数长度交换后还剩下一个节点，偶数长度交换后不剩下节点，指针的下一个节点为空。注意要保存交换的第一个节点与第三个节点的指针，防止节点交换导致指针顺序改变，找不到原来节点的指针

/**
 * 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* dummyHead = new ListNode(0); //创建一个虚拟头节点
        dummyHead->next = head; //虚拟头节点指向头节点
        ListNode* cur = dummyHead;
        while( cur->next != NULL && cur->next->next != NULL){
            ListNode* tmp = cur->next; //保存交换的第一个节点
            ListNode* tmp1 = cur->next->next->next; //保存下一次交换的第一个节点
            cur->next = cur->next->next;
            cur->next->next = tmp;
            cur->next->next->next = tmp1;
            cur = cur->next->next; //cur向后移动两个节点
        }
        return dummyHead->next; //返回头节点
    }
};

Leetcode 19 删除链表的倒数第N个节点
思路：使用双指针法，快指针先走n+1步，然后慢指针再走，慢指针与快指针的距离是n+1。然后慢指针和快指针同时移动，当快指针为空时，根据快慢指针距离，慢指针为倒数第n+1个节点，即被删除的节点的上一个节点，将慢指针指向被删除节点的下一个节点，然后释放被删除节点的内存，完成节点的删除操作

/**
 * 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(0);
        dummyHead->next = head;
        ListNode* fast = dummyHead;
        ListNode* slow = dummyHead; //定义快慢指针
        n++; //n+1 使快指针走n+1步
        while(n-- && fast != NULL){
            fast = fast->next;
        }
        while(fast != NULL){
            fast =fast->next;
            slow = slow->next; //快慢指针同时移动 退出循环时slow指向被删除节点的上一个节点
        }
        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp; //释放内存
        return dummyHead->next;
    }
};

Leetcode 面试题02.07.链表相交
思路：先使两个链表的临时指针对齐，即长链表的指针移动链表长度之差步，没对齐前短链表头节点之前没有指针，此时两链表不可能相交，相交即为指针相等，而不是数值相等

/**
 * 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; //链表A的临时指针
        ListNode* curB = headB;
        int lenA = 0, lenB = 0; //链表A和B的长度
        while(curA != NULL){
            lenA++;
            curA = curA->next;
        }
        while(curB != NULL){
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB; //让临时指针回到头节点
        if(lenB>lenA){ //让A链表长度最大
            swap(lenA, lenB);
            swap(curA,curB);
        }
        int gap = lenA - lenB; //链表长度差值
        while(gap--){
            curA = curA->next; //让curA和curB对齐
        }
        while(curA != NULL){
            if(curA==curB) //相交为指针相等
                return curA;
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};