循环链表与快慢指针以及链表的转置

今天学习的内容之一是循环链表与快慢指针。

初始化：

将slow、fast 指向head结点

更新规则是：慢指针走一步，快指针走两步

slow = slow.next,fast = fast.next.next

由于链表里有环，则有以下几点结论

1、快慢指针必定在某个结点相遇（下文称为相遇结点）

推导：

试想一下，因为链表有环，是不存在结点指向None的情况，所以快慢指针会一直在环里走动。

假设慢指针进入链表的环的时候，快指针与慢指针之间的距离m步。

此时继续按照规则更新，则两者相差m-1步。

直到两者距离相差0步，即相遇了。

 

2、如果快慢指针同时在相遇结点同时出发，则在下一次相遇的结点时，将快指针走过的步数减去慢指针的步数便可以得出环长度。

 

3、在头结点和相遇结点同时开始，每次往前走一步，两个结点相遇时，便是环的入口结点。

设：入口结点为p，相遇结点为q，两者相距m步，问题则是：求头结点head到入口结点p的距离a

s = a + m

 

注意：当慢指针进入环之后，两者相遇的步数必定小于len。也就是说，慢指针还没走完一圈就会被追上。

2s = a + m + k * len（k为快指针绕环的圈数，len为环的长度）

可得：

a = k * len - m

相遇结点位置是：a + m

相遇结点到入口结点的距离就应该是：len - m 即 a

所以相遇结点和头结点到入口结点的距离都是a，依照这个特性即可得出答案。

 

下面这道题，可以利用第三点结论解出：（LeetCode上的142题）

示例 1：

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

示例 2：

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

示例 3：

输入：head = [1], pos = -1
输出：no cycle
解释：链表中没有环。

 

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

class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        slow,fast,iscircle = head,head,0
        while slow and fast:#判断这个链表是否有环，这是利用了循环链表中快慢指针必相遇的特点
            if slow.next != None and fast.next != None and fast.next.next != None:
                slow,fast = slow.next,fast.next.next
            else:
                break
            if slow == fast:
                iscircle = 1
                break
            
        
        if not iscircle:
            return None
        else:
            fast = head#利用第三点，得出答案
            while fast != slow:
                fast = fast.next
                slow = slow.next
            return fast

还有一种解法，没有用到快慢指针，可以参考：

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

class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        p = head
        s = set()#建立一个元组（dict或者list其实也行。dict和set速度差不多，list就稍慢一点）
        while p:
            if p in s:#如果结点已经存在在了元组里，就将p返回
                return p
            s.add(p)#记录所有遍历过的结点
            p = p.next
        return None

 

另一个学习的内容是转置链表。

关于转置链表，有很多方法，有复杂的，有简单的。

我想我这么懒的人肯定是学简单的就好了。

LeetCode 206 题

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

链表转置我会写有空头结点的，但是不会写没有空头结点的

所以我决定给它加个头结点23333

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

class Solution:
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head == None or head.next == None:return head
        n = ListNode(0)#加头
        n.next = head
        head = n
        p,q = head.next,head.next.next
        while q:#头插法逆置单链表
            p.next = q.next
            q.next = head.next
            head.next = q
            q = p.next
        
        return head.next#去头即可食用。呸呸呸，去头即可返回。

有点慢呐。。

后来看了看大佬做的 

 

对不起，是在下太蠢了。