【leetcode】链表问题

题目1

【简单】环形链表

给定一个链表，判断链表中是否有环。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

 

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

 

 

解答

快慢双指针，可以有效的减少空间复杂度和时间复杂度的匹配次数

首先，由于链表是个环，所以相遇的过程可以看作是快指针从后边追赶慢指针的过程。那么做如下思考：
1：快指针与慢指针之间差一步。此时继续往后走，慢指针前进一步，快指针前进两步，两者相遇。
2：快指针与慢指针之间差两步。此时继续往后走，慢指针前进一步，快指针前进两步，两者之间相差一步，转化为第一种情况。
3：快指针与慢指针之间差N步。此时继续往后走，慢指针前进一步，快指针前进两步，两者之间相差(N+1-2)-> N-1步。

因此，此题得证。所以快指针必然与慢指针相遇。又因为快指针速度是慢指针的两倍，所以相遇时必然只绕了一圈。

上述解释来自链接：https://www.zhihu.com/question/23208893/answer/117115415
 

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        # 快慢双指针追赶碰撞解法，时间复杂度为O（n）,空间复杂度为O（1）
        if not head:
            return head
        slow = head
        quick = head
        while quick and slow:
            # 这里因为quick是跳两次，所以要判断quick和quick.next是否都为空，否则会报NoneType的异常
            slow = slow.next
            if quick.next:
                quick = quick.next.next
            else:
                return False
            if quick is slow:
                return True
        return False

快慢指针的用途：

1、判断链表中的环（如上题所示）

2、找中间值

一般的思路是：先遍历一次链表，记录住一共有多少个节点，然后，再次遍历找寻中点。

利用快慢指针，我们来看看这个问题会变成什么样。思路如下：我们把一个链表看成一个跑道，假设a的速度是b的两倍，那么当a跑完全程后，b刚好跑一半，以此来达到找到中间节点的目的。

如下图，最开始，slow与fast指针都指向链表第一个节点，然后slow每次移动一个指针，fast每次移动两个指针。

3、删除倒数第n个节点

删除倒数第n个节点，那就等于是要我们先找出待删除元素前一个元素，也就是第n-1个节点。聪明的你肯定发现了，我们又把这个问题转化为找链表上的某个节点的问题了，这是快慢指针最擅长的场景。

那如何找第(n-1)个元素呢？我们一开始就让fast指针比slow指针快n+1个元素，接下来，两个指针都是一步一步来往下走。那么当fast指针走完时，slow指针就刚刚好停留在第(n-1)个元素上。

以下图解了n=2时的情形（其中dummyHead是我们手动加上去的虚拟头节点）：

 

题目2

【简单】回文链表

编写一个函数，检查输入的链表是否是回文的。

 

示例 1：

输入： 1->2
输出： false

示例 2：

输入： 1->2->2->1
输出： true

 

进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

 

解答

1. 快慢指针遍历到链表中间，快指针走两步、慢指针走一步，最后慢指针的位置就是链表中间
2. 从中间开始反转链表后半段
3. 从原链表头和反转后的链表头开始比较 value

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def isPalindrome(self, head):
        if not head: 
            return True
        slow = head
        fast = head

        # slow 遍历到中间，最后 slow 停的位置是 n/2+1
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        
        # 然后从 slow 开始反转链表
        # 如果是奇数，多出来的一个节点不用管了
        pre = slow
        while slow and slow.next:
            tmp = slow.next.next
            slow.next.next = pre
            pre = slow.next
            slow.next = tmp

        # 反转后的头结点是 pre，从 pre 和 head 开始比较 val
        while head and pre:
            if head.val != pre.val:
                return False
            head = head.next
            pre = pre.next
        
        return True


# 链接：https://leetcode-cn.com/problems/palindrome-linked-list-lcci/solution/shuang-zhi-zhen-fan-zhuan-lian-biao-python-by-yuyi/

 

 

【参考】

链表中快慢指针的妙用