链表1

Author: realJaydenCheng

2.data_structure/2.linked_list.md

@@ -4,14 +4,14 @@
 
 链表相关的核心点
 
-- null/nil 异常处理
-- dummy node 哑巴节点
-- 快慢指针
+- null/nil 异常处理，多写点None的分支没事的；
+- dummy node 哑节点：避免处理head导致的问题，反正最后返回就是返回dummy.next；
+- 快慢指针，有时也会有三个指针的情况，比如反转链表。
 - 插入一个节点到排序链表
 - 从一个链表中移除一个节点
-- 翻转链表
+- 翻转链表：不好搞了就创一个新的链表从头开始，只操作头节点。链表问题搞不清楚都可以这么思考；
 - 合并两个链表
-- 找到链表的中间节点
+- 找到链表的中间节点。
 
 ## 常见题型
 
@@ -72,16 +72,39 @@ class Solution:
         return dummy.next
 ```
 
-注意点
-• A->B->C 删除 B，A.next = C
-• 删除用一个 Dummy Node 节点辅助（允许头节点可变）
-• 访问 X.next 、X.value 一定要保证 X != nil
+注意点：
+
+- A->B->C 删除 B，A.next = C
+- 删除用一个 Dummy Node 节点辅助（允许头节点可变）
+- 访问 X.next 、X.value 一定要保证 X != nil
 
 ### [reverse-linked-list](https://leetcode-cn.com/problems/reverse-linked-list/)
 
 > 反转一个单链表。
 
-- 思路：将当前结点放置到头结点
+- 思路：将当前结点放置到头结点，新创一个链表，把原来链表中的节点一个一个挪过去。
+- 注意：`next_ = curr.next`步骤，没有这一步的话，`cur.next`会在`dummy_new_head.next = dummy_old_head`的操作中被修改掉。
+- 上面的解法是下面解法的更清晰的版本。
+
+```python
+    def reverseListI(self, head: Optional[ListNode]) -> Optional[ListNode]:
+
+        dummy = ListNode()
+        curr = head
+
+        while curr:
+
+            next_ = curr.next
+            
+            dummy_old_head = dummy.next
+            dummy.next = curr
+            dummy_new_head = dummy.next
+            dummy_new_head.next = dummy_old_head
+
+            curr = next_
+
+        return dummy.next
+```
 
 ```Python
 class Solution:
@@ -100,7 +123,9 @@ class Solution:
 
         return head
 ```
+
 - Recursive method is tricky
+
 ```Python
 class Solution:
     def reverseList(self, head: ListNode) -> ListNode:
@@ -147,7 +172,7 @@ class Solution:
 
 ### [merge-two-sorted-lists](https://leetcode-cn.com/problems/merge-two-sorted-lists/)
 
-> 将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
+> 将两个升序链表合并为一个新的升序链表并返回。**新链表**是通过拼接给定的两个链表的所有节点组成的。
 
 - 思路：通过 dummy node 链表，连接各个元素
 
@@ -177,27 +202,31 @@ class Solution:
 
 > 给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于  *x*  的节点都在大于或等于  *x*  的节点之前。
 
-- 思路：将大于 x 的节点，放到另外一个链表，最后连接这两个链表
+- 思路：将大于 x 的节点，放到另外一个链表，最后连接这两个链表。
+- 注意：依然是注意curr.next = None，切断和原来链表的链接，避免成环，导致超时和爆内存（无限循环）。
 
-```go
+```python
 class Solution:
-    def partition(self, head: ListNode, x: int) -> ListNode:
-        
-        p = l = ListNode()
-        q = s = ListNode(next=head)
-        
-        while q.next is not None:
-            if q.next.val < x:
-                q = q.next
+    def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:
+
+        gt_dummy, lt_dummy = ListNode(), ListNode()
+        gt_curr, lt_curr = gt_dummy, lt_dummy
+
+        curr = head
+        while curr:
+            next_ = curr.next
+            curr.next = None
+            if curr.val < x:
+                lt_curr.next = curr
+                lt_curr = lt_curr.next
             else:
-                p.next = q.next
-                q.next = q.next.next
-                p = p.next
-        
-        p.next = None
-        q.next = l.next
-        
-	return s.next
+                gt_curr.next = curr
+                gt_curr = gt_curr.next
+            curr = next_
+
+        lt_curr.next = gt_dummy.next
+
+        return lt_dummy.next
 ```
 
 哑巴节点使用场景