两两交换链表中的结点&删除链表的倒数第N个节点 &

两两交换链表中的结点&删除链表的倒数第N个节点 &链表相交

23. 两两交换链表中的结点

力扣链接：https://leetcode.cn/problems/swap-nodes-in-pairs/

题目描述：

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

/**
 * 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) {
        if (head == nullptr || head->next == nullptr) return head;
        ListNode* L = new ListNode(); // 创建一个虚拟头结点
        ListNode* ppre = L;  // ppre指向pre之前一个元素
        ListNode* pre = head;
        ListNode* p = head->next;
        while (p != nullptr) { // 遍历链表中每一个结点
            ListNode* tmp = p->next; // 在结点交换时防止后续结点断链
            p->next = pre;
            pre->next = tmp;
            ppre->next = p;
            if (tmp != nullptr && tmp->next != nullptr) { // 判断后续是否仍然存在二个结点
                pre = tmp;
                p = tmp->next;
                ppre = ppre->next->next;
            } else {  // 若不存在直接返回处理的链表结果
                return L->next;
            }
        }
        return L->next;
    }
};

题解与总结：

• 两两交换链表中的结点，最简单的方式就是进行值的交换，但是题目明确要求不可以使用此方式进行；
• 首先判断链表中结点个数：0,1直接返回不用进行交换
• 使用二个指针分别指向二个待交换的结点，pre, p 结点交换还需要使用pre之前的一个元素，才能保证前面 的链表不断链，这就要考虑使用带有头结点的单链表;

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

力扣链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/

题目描述：

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

题解代码：

/**
 * 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* L = new ListNode(0, head);
        ListNode* p = head;
        ListNode* pre = L;
        while (n--) {
            p = p->next;
        }
        while (p != nullptr) {
            p = p->next;
            pre = pre->next;
        }
        pre->next = pre->next->next;
        return L->next;
    }
};

• 使用双指针，P指针在先走N步，pre, p 在同时向后移动
• 使用带有头结点的链表处理比较方便，单个元素进行删除

面试题02.07 链表相交

力扣链接：https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/submissions/

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

图示两个链表在节点 c1 开始相交：

题解代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int getLength(ListNode* head) {
        // 获取链表中元素个数
        ListNode* p = head;
        int count = 0;
        while (p != NULL) {
            count++;
            p = p->next;
        }
        return count;
    }
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int lengthA = getLength(headA);
        int lengthB = getLength(headB);
        ListNode* longList;
        ListNode* shortList;
        int step; // 记录长表与短表之间的差值
        if (lengthA >= lengthB) {
            longList = headA;
            shortList = headB;
            step = lengthA - lengthB;
        } else {
            longList = headB;
            shortList = headA;
            step = lengthB - lengthA; 
        }
        // 遍历指针
        ListNode* plong = longList;
        ListNode* pshort = shortList;
        // 将长表先向后移动step个结点
        while (step--) {
            plong = plong->next;
        }
        // 将长表与短表遍历指针同时向后移动
        while (pshort != NULL) {
            if (pshort == plong) return pshort;
            pshort = pshort->next;
            plong = plong->next;
        }
        return NULL;
    }
};

总结与反思：

• 解题思想：先分别计算二表的长度，计算差值step，将长表首先向后移动step步，然后同时移动二表的遍历指针，当遍历指针首次相同时即找到了交叉点