链表

Author: realJaydenCheng

2.data_structure/2.linked_list.md

@@ -39,7 +39,7 @@ class Solution:
 
 ### [remove-duplicates-from-sorted-list-ii](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii/)
 
-> 给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中   没有重复出现的数字。
+> 给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现的数字。
 
 - 思路：链表头结点可能被删除，所以用 dummy node 辅助删除
 
@@ -142,7 +142,7 @@ class Solution:
 
 ### [reverse-linked-list-ii](https://leetcode-cn.com/problems/reverse-linked-list-ii/)
 
-> 反转从位置  *m*  到  *n*  的链表。请使用一趟扫描完成反转。
+> 反转从位置 *m* 到 *n* 的链表。请使用一趟扫描完成反转。
 
 - 思路：先找到 m 处, 再反转 n - m 次即可
 
@@ -229,55 +229,59 @@ class Solution:
         return lt_dummy.next
 ```
 
-哑巴节点使用场景
-
-> 当头节点不确定的时候，使用哑巴节点
+哑巴节点使用场景：当头节点不确定的时候，使用哑巴节点
 
 ### [sort-list](https://leetcode-cn.com/problems/sort-list/)
 
-> 在  *O*(*n* log *n*) 时间复杂度和常数级空间复杂度下，对链表进行排序。
+> 在 *O*(*n* log *n*) 时间复杂度和常数级空间复杂度下，对链表进行排序。
 
 - 思路：归并排序，slow-fast找中点
+- 为什么看不到排序就排序了？
+  - 因为递归到链表长度为 1 的时候，才会返回；
+  - 这时就是排序好的返回了，长度为2；
+  - 再到后面就是输入排序好的短链表，可以直接使用合并有序链表。
 
 ```Python
 class Solution:
-    
-    def _merge(self, l1, l2):
-        tail = l_merge = ListNode()
-        
-        while l1 is not None and l2 is not None:
-            if l1.val > l2.val:
-                tail.next = l2
-                l2 = l2.next
+
+    def _merge(self, head1: ListNode, head2: ListNode):
+        dummy = ListNode()
+        pointer = dummy
+        curr1, curr2 = head1, head2
+        while curr1 or curr2:
+            if curr1 is None:
+                pointer.next = curr2
+                curr2 = curr2.next
+            elif curr2 is None:
+                pointer.next = curr1
+                curr1 = curr1.next
             else:
-                tail.next = l1
-                l1 = l1.next
-            tail = tail.next
+                if curr1.val < curr2.val:
+                    pointer.next = curr1
+                    curr1 = curr1.next
+                else:
+                    pointer.next = curr2
+                    curr2 = curr2.next
+            pointer = pointer.next
+        return dummy.next
 
-        if l1 is not None:
-            tail.next = l1
-        else:
-            tail.next = l2
-        
-        return l_merge.next
-    
-    def _findmid(self, head):
+    def _find_mid(self, head: ListNode):
         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
-        
+            fast = fast.next.next
         return slow
-    
-    def sortList(self, head: ListNode) -> ListNode:
+
+    def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:
         if head is None or head.next is None:
             return head
-        
-        mid = self._findmid(head)
-        tail = mid.next
-        mid.next = None # break from middle
-        
-        return self._merge(self.sortList(head), self.sortList(tail))
+        mid = self._find_mid(head)
+        sub_head = mid.next
+        mid.next = None
+        return self._merge(
+            self.sortList(head),
+            self.sortList(sub_head),
+        )
 ```
 
 注意点