【C++代码】两两交换链表中的节点，删除链表的倒数第 N 个结点，链表相交，环形链表 II--代码随想录

最新推荐文章于 2024-05-19 12:01:11 发布

羞儿

最新推荐文章于 2024-05-19 12:01:11 发布

阅读量687

点赞数 1

分类专栏：啃书《C++Primer5 文章标签： c++ 链表开发语言

本文链接：https://blog.csdn.net/weixin_43424450/article/details/132517346

版权

啃书《C++Primer5 专栏收录该内容

37 篇文章 2 订阅

订阅专栏

题目：两两交换链表中的节点

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

题解

这道题目正常模拟就可以了。建议使用虚拟头结点，这样会方便很多，要不然每次针对头结点（没有前一个指针指向头结点），还要单独处理。交换相邻两个元素了，此时一定要画图，不画图，操作多个指针很容易乱，而且要操作的先后顺序。初始时，cur指向虚拟头结点，然后进行如下三步：
- 操作之后，链表如下：
- ```
/**
 * 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* virtualHead=new ListNode(0);
        virtualHead->next=head;
        ListNode* in_ptr=virtualHead;
        while(in_ptr->next!=nullptr && in_ptr->next->next!=nullptr){
            ListNode* left= in_ptr->next;
            ListNode* right=in_ptr->next->next->next;
            in_ptr->next = left->next;
            in_ptr->next->next=left;
            in_ptr->next->next->next=right;
            in_ptr = in_ptr->next->next;
        }
        return virtualHead->next;
    }
};
```
- 创建虚拟头结点 virtualHead，令 virtualHead.next = head。令 left 表示当前到达的节点，初始时 left = virtualHead。每次需要交换 left 后面的两个节点。
- 如果 left 的后面没有节点或者只有一个节点，则没有更多的节点需要交换，因此结束交换。否则，获得 left 后面的两个节点 node1 和 node2，通过更新节点的指针关系实现两两交换节点。
- 具体而言，交换之前的节点关系是 left -> node1 -> node2，交换之后的节点关系要变成 left -> node2 -> node1，因此需要进行如下操作。
- ```
temp.next = node2
node1.next = node2.next
node2.next = node1
```
- 完成上述操作之后，节点关系即变成 left -> node2 -> node1。再令 left = node1，对链表中的其余节点进行两两交换，直到全部节点都被两两交换。两两交换链表中的节点之后，新的链表的头节点是 virtualHead.next，返回新的链表的头节点即可。
- 时间复杂度：O(n)，其中 n 是链表的节点数量。需要对每个节点进行更新指针的操作。空间复杂度：O(1)。

题目：删除链表的倒数第 N 个结点

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

题解

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

首先这里我推荐大家使用虚拟头结点，这样方便处理删除实际头结点的逻辑;
定义fast指针和slow指针，初始值为虚拟头结点，如图：
fast首先走n + 1步，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作），如图：
fast和slow同时移动，直到fast指向末尾

/**
 * 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* virtualHead = new ListNode(0);
        virtualHead->next = head;
        ListNode* left = virtualHead;
        ListNode* right = virtualHead;
        while(n-- && right!=NULL){
            right=right->next;
        }
        right = right->next;
        while(right){
            right = right->next;
            left = left->next;
        }
        // left->next = left->next->next;
        ListNode* wait_del = left->next;
        left->next = wait_del->next;
        delete wait_del;
        return virtualHead->next;
    }
};

时间复杂度：O(L)，其中 L 是链表的长度。空间复杂度：O(1)。

题目：链表相交

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

题解

简单来说，就是求两个链表交点节点的指针。这里要注意，交点不是数值相等，而是指针相等。
只有当链表 headA 和 headB 都不为空时，两个链表才可能相交。因此首先判断链表 headA 和 headB 是否为空，如果其中至少有一个链表为空，则两个链表一定不相交，返回 null。面试题 02.07. 链表相交 - 力扣（LeetCode）
当链表 headA 和 headB 都不为空时，创建两个指针 pA 和 pB，初始时分别指向两个链表的头节点 headA 和 headB，然后将两个指针依次遍历两个链表的每个节点。具体做法如下：
- 每步操作需要同时更新指针 pA 和 pB。
- 如果指针 pA 不为空，则将指针 pA 移到下一个节点；如果指针 pB 不为空，则将指针 pB 移到下一个节点。
- 如果指针 pA 为空，则将指针 pA 移到链表 headB 的头节点；如果指针 pB 为空，则将指针 pB 移到链表 headA 的头节点。
- 当指针 pA 和 pB 指向同一个节点或者都为空时，返回它们指向的节点或者 null。
分析：考虑两种情况，第一种情况是两个链表相交，第二种情况是两个链表不相交。
- 两个链表相交：链表 headA 和 headB 的长度分别是 m 和 n。假设链表 headA 的不相交部分有 a 个节点，链表 headB 的不相交部分有 b 个节点，两个链表相交的部分有 c 个节点，则有 a+c=m，b+c=n。
  - 如果 a=b，则两个指针会同时到达两个链表相交的节点，此时返回相交的节点；
  - 如果 a≠b，则指针 pA 会遍历完链表 headA，指针 pB 会遍历完链表 head，两个指针不会同时到达链表的尾节点，然后指针 pA 移到链表 headB 的头节点，指针 pB 移到链表 headA 的头节点，然后两个指针继续移动，在指针 pA 移动了 a+c+b 次、指针 pB 移动了 b+c+a 次之后，两个指针会同时到达两个链表相交的节点，该节点也是两个指针第一次同时指向的节点，此时返回相交的节点。
- 两个链表不相交：链表 headA 和 headB 的长度分别是 m 和 n。考虑当 m=n 和 m≠n 时，两个指针分别会如何移动：
  - 如果 m=n，则两个指针会同时到达两个链表的尾节点，然后同时变成空值 null，此时返回 null；
  - 如果 m≠n，则由于两个链表没有公共节点，两个指针也不会同时到达两个链表的尾节点，因此两个指针都会遍历完两个链表，在指针 pA 移动了 m+n 次、指针 pB 移动了 n+m 次之后，两个指针会同时变成空值 null，此时返回 null。

/**
 * 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) {
        if(headA==nullptr||headB==nullptr)
            return nullptr;
        ListNode* pA=headA;
        ListNode* pB=headB;
        while(pA!=pB){
            pA=pA==nullptr?headB:pA->next;
            pB=pB==nullptr?headA:pB->next;
        }
        return pA;
    }
};

时间复杂度：O(m+n)，其中 m 和 n 是分别是链表 headA 和 headB 的长度。两个指针同时遍历两个链表，每个指针遍历两个链表各一次。空间复杂度：O(1)。

题目：环形链表 II

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。如果链表无环，则返回 null。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

题解

可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇，说明这个链表有环。
为什么fast 走两个节点，slow走一个节点，有环的话，一定会在环内相遇呢，而不是永远的错开呢
- 这是因为fast是走两步，slow是走一步，其实相对于slow来说，fast是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合。
如果有环，如何找到这个环的入口
- 假设从头结点到环形入口节点的节点数为x。环形入口节点到 fast指针与slow指针相遇节点节点数为y。从相遇节点再到环形入口节点节点数为 z。代码随想录 (programmercarl.com) 如图所示：
- 那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针，（y+z）为一圈内节点的个数A。
- 因为fast指针是一步走两个节点，slow指针一步走一个节点，所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：
  - $z)\\$
  - 两边消掉一个（x+y）: x + y = n (y + z);因为要找环形的入口，那么要求的是x，因为x表示头结点到环形入口节点的的距离。所以要求x ，将x单独放在左面：x = n (y + z) - y ,再从n(y+z)中提出一个（y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。
  - 当 n为1的时候，公式就化解为 x = z，这就意味着，从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点，那么当这两个指针相遇的时候就是环形入口的节点。
  - 也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。让index1和index2同时移动，每次移动一个节点，那么他们相遇的地方就是环形入口的节点。

/**
 * 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* left = head;
        ListNode* right =head;
        while(right!=NULL && right->next!=NULL){
            right = right->next->next;
            left = left->next;
            if(left==right){
                ListNode* temp1 = left;
                ListNode* temp2 = head;
                while(temp1!=temp2){
                    temp1 = temp1->next;
                    temp2 = temp2->next;
                }
                return temp2;
            }
        }
        return NULL;
    }
};

时间复杂度 O(N)：第二次相遇中，慢指针须走步数 a<a+b；第一次相遇中，慢指针须走步数 a+b−x<a+b，其中 xxx 为双指针重合点与环入口距离；因此总体为线性复杂度；空间复杂度 O(1) ：双指针使用常数大小的额外空间。

羞儿

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【C++代码】两两交换链表中的节点，删除链表的倒数第 N 个结点，链表相交，环形链表 II--代码随想录

如果 m≠n，则由于两个链表没有公共节点，两个指针也不会同时到达两个链表的尾节点，因此两个指针都会遍历完两个链表，在指针 pA 移动了 m+n 次、指针 pB 移动了 n+m 次之后，两个指针会同时变成空值 null，此时返回 null。假设链表 headA 的不相交部分有 a 个节点，链表 headB 的不相交部分有 b 个节点，两个链表相交的部分有 c 个节点，则有 a+c=m，b+c=n。否则，获得 left 后面的两个节点 node1 和 node2，通过更新节点的指针关系实现两两交换节点。
复制链接

扫一扫