LeetCode:链表（三）

本组囊括链表相关题目，难度不等。

61. Rotate List

题目描述:中等

解法一：

官方题解：使用成环的思想，原链表连成环，再断开环和生成新链头和链尾即可；
首先将原链表的链头和链尾连接起来形成环，然后再n-k的节点后断开环，下一个节点n-k+1即是新的链表的链头，n-k是新链表的链尾。

上述考虑的是k<=n的情况，如果k>n呢：考虑k = (k//n) * n + k % n，将k写为两部分之和，前部分是向下取整，即是n的倍数，不对最终结果有影响，只需考虑后半部分即可。于是，我们把k统一写为k%n。

class Solution:
    def rotateRight(self, head: ListNode, k: int) -> ListNode:
       
        if not head:
            return None
        if not head.next:
            return head
        old_tail = head  # old_tail往后移动了，head不会移动仍在原位置
        n = 1
        while old_tail.next != None:
            old_tail = old_tail.next # 先将旧链链尾的下一个节点作为新链的链头
            n += 1  # 表长度n
        old_tail.next = head # 原链尾指向原链头，形成环
        new_head = head # 这句可要可不要
        for i in range( n - k % n - 1):# 从头走到新的链表尾来断开环
            head = head.next
        new_head = head.next # 找到新链表的头
        head.next = None # 再在旧链链尾断开环
        return new_head
        # 时间复杂度：O(N),先遍历一遍找链尾，在走n-k-1步。
        # 空间复杂度：O(1)

86. Partition List

题目描述：中等

解法一：

对于这个道题来说，比较直观的想法是将原链表的值分为两组（大于等于x和小于x）
分组后的两个小链表，连接起来即得到答案;
我们用两个指针来跟踪这两个链表，最后连接的时候要注意边界条件;

class Solution:
    def partition(self, head: ListNode, x: int) -> ListNode:
        before_head = ListNode(0) # 两个哑节点
        before = before_head      # 两个指针
        after_head = ListNode(0)
        after = after_head
        while head: # 遍历一遍链表
            if head.val < x: 
                before.next = head
                before = before.next
            else:
                after.next = head
                after = after.next
            head = head.next
        after.next = None # 这里需要手动实现断链，不然如果之前这个地方指向的下一个非空，就会形成环。
        before.next = after_head.next # 连接两个链表
        return before_head.next # 返回哑节点的下一个节点
        # 时间复杂度：O(N)
        # 空间复杂度：O(1),没有使用新的空间，原地移动链表

141. Linked List Cycle

题目描述：简单

解法一：

环的意思就是后面会不止一次碰到同一个节点；

思路就是希望通过一个类似表来记录已经走过的节点，若再次碰到这个节点，则返回true
首先想到的就是哈希表，通过哈希表来记录走过的节点；
用Python实现的话就是设置一个字典，键为走过的节点值，值设为任意数即可：

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
       
        hashmap = {}
        while head:
            if head in hashmap:
                return True
            else:
                hashmap[head] = 1
                head = head.next
        return False
        # 时间复杂度O(N),空间复杂度O(N) (额外的哈希表)

解法二：

进阶，在O(1)空间中解决： 使用双指针法，这里用快慢指针赛跑。
思路是什么呢，假设两个快慢指针在环形赛道上赛跑，快指针每次能跑两步而满指针每次能跑一步，这样下去，设环形长度为K，则快指针经过K次循环必定与满指针相遇；若快指针先跑到了尾部节点，则证明没有环形跑道。

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        if head == None or head.next == None:
            return False
        low, fast = ListNode(0), ListNode(0)
        low = head 
        fast = head.next  
        while fast and fast.next:  # 换一种写法也可以
            if fast == low:
                return True
            low = low.next
            fast = fast.next.next
        return False