feat: update solutions to lc problems

Author: yanglbme

solution/0000-0099/0081.Search in Rotated Sorted Array II/README.md

@@ -55,7 +55,7 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-二分查找。
+**方法一：二分查找**
 
 <!-- tabs:start -->
 

solution/0000-0099/0083.Remove Duplicates from Sorted List/README.md

@@ -51,7 +51,7 @@
 #         self.val = val
 #         self.next = next
 class Solution:
-    def deleteDuplicates(self, head: ListNode) -> ListNode:
+    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
         cur = head
         while cur and cur.next:
             if cur.val == cur.next.val:
@@ -61,6 +61,25 @@ class Solution:
         return head
 ```
 
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        dummy = ListNode(1000)
+        cur = dummy
+        while head:
+            if head.val != cur.val:
+                cur.next = head
+                cur = cur.next
+            head = head.next
+        cur.next = None
+        return dummy.next
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->

solution/0000-0099/0083.Remove Duplicates from Sorted List/README_EN.md

@@ -43,7 +43,7 @@
 #         self.val = val
 #         self.next = next
 class Solution:
-    def deleteDuplicates(self, head: ListNode) -> ListNode:
+    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
         cur = head
         while cur and cur.next:
             if cur.val == cur.next.val:
@@ -53,6 +53,25 @@ class Solution:
         return head
 ```
 
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        dummy = ListNode(1000)
+        cur = dummy
+        while head:
+            if head.val != cur.val:
+                cur.next = head
+                cur = cur.next
+            head = head.next
+        cur.next = None
+        return dummy.next
+```
+
 ### **Java**
 
 ```java

solution/0000-0099/0086.Partition List/README.md

@@ -40,8 +40,12 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：模拟**
+
 创建两个链表，一个存放小于 `x` 的节点，另一个存放大于等于 `x` 的节点，之后进行拼接即可。
 
+时间复杂度 $O(n)，空间复杂度 $O(1)$。其中 $n$ 是原链表的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -55,7 +59,7 @@
 #         self.val = val
 #         self.next = next
 class Solution:
-    def partition(self, head: ListNode, x: int) -> ListNode:
+    def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:
         d1, d2 = ListNode(), ListNode()
         t1, t2 = d1, d2
         while head:

solution/0000-0099/0086.Partition List/README_EN.md

@@ -45,7 +45,7 @@
 #         self.val = val
 #         self.next = next
 class Solution:
-    def partition(self, head: ListNode, x: int) -> ListNode:
+    def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:
         d1, d2 = ListNode(), ListNode()
         t1, t2 = d1, d2
         while head:

solution/0000-0099/0086.Partition List/Solution.py

@@ -4,7 +4,7 @@
 #         self.val = val
 #         self.next = next
 class Solution:
-    def partition(self, head: ListNode, x: int) -> ListNode:
+    def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:
         d1, d2 = ListNode(), ListNode()
         t1, t2 = d1, d2
         while head:

solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README.md

@@ -42,14 +42,18 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-前序序列的第一个结点 `preorder[0]` 为根节点，我们在中序序列中找到根节点的位置 i，可以将中序序列划分为左子树 `inorder[:i]` 、右子树 `inorder[i+1:]`。
+**方法一：递归**
 
-通过左右子树的区间，可以计算出左、右子树节点的个数，假设为 m、n。然后在前序节点中，从根节点往后的 m 个节点为左子树，再往后的 n 个节点为右子树。
+前序序列的第一个结点 $preorder[0]$ 为根节点，我们在中序序列中找到根节点的位置 $i$，可以将中序序列划分为左子树 $inorder[0..i]$ 、右子树 $inorder[i+1..]$。
+
+通过左右子树的区间，可以计算出左、右子树节点的个数，假设为 $m$ 和 $n$。然后在前序节点中，从根节点往后的 $m$ 个节点为左子树，再往后的 $n$ 个节点为右子树。
 
 递归求解即可。
 
 > 前序遍历：先遍历根节点，再遍历左右子树；中序遍历：先遍历左子树，再遍历根节点，最后遍历右子树。
 
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。
+
 <!-- tabs:start -->
 
 ### **Python3**