链表

Author: realJaydenCheng

2.data_structure/2.linked_list.md

@@ -6,7 +6,7 @@
 
 - null/nil 异常处理，多写点None的分支没事的；
 - dummy node 哑节点：避免处理head导致的问题，反正最后返回就是返回dummy.next；
-- 快慢指针，有时也会有三个指针的情况，比如反转链表。
+- 快慢指针，比如找中点。有时也会有三个指针的情况，比如反转链表。
 - 插入一个节点到排序链表
 - 从一个链表中移除一个节点
 - 翻转链表：不好搞了就创一个新的链表从头开始，只操作头节点。链表问题搞不清楚都可以这么思考；
@@ -296,44 +296,46 @@ class Solution:
 > 将其重新排列后变为： *L*→*L\_\_n*→*L*→*L\_\_n*→*L*→*L\_\_n*→…
 
 - 思路：找到中点断开，翻转后面部分，然后合并前后两个链表
+- 注意点：快慢指针，翻转链表，合并链表，前面几道题目的组合
+- 拿到题目时不要慌，纸上推一下，就会发现动的是后面一半的节点，不要被题目示意图迷惑。
 
 ```Python
 class Solution:
-    
-    def reverseList(self, head: ListNode) -> ListNode:
-        
-        prev, curr = None, head
-        
-        while curr is not None:
-            curr.next, prev, curr = prev, curr, curr.next
-            
-        return prev
-    
-    def reorderList(self, head: ListNode) -> None:
+    def reorderList(self, head: Optional[ListNode]) -> None:
         """
         Do not return anything, modify head in-place instead.
         """
-        if head is None or head.next is None or head.next.next is None:
+        if head is None or head.next is None:
             return
 
         slow, fast = head, head.next
-        while fast is not None and fast.next is not None:
-            fast = fast.next.next
+        while fast and fast.next:
             slow = slow.next
-        
-        h, m = head, slow.next
+            fast = fast.next.next
+        mid = slow.next
         slow.next = None
-        
-        m = self.reverseList(m)
-        
-        while h is not None and m is not None:
-            p = m.next
-            m.next = h.next
-            h.next = m
-            h = h.next.next
-            m = p
-            
-        return
+
+        dummy = ListNode()
+        curr = mid
+        while curr:
+            curr_next = curr.next
+            curr.next = None
+            old_dummy_head = dummy.next
+            new_dummy_head = curr
+            dummy.next = new_dummy_head
+            new_dummy_head.next = old_dummy_head
+            curr = curr_next
+
+        curr = dummy.next
+        pointer = head
+        while curr:
+            curr_next = curr.next
+            curr.next = None
+            pointer_next = pointer.next
+            pointer.next = curr
+            curr.next = pointer_next
+            curr = curr_next
+            pointer = pointer_next
 ```
 
 ### [linked-list-cycle](https://leetcode-cn.com/problems/linked-list-cycle/)
@@ -342,7 +344,7 @@ class Solution:
 
 - 思路1：Hash Table 记录所有结点判断重复，空间复杂度 O(n) 非最优，时间复杂度 O(n) 但必然需要 n 次循环
 - 思路2：快慢指针，快慢指针相同则有环，证明：如果有环每走一步快慢指针距离会减 1，空间复杂度 O(1) 最优，时间复杂度 O(n) 但循环次数小于等于 n
-  ![fast_slow_linked_list](https://img.fuiboom.com/img/fast_slow_linked_list.png)
+  - 另一种理解方法：快慢指针进入环中，必然会相遇，相遇就是有环。
 
 ```Python
 class Solution:
@@ -352,7 +354,7 @@ class Solution:
 
         while fast is not None and fast.next is not None:
             slow = slow.next
-	    fast = fast.next.next
+            fast = fast.next.next
             if fast == slow:
                 return True
 
@@ -364,6 +366,7 @@ class Solution:
 > 给定一个链表，返回链表开始入环的第一个节点。  如果链表无环，则返回  `null`。
 
 - 思路：快慢指针，快慢相遇之后，慢指针回到头，快慢指针步调一致一起移动，相遇点即为入环点。
+- 为什么呢？因为快指针每次移动 2 步，慢指针每次移动 1 步，所以快指针走过的路程是慢指针的 2 倍，所以快指针走过的路程为慢指针的 2 倍时，快慢指针相遇。
 
 ![cycled_linked_list](https://img.fuiboom.com/img/cycled_linked_list.png)
 
@@ -387,13 +390,14 @@ class Solution:
         return None
 ```
 
-坑点
+坑点：
 
-- 指针比较时直接比较对象，不要用值比较，链表中有可能存在重复值情况
-- 第一次相交后，快指针需要从下一个节点开始和头指针一起匀速移动
+1. 指针比较时直接比较对象，不要用值比较，链表中有可能存在重复值情况
+2. 第一次相交后，快指针需要从下一个节点开始和头指针一起匀速移动
 
+**注意**：*找中点和找环的快慢指针起始不一样*
 
-注意，此题中使用 slow = fast = head 是为了保证最后找环起始点时移动步数相同，但是作为找中点使用时**一般用 fast=head.Next 较多**，因为这样可以知道中点的上一个节点，可以用来删除等操作。
+此题中使用 slow = fast = head 是为了保证最后找环起始点时移动步数相同，但是作为找中点使用时**一般用 fast=head.Next 较多**，因为这样可以知道中点的上一个节点，可以用来删除等操作。
 
 - fast 如果初始化为 head.Next 则中点在 slow.Next
 - fast 初始化为 head,则中点在 slow
@@ -402,7 +406,17 @@ class Solution:
 
 > 请判断一个链表是否为回文链表。
 
-- 思路：O(1) 空间复杂度的解法需要破坏原链表（找中点 -> 反转后半个list -> 判断回文），在实际应用中往往还需要复原（后半个list再反转一次后拼接），操作比较复杂，这里给出更工程化的做法
+- 思路：O(1) 空间复杂度的解法需要破坏原链表
+  - 找中点 -> 反转后半个list -> 判断回文
+  - 在实际应用中往往还需要复原（后半个list再反转一次后拼接）
+  - 操作比较复杂
+- 这里给出更工程化的做法：
+  - 利用到栈结构
+  - 找中点时在栈中记录节点值
+  - 然后遍历后半部分链表，借用栈的先进后出刚好反着判断
+  - 注意 fast is not None 情况，这表明链表长度为奇数，slow 指针需要再走一步
+  - 反正是注意检查链表的奇偶情况
+  - 这种方法虽然不会破坏链表，但空间复杂度为 O(n/2)
 
 ```Python
 class Solution:
@@ -432,66 +446,68 @@ class Solution:
 > 要求返回这个链表的 深拷贝。
 
 - 思路1：hash table 存储 random 指针的连接关系
+  - 对于python这种解释性语言，可以在原始节点对象上，直接利用属性存储random链接信息
 
 ```Python
 class Solution:
-    def copyRandomList(self, head: 'Node') -> 'Node':
-        
-        if head is None:
-            return None
-        
-        parent = collections.defaultdict(list)
-        
-        out = Node(0)
-        o, n = head, out
-        while o is not None:
-            n.next = Node(o.val)
-            n = n.next
-            if o.random is not None:
-                parent[o.random].append(n)
-            o = o.next
-            
-        o, n = head, out.next
-        while o is not None:
-            if o in parent:
-                for p in parent[o]:
-                    p.random = n
-            o = o.next
-            n = n.next
-        
-        return out.next
+    def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
+        dummy = Node(x=-1)
+        old_curr, new_curr = head, dummy
+        while old_curr:
+            new_node = Node(x=old_curr.val)
+            new_curr.next = new_node
+            old_curr.new = new_node
+            old_curr = old_curr.next
+            new_curr = new_curr.next
+
+        old_curr, new_curr = head, dummy.next
+        while old_curr:
+            old_random = old_curr.random
+            if old_random:
+                new_curr.random = old_random.new
+            else:
+                new_curr.random = None
+            old_curr = old_curr.next
+            new_curr = new_curr.next
+
+        return dummy.next
 ```
 
 - 思路2：复制结点跟在原结点后面，间接维护连接关系，优化空间复杂度，建立好新 list 的 random 链接后分离
+  - 三次遍历：复制节点、建立 random 链接、分离新 list
+  - 注意：复制节点时维护好原来的 next 指针，避免混乱
 
 ```Python
 class Solution:
-    def copyRandomList(self, head: 'Node') -> 'Node':
-        
-        if head is None:
+    def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
+
+        if not head:
             return None
 
-        p = head
-        while p is not None:
-            p.next = Node(p.val, p.next)
-            p = p.next.next
-        
-        p = head
-        while p is not None:
-            if p.random is not None:
-                p.next.random = p.random.next
-            p = p.next.next
-        
-        new = head.next
-        o, n = head, new
-        while n.next is not None:
-            o.next = n.next
-            n.next = n.next.next
-            o = o.next
-            n = n.next
-        o.next = None
-        
-        return new
+        old_curr = head
+        while old_curr:
+            old_next = old_curr.next
+            old_curr.next = Node(
+                x=old_curr.val,
+                next=old_curr.next,
+            )
+            old_curr = old_next
+        
+        old_curr = head
+        while old_curr:
+            new_curr = old_curr.next
+            if old_curr.random:
+                new_curr.random = old_curr.random.next
+            old_curr = new_curr.next
+        
+        new_head = new_curr = head.next
+        while new_curr:
+            old_curr = new_curr.next
+            if old_curr:
+                new_curr.next = old_curr.next
+            new_curr = new_curr.next
+
+        return new_head
 ```
 
 ## 总结