feat: add solutions to lc problem: No.143 (doocs#1350)

No.0143.Reorder List

Author: yanglbme

solution/0100-0199/0143.Reorder List/README.md

@@ -50,7 +50,11 @@ L<sub>0</sub> → L<sub>n</sub> → L<sub>1</sub> → L<sub>n - 1</sub> → L<su
 
 <!-- 这里可写通用的实现逻辑 -->
 
-先通过快慢指针找到链表中点，将链表划分为左右两部分。之后反转右半部分的链表，然后将左右两个链接依次连接即可。
+**方法一：快慢指针 + 反转链表 + 合并链表**
+
+我们先用快慢指针找到链表的中点，然后将链表的后半部分反转，最后将左右两个链表合并。
+
+时间复杂度 $O(n)$，其中 $n$ 是链表的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -65,17 +69,12 @@ L<sub>0</sub> → L<sub>n</sub> → L<sub>1</sub> → L<sub>n - 1</sub> → L<su
 #         self.val = val
 #         self.next = next
 class Solution:
-    def reorderList(self, head: ListNode) -> None:
-        """
-        Do not return anything, modify head in-place instead.
-        """
-        if head is None or head.next is None:
-            return
-
+    def reorderList(self, head: Optional[ListNode]) -> None:
         # 快慢指针找到链表中点
-        slow, fast = head, head.next
-        while fast and fast.next:
-            slow, fast = slow.next, fast.next.next
+        fast = slow = head
+        while fast.next and fast.next.next:
+            slow = slow.next
+            fast = fast.next.next
 
         # cur 指向右半部分链表
         cur = slow.next
@@ -88,8 +87,9 @@ class Solution:
             cur.next = pre
             pre, cur = cur, t
         cur = head
-        # 此时 cur, pre 分别指向链表左右两半的第一个节点
 
+        # 此时 cur, pre 分别指向链表左右两半的第一个节点
+        # 合并
         while pre:
             t = pre.next
             pre.next = cur.next
@@ -114,19 +114,18 @@ class Solution:
  */
 class Solution {
     public void reorderList(ListNode head) {
-        if (head == null || head.next == null) {
-            return;
-        }
-        ListNode slow = head;
-        ListNode fast = head.next;
-        while (fast != null && fast.next != null) {
+        // 快慢指针找到链表中点
+        ListNode fast = head, slow = head;
+        while (fast.next != null && fast.next.next != null) {
             slow = slow.next;
             fast = fast.next.next;
         }
 
+        // cur 指向右半部分链表
         ListNode cur = slow.next;
         slow.next = null;
 
+        // 反转右半部分链表
         ListNode pre = null;
         while (cur != null) {
             ListNode t = cur.next;
@@ -136,6 +135,8 @@ class Solution {
         }
         cur = head;
 
+        // 此时 cur, pre 分别指向链表左右两半的第一个节点
+        // 合并
         while (pre != null) {
             ListNode t = pre.next;
             pre.next = cur.next;
@@ -147,57 +148,55 @@ class Solution {
 }
 ```
 
-### **C#**
+### **C++**
 
-```cs
+```cpp
 /**
  * Definition for singly-linked list.
- * public class ListNode {
- *     public int val;
- *     public ListNode next;
- *     public ListNode(int val=0, ListNode next=null) {
- *         this.val = val;
- *         this.next = next;
- *     }
- * }
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
  */
-public class Solution {
-    public void ReorderList(ListNode head) {
-        if (head == null || head.next == null)
-        {
-            return;
-        }
-        ListNode slow = head;
-        ListNode fast = head.next;
-        while (fast != null && fast.next != null)
-        {
-            slow = slow.next;
-            fast = fast.next.next;
+class Solution {
+public:
+    void reorderList(ListNode* head) {
+        // 快慢指针找到链表中点
+        ListNode* fast = head;
+        ListNode* slow = head;
+        while (fast->next && fast->next->next) {
+            slow = slow->next;
+            fast = fast->next->next;
         }
 
-        ListNode cur = slow.next;
-        slow.next = null;
+        // cur 指向右半部分链表
+        ListNode* cur = slow->next;
+        slow->next = nullptr;
 
-        ListNode pre = null;
-        while (cur != null)
-        {
-            ListNode t = cur.next;
-            cur.next = pre;
+        // 反转右半部分链表
+        ListNode* pre = nullptr;
+        while (cur) {
+            ListNode* t = cur->next;
+            cur->next = pre;
             pre = cur;
             cur = t;
         }
         cur = head;
 
-        while (pre != null)
-        {
-            ListNode t = pre.next;
-            pre.next = cur.next;
-            cur.next = pre;
-            cur = pre.next;
+        // 此时 cur, pre 分别指向链表左右两半的第一个节点
+        // 合并
+        while (pre) {
+            ListNode* t = pre->next;
+            pre->next = cur->next;
+            cur->next = pre;
+            cur = pre->next;
             pre = t;
         }
     }
-}
+};
 ```
 
 ### **Go**
@@ -211,17 +210,17 @@ public class Solution {
  * }
  */
 func reorderList(head *ListNode) {
-	if head == nil || head.Next == nil {
-		return
-	}
-	slow, fast := head, head.Next
-	for fast != nil && fast.Next != nil {
+	// 快慢指针找到链表中点
+	fast, slow := head, head
+	for fast.Next != nil && fast.Next.Next != nil {
 		slow, fast = slow.Next, fast.Next.Next
 	}
 
+	// cur 指向右半部分链表
 	cur := slow.Next
 	slow.Next = nil
 
+	// 反转右半部分链表
 	var pre *ListNode
 	for cur != nil {
 		t := cur.Next
@@ -230,6 +229,8 @@ func reorderList(head *ListNode) {
 	}
 	cur = head
 
+	// 此时 cur, pre 分别指向链表左右两半的第一个节点
+	// 合并
 	for pre != nil {
 		t := pre.Next
 		pre.Next = cur.Next
@@ -254,19 +255,19 @@ func reorderList(head *ListNode) {
  * @return {void} Do not return anything, modify head in-place instead.
  */
 var reorderList = function (head) {
-    if (!head || !head.next) {
-        return;
-    }
+    // 快慢指针找到链表中点
     let slow = head;
-    let fast = head.next;
-    while (fast && fast.next) {
+    let fast = head;
+    while (fast.next && fast.next.next) {
         slow = slow.next;
         fast = fast.next.next;
     }
 
+    // cur 指向右半部分链表
     let cur = slow.next;
     slow.next = null;
 
+    // 反转右半部分链表
     let pre = null;
     while (cur) {
         const t = cur.next;
@@ -276,6 +277,8 @@ var reorderList = function (head) {
     }
     cur = head;
 
+    // 此时 cur, pre 分别指向链表左右两半的第一个节点
+    // 合并
     while (pre) {
         const t = pre.next;
         pre.next = cur.next;
@@ -286,6 +289,57 @@ var reorderList = function (head) {
 };
 ```
 
+### **C#**
+
+```cs
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    public void ReorderList(ListNode head) {
+        // 快慢指针找到链表中点
+        ListNode slow = head;
+        ListNode fast = head;
+        while (fast.next != null && fast.next.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+
+        // cur 指向右半部分链表
+        ListNode cur = slow.next;
+        slow.next = null;
+
+        // 反转右半部分链表
+        ListNode pre = null;
+        while (cur != null) {
+            ListNode t = cur.next;
+            cur.next = pre;
+            pre = cur;
+            cur = t;
+        }
+        cur = head;
+
+        // 此时 cur, pre 分别指向链表左右两半的第一个节点
+        // 合并
+        while (pre != null) {
+            ListNode t = pre.next;
+            pre.next = cur.next;
+            cur.next = pre;
+            cur = pre.next;
+            pre = t;
+        }
+    }
+}
+```
+
 ### **TypeScript**
 
 ```ts