Leetcode 876.141.142.143 环形链表 C++实现-CSDN博客

本文链接：https://blog.csdn.net/2301_77329667/article/details/141379402

问题：给你单链表的头结点 head ，请你找出并返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

、

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

算法：

快慢指针，快指针 fast 移动两个元素位置，慢指针 slow 移动一个元素位置。

当元素个数为奇数时，快指针 fast 指向最后一个结点时，慢指针 slow 正好位于中间结点处。

当元素个数为偶数时，快指针 fast 指向空时，慢指针 slow 正好位于第二个中间结点处。

代码：

struct ListNode* middleNode(struct ListNode* head){
    ListNode *fast=head,*slow=head;
    while(fast&&fast->next){
        slow=slow->next;
        fast=fast->next->next;
    }
    return slow;
}

Leetcode 141. 环形链表

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

如果链表中存在环，则返回 true 。否则，返回 false 。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

算法：

如果有环的话，那么慢指针 slow 和快指针 fast 都会进入环中。这时用相对速度思考，乌慢指针 slow 不动，快指针 fast 相对慢指针 slow 每次只走一步，这样就可以看出快指针 fast 一定会和慢指针 slow 相遇了。

代码：

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode *fast = head,*slow = head;
        while(fast && fast->next){
            slow = slow->next;
            fast = fast->next->next;
            if(fast == slow)    return true;
        }
        return false;
    }
};

Leetcode 142. 环形链表 II

问题：给定一个链表的头节点 head ，返回链表开始入环的第一个节点。如果链表无环，则返回 null。

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

不允许修改 链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

算法：

快慢指针，慢指针 slow 追上快指针 fast 时，慢指针 slow 一定没有走完一整圈，因为慢指针 slow 和快指针 fast 相对速度是 1 ，所以最坏情况是慢指针入环后再走环长度 - 1 的距离。

列出等式后可推得：从头结点 head 到环入口的距离 a - 慢指针 slow 入环后走的距离 c = n 倍的环长。

代码：

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *slow = head,*fast = head;
        while(fast && fast->next){
            slow = slow->next;
            fast = fast->next->next;
            if(fast == slow){// 快慢指针相遇
                while(slow != head){
                    slow = slow->next;
                    head = head->next;
                }
                return slow;
            }
        }
        return nullptr;
    }
};

Leetcode 143. 重排链表

问题：

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

L0 → L1 → … → Ln - 1 → Ln

请将其重新排列后变为：

L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …

不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

/**
 * 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) {}
 * };
 */

算法：先找到链表的中间结点 mid

反转后半段链表

代码：

class Solution {
    // 链表的中间结点
    ListNode *middleNode(ListNode *head) {
        ListNode *slow = head, *fast = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
    // 反转链表
    ListNode *reverseList(ListNode *head) {
        ListNode *pre = nullptr, *cur = head;
        while (cur) {
            ListNode *nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }

public:
    void reorderList(ListNode* head) {
        ListNode *mid = middleNode(head);// 找出中间结点 mid
        ListNode *head2 = reverseList(mid);// 反转后半段链表
        while(head2->next){
            ListNode *nxt = head->next,*nxt2 = head2->next;
            head->next = head2;
            head2->next = nxt;
            head = nxt;
            head2 = nxt2;
        }
    }
};