Merge branch 'master' of https://github.com/azl397985856/leetcode

Author: lucifer

README.md

@@ -179,7 +179,7 @@ leetcode 题解，记录自己的 leetcode 解题之路。
 - [0086.partition-list](./problems/86.partition-list.md)
 - [0090.subsets-ii](./problems/90.subsets-ii.md)
 - [0091.decode-ways](./problems/91.decode-ways.md)
-- [0092.reverse-linked-list-ii](./problems/92.reverse-linked-list-ii.md)
+- [0092.reverse-linked-list-ii](./problems/92.reverse-linked-list-ii.md) 🖊
 - [0094.binary-tree-inorder-traversal](./problems/94.binary-tree-inorder-traversal.md)
 - [0095.unique-binary-search-trees-ii](./problems/95.unique-binary-search-trees-ii.md) 🆕
 - [0096.unique-binary-search-trees](./problems/96.unique-binary-search-trees.md) 🆕

problems/92.reverse-linked-list-ii.md

@@ -13,37 +13,101 @@ Output: 1->4->3->2->5->NULL
 
 ## 思路
 
-考虑取出需要反转的这一小段链表，反转完后再插入到原先的链表中。
+这道题和[206.reverse-linked-list](https://github.com/azl397985856/leetcode/blob/master/problems/206.reverse-linked-list.md) 有点类似，并且这道题是206的升级版。 让我们反转某一个区间，而不是整个链表，我们可以将206看作本题的特殊情况（special case）。
 
-以本题为例：
-
-变换的是2,3,4这三个点，那么我们可以先取出2，用front指针指向2，然后当取出3的时候，我们把3加到2的前面，把front指针前移到3，依次类推，到4后停止，这样我们得到一个新链表4->3->2, front指针指向4。
+核心在于**取出需要反转的这一小段链表，反转完后再插入到原先的链表中。**
 
-对于原链表来说，有两个点的位置很重要，需要用指针记录下来，分别是1和5，把新链表插入的时候需要这两个点的位置。
+以本题为例：
 
-用pre指针记录1的位置
+反转的是2,3,4这三个点，那么我们可以先取出2，用cur指针指向2，然后当取出3的时候，我们将3指向2的，把cur指针前移到3，依次类推，到4后停止，这样我们得到一个新链表4->3->2, cur指针指向4。
 
-当4结点被取走后，5的位置需要记下来
+对于原链表来说，有两个点的位置很重要，需要用指针记录下来，分别是1和5，把新链表插入的时候需要这两个点的位置。用pre指针记录1的位置当4结点被取走后，5的位置需要记下来
 
-这样我们就可以把倒置后的那一小段链表加入到原链表中
+这样我们就可以把反转后的那一小段链表加入到原链表中
 
 ![92.reverse-linked-list-ii](../assets/92.reverse-linked-list-ii.gif)
 
 (图片来自： https://github.com/MisterBooo/LeetCodeAnimation)
-## 关键点解析
 
-- 链表的基本操作（交换）
-- 虚拟节点dummy 简化操作
-- 考虑特殊情况 m 是 1 或者 n是链表长度的情况
-- 用四个变量记录特殊节点， 然后操作这四个节点使之按照一定方式连接即可。
 
-```js
-    let midStartNode = null;
-    let preMidStartNode = null;
-    let midEndNode = null;
-    let postMidEndNode = null;
+首先我们直接返回head是不行的。 当 m 不等于1的时候是没有问题的，但只要 m 为1，就会有问题。
+
+```python
+class Solution:
+    def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
+        pre = None
+        cur = head
+        i = 0
+        p1 = p2 = p3 = p4 = None
+        # ...
+        if p1:
+            p1.next = p3
+        else:
+            dummy.next = p3
+        if p2:
+            p2.next = p4
+        return head
 ```
+   
+ 如上代码是不可以的，我们考虑使用dummy节点。
+ ```python
+ class Solution:
+    def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
+        pre = None
+        cur = head
+        i = 0
+        p1 = p2 = p3 = p4 = None
+        dummy = ListNode(0)
+        dummy.next = head
+
+        # ...
+
+        if p1:
+            p1.next = p3
+        else:
+            dummy.next = p3
+        if p2:
+            p2.next = p4
+
+        return dummy.next
+ ```
+ 
+ 关于链表反转部分, 顺序比较重要，我们需要：
+ 
+ - 先 cur.next = pre
+ - 再 更新p2和p2.next(其中要设置p2.next = None，否则会互相应用，造成无限循环)
+ - 最后更新 pre 和 cur
+ 
+ 上述的顺序不能错，不然会有问题。原因就在于`p2.next = None`，如果这个放在最后，那么我们的cur会提前断开。
+ 
+ ```python
+     while cur:
+            i += 1
+            if i == m - 1:
+                p1 = cur
+            next = cur.next
+            if m < i <= n:
+                cur.next = pre
+
+            if i == m:
+                p2 = cur
+                p2.next = None
+
+            if i == n:
+                p3 = cur
+
+            if i == n + 1:
+                p4 = cur
+
+            pre = cur
+            cur = next
+ ```
 
+## 关键点解析
+
+- 链表的基本操作
+- 考虑特殊情况 m 是 1 或者 n是链表长度的情况，我们可以采用虚拟节点dummy 简化操作
+- 用四个变量记录特殊节点， 然后操作这四个节点使之按照一定方式连接即可。
 - 注意更新current和pre的位置， 否则有可能出现溢出
 
 
@@ -60,24 +124,6 @@ JavaScript Code:
  * [92] Reverse Linked List II
  *
  * https://leetcode.com/problems/reverse-linked-list-ii/description/
- *
- * algorithms
- * Medium (34.13%)
- * Total Accepted:    182.3K
- * Total Submissions: 532.8K
- * Testcase Example:  '[1,2,3,4,5]\n2\n4'
- *
- * Reverse a linked list from position m to n. Do it in one-pass.
- * 
- * Note: 1 ≤ m ≤ n ≤ length of list.
- * 
- * Example:
- * 
- * 
- * Input: 1->2->3->4->5->NULL, m = 2, n = 4
- * Output: 1->4->3->2->5->NULL
- * 
- * 
  */
 /**
  * Definition for singly-linked list.
@@ -98,49 +144,46 @@ var reverseBetween = function(head, m, n) {
         next: head
     }
 
-    let current = dummyHead.next; // 当前遍历的节点
-    let pre = current; // 因为要反转，因此我们需要记住前一个节点
+    let cur = dummyHead.next; // 当前遍历的节点
+    let pre = cur; // 因为要反转，因此我们需要记住前一个节点
     let index = 0; // 链表索引，用来判断是否是特殊位置（头尾位置）
 
     // 上面提到的四个特殊节点
-    let midStartNode = null;
-    let preMidStartNode = null;
-    let midEndNode = null;
-    let postMidEndNode = null;
+    let p1 = p2 = p3 = p4 = null
 
-    while(current) {
-        const next = current.next;
+    while(cur) {
+        const next = cur.next;
         index++;
 
         // 对 (m - n) 范围内的节点进行反转
         if (index > m && index <= n) {           
-            current.next = pre;
+            cur.next = pre;
         }
 
         // 下面四个if都是边界, 用于更新四个特殊节点的值
         if (index === m - 1) {
-            preMidStartNode = current;
+            p1 = cur;
         }
         if (index === m) {
-            midStartNode = current;
+            p2 = cur;
         }
 
-        if (index === n + 1) {
-            postMidEndNode = current;
+        if (index === n) {
+            p3 = cur;
         }
 
-        if (index === n) {
-            midEndNode = current;;
+        if (index === n + 1) {
+            p4 = cur;;
         }
 
-        pre = current;
+        pre = cur;
 
-        current = next;
+        cur = next;
     }
 
     // 两个链表合并起来
-    (preMidStartNode || dummyHead).next = midEndNode; // 特殊情况需要考虑
-    midStartNode.next = postMidEndNode;
+    (p1 || dummyHead).next = p3; // 特殊情况需要考虑
+    p2.next = p4;
 
     return dummyHead.next;
 };