update

Author: jasoncao11

51. 环形链表.md

@@ -23,4 +23,21 @@ class Solution:
             slow = slow.next
             fast = fast.next.next
         return True
+```
+
+```
+class Solution(object):
+    def hasCycle(self, head):
+        """
+        :type head: ListNode
+        :rtype: bool
+        """
+
+        slow = fast = head
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+            if slow == fast:
+                return True
+        return False
 ```

87. 环形链表 II.md

@@ -0,0 +1,29 @@
+***给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。***
+
+```
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def detectCycle(self, head: ListNode) -> ListNode:
+        slow = fast = head
+        flag = False
+        while fast and fast.next:
+            fast = fast.next.next
+            slow = slow.next
+            if fast == slow:
+                flag = True
+                break
+        if not flag:
+            return None
+
+        fast = head
+        while fast != slow:
+            fast = fast.next
+            slow = slow.next
+        
+        return fast
+```

88. 链表的中间结点.md

@@ -0,0 +1,16 @@
+***给定一个头结点为 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。***
+
+```
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def middleNode(self, head: ListNode) -> ListNode:
+        slow = fast = head
+        while fast and fast.next:
+            fast = fast.next.next
+            slow = slow.next
+        return slow
+```

89. 回文链表.md

@@ -0,0 +1,45 @@
+***给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。***
+
+```
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution(object):
+    def isPalindrome(self, head):
+        """
+        :type head: ListNode
+        :rtype: bool
+        """
+
+        if not head:
+            return False
+        if not head.next:
+            return True
+
+        # 用于找到中间点的指针
+        slow = head
+        fast = head
+        # 用于反转的指针
+        pre = None
+        cur = head
+
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+            cur.next = pre
+            pre = cur
+            cur = slow
+
+        #奇数情况
+        if fast:
+            slow = slow.next
+
+        while pre and slow:
+            if pre.val != slow.val:
+                return False
+            pre = pre.next
+            slow = slow.next
+        return True
+```

90. 从头到尾打印列表.md

@@ -0,0 +1,28 @@
+***输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。***
+
+```
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def reversePrint(self, head):
+        """
+        :type head: ListNode
+        :rtype: List[int]
+        """
+        #方法一：递归
+        if not head:
+            return []
+        rev = self.reversePrint(head.next)
+        rev.append(head.val)
+        return rev
+        #方法二
+        #res = []
+        #while head:
+        #    res.insert(0, head.val)
+        #    head = head.next
+        #return res
+```

91. 复杂链表的复制.md

@@ -0,0 +1,32 @@
+***请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。***
+
+![algo35](./images/algo35.jpg)
+
+```
+class Solution:
+    def copyRandomList(self, head: 'Node') -> 'Node':
+        if not head: return
+        cur = head
+        # 1. 复制各节点，并构建拼接链表
+        while cur:
+            tmp = Node(cur.val)
+            tmp.next = cur.next
+            cur.next = tmp
+            cur = tmp.next
+        # 2. 构建各新节点的 random 指向
+        cur = head
+        while cur:
+            if cur.random:
+                cur.next.random = cur.random.next
+            cur = cur.next.next
+        # 3. 拆分两链表
+        cur = dummy = head.next
+        pre = head
+        while cur.next:
+            pre.next = pre.next.next
+            cur.next = cur.next.next
+            pre = pre.next
+            cur = cur.next
+        pre.next = None # 单独处理原链表尾节点
+        return dummy      # 返回新链表头节点
+```