Leetcode 876.141.142.143 环形链表 C++实现

Leetcode 876. 链表的中间结点

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

cpp 复制代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

算法:

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

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

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

代码:

cpp 复制代码
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

cpp 复制代码
/**
 * 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相遇了。

代码:

cpp 复制代码
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 不作为参数进行传递,仅仅是为了标识链表的实际情况。

不允许修改链表

cpp 复制代码
/**
 * 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 倍的环长

代码:

cpp 复制代码
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 → …

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

cpp 复制代码
/**
 * 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

反转后半段链表

代码:

cpp 复制代码
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;
        }
    }
};
相关推荐
沐怡旸8 分钟前
【算法】725.分割链表--通俗讲解
算法·面试
AI+程序员在路上1 小时前
QT6中Combo Box与Combo BoxFont 功能及用法
c++·qt
L_09071 小时前
【Algorithm】Day-4
c++·算法·leetcode
代码充电宝1 小时前
LeetCode 算法题【简单】20. 有效的括号
java·算法·leetcode·面试·职场和发展
海琴烟Sunshine2 小时前
leetcode 119. 杨辉三角 II python
算法·leetcode·职场和发展
小杨的全栈之路2 小时前
霍夫曼编码:数据压缩的核心算法详解(附图解 + 代码)
算法
cjinhuo2 小时前
标签页、书签太多找不到?AI 分组 + 拼音模糊搜索,开源插件秒解切换难题!
前端·算法·开源
贝塔实验室2 小时前
频偏估计方法--快速傅里叶变换(FFT)估计法
网络协议·算法·数学建模·动态规划·信息与通信·信号处理·傅立叶分析
煜3642 小时前
C++异常与智能指针
开发语言·c++
光头闪亮亮2 小时前
ZBar 环境搭建与快速入门指南
c++