四、基础算法精讲：链表-快慢指针

路哞哞

已于 2023-10-31 09:32:49 修改

阅读量69

点赞数

分类专栏：算法笔记 2 文章标签：算法链表数据结构

于 2023-10-31 09:31:08 首次发布

本文链接：https://blog.csdn.net/qq_34696503/article/details/134132672

版权

算法笔记 2 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1、链表的中间结点

Leetcode 876

class Solution:
    def middleNode(self, head: Optional[ListNode]) -> Optional[ListNode]:
        slow = fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        return slow

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode *slow = head, *fast = head;
        while (fast && fast->next) 
            slow = slow->next, fast = fast->next->next;
        return slow;
    }
};

时间复杂度： $O (n)$
空间复杂度： $O (1)$

2、环形链表

Leetcode 141

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        slow = fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow is fast:
                return True
        return False

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

时间复杂度： $O (n)$
空间复杂度： $O (1)$

3、环形链表 II

Leetcode 142

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        fast = slow = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if fast is slow:
                while slow is not head:
                    slow = slow.next
                    head = head.next
                return slow
        return None

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;
    }
};

时间复杂度： $O (n)$
空间复杂度： $O (1)$

3、重排列表

Leetcode 143

class Solution:
    def middleNode(self, head: Optional[ListNode])->Optional[ListNode]:
        slow = fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        return slow

    def reverseList(self, head: Optional[ListNode])->Optional[ListNode]:
        pre, cur = None, head
        while cur:
            nxt = cur.next
            cur.next = pre
            pre = cur
            cur = nxt
        return pre

    def reorderList(self, head: Optional[ListNode]) -> None:
        mid = self.middleNode(head)
        head2 = self.reverseList(mid)
        while head2.next:
            nxt = head.next
            nxt2 = head2.next
            head.next = head2
            head2.next = nxt
            head = nxt
            head2 = nxt2

class Solution {
public:
    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;
    }

    void reorderList(ListNode* head) {
        ListNode *mid = middleNode(head);
        ListNode *head2 = reverseList(mid);
        while (head2->next) {
            ListNode *nxt = head->next, *nxt2 = head2->next;
            head->next = head2, head2->next = nxt;
            head = nxt, head2 = nxt2;
        }
    }   
};