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

19.删除链表的倒数第N个节点
面试题 02.07. 链表相交
142.环形链表II
)

链表

链表

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

题目链接

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表，不修改节点内部的值

1. 先设虚拟头结点（头指针）指向head，使得头结点和中间结点操作相同

2. 交换相邻两个，涉及到前后两个，共4个，要用p->next，避免出现p已经是nullptr，还用p->next导致出现错误

3. 操作步骤
   

4. 为了防止因为更改next失掉连接关系，需要暂存指针，记录结点

代码

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

            p->next = p->next->next;    // STEP 1
            p->next->next = tmp1;       // STEP 2
            tmp1->next = tmp2;          // STEP 3

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

相关题目

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

题目链接

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

1. 经典的双指针法-快慢指针，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾，删掉slow所指向的节点
2. fast首先走n + 1步，同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作）
3. 判断条件但凡设计遍历指针的一定要注意有fast != NULL

代码

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;

        ListNode* fast = dummyHead;
        ListNode* slow = dummyHead;

        /*for (int i = 0; i < n + 1 && fast != NULL; i++)
            fast = fast->next;*/

        while (n-- && fast != NULL) {
            fast = fast->next;
        }
        fast = fast->next; // fast再提前走一步，因为需要让slow指向删除节点的上一个节点

        while (fast)
        {
            fast = fast->next;
            slow = slow->next;
        }

        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp;
        tmp = nullptr;

        return dummyHead->next;

    }
};

相关题目

面试题 02.07. 链表相交

题目链接

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null
整个链式结构中不存在环，函数返回结果后，链表必须保持其原始结构

1. 两个链表交点节点的指针,注意，交点不是数值相等，而是指针相等 ，p == q别写成p = q了。。。。。

		if (p == q) {
        	return p;

2. 求出两个链表的长度，并求出两个链表长度的差值，然后让p移动到，和q 末尾对齐的位置

		while (gap--) {
        	p = p->next;
    	}

3. 在 C++ 中，可以直接使用 std::swap() 函数，这是一个用于交换两个变量值的内置函数。它是定义在< algorithm > 头文件中的

		if (lenB > lenA) {
            swap(lenA, lenB);
            swap(p, q);
        }

代码

class Solution {
public:
    ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {

        ListNode* p = headA;
        ListNode* q = headB;
        int lenA = 0, lenB = 0;
        while (p != NULL) { // 求链表A的长度
            lenA++;
            p = p->next;
        }
        while (q != NULL) { // 求链表B的长度
            lenB++;
            q = q->next;
        }
        p = headA;
        q = headB;
        // 让A为最长链，lenA为其长度
        if (lenB > lenA) {
            swap(lenA, lenB);
            swap(p, q);
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让p和q在同一起点上（末尾位置对齐）
        while (gap--) {
            p = p->next;
        }
        // 遍历p 和 q，遇到相同则直接返回
        // 注意比较的是地址，而不是值
        while (p != NULL) {
            if (p == q) {
                return p;
            }
            p = p->next;
            q = q->next;
        }
        return NULL;

    }
};

总结

通过求长作差，长的先移动变短是两条链等长，然后一起后移，只到指针相等

相关题目

同：160.链表相交

142.环形链表II

题目链接

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

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

1. 判断链表是否有环
   使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环

2. 如果有环，找到这个环的入口
   假设从头结点到环形入口结点 的结点数为x。 环形入口节点到 fast指针与slow指针相遇结点 结点数为y。 从相遇结点 再到环形入口结点结点数为 z
   

计算过程：
相遇时： slow指针走过的结点数为: x + y， fast指针走过的结点数：
x + y + n (y + z)
fast指针走过的结点数 = slow指针走过的结点数 * 2：
(x + y) * 2 = x + y + n (y + z)
环形入口，x，x表示 头结点到 环形入口结点的的距离：
x = n (y + z) - y = (n - 1) (y + z) + z
这是寻找入口结点的关键所在，也就是说，当我们找到相遇结点时，分设两个指针从头结点，相遇结点同时出发，再次相遇即入口结点

3. 当slow进入环，fast在slow“后面”，fast速度是slow两倍，一定在slow走完第一个环时fast追上slow，fast相对于slow是一次移动一个节点，不可能跳过，定会相遇，因此slow指针走过的结点数为 x + y，而不是 x + k(y + z) + y
4. fast每次后移两个结点，判断结束条件fast != NULL && fast->next != NULL

代码

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，此时从head 和 相遇点，同时查找直至相遇
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }
};

总结

快慢指针，环内相遇，重新出发，相遇入口

相关题目