feat: update solutions to lc/lcof problems (doocs#2861)

lcof/面试题06. 从尾到头打印链表/README.md

@@ -100,9 +100,11 @@ class Solution {
 class Solution {
 public:
     vector<int> reversePrint(ListNode* head) {
-        if (!head) return {};
-        vector<int> ans = reversePrint(head->next);
-        ans.push_back(head->val);
+        vector<int> ans;
+        for (; head; head = head->next) {
+            ans.push_back(head->val);
+        }
+        reverse(ans.begin(), ans.end());
         return ans;
     }
 };
@@ -145,11 +147,11 @@ func reversePrint(head *ListNode) (ans []int) {
  */
 
 function reversePrint(head: ListNode | null): number[] {
-    let ans: number[] = [];
-    for (; !!head; head = head.next) {
-        ans.unshift(head.val);
+    const ans: number[] = [];
+    for (; head; head = head.next) {
+        ans.push(head.val);
     }
-    return ans;
+    return ans.reverse();
 }
 ```
 
@@ -174,14 +176,14 @@ function reversePrint(head: ListNode | null): number[] {
 // }
 impl Solution {
     pub fn reverse_print(head: Option<Box<ListNode>>) -> Vec<i32> {
-        let mut arr: Vec<i32> = vec![];
+        let mut ans: Vec<i32> = vec![];
         let mut cur = head;
         while let Some(node) = cur {
-            arr.push(node.val);
+            ans.push(node.val);
             cur = node.next;
         }
-        arr.reverse();
-        arr
+        ans.reverse();
+        ans
     }
 }
 ```
@@ -191,21 +193,21 @@ impl Solution {
 ```js
 /**
  * Definition for singly-linked list.
- * function ListNode(val) {
- *     this.val = val;
- *     this.next = null;
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
  * }
  */
 /**
  * @param {ListNode} head
  * @return {number[]}
  */
 var reversePrint = function (head) {
-    let ans = [];
-    for (; !!head; head = head.next) {
-        ans.unshift(head.val);
+    const ans = [];
+    for (; head; head = head.next) {
+        ans.push(head.val);
     }
-    return ans;
+    return ans.reverse();
 };
 ```
 
@@ -217,20 +219,49 @@ var reversePrint = function (head) {
  * public class ListNode {
  *     public int val;
  *     public ListNode next;
- *     public ListNode(int x) { val = x; }
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
  * }
  */
- public class Solution {
-     public int[] ReversePrint(ListNode head) {
-         List<int> ans = new List<int>();
-         while (head != null) {
-             ans.Add(head.val);
-             head = head.next;
-         }
-         ans.Reverse();
-         return ans.ToArray();
-     }
- }
+public class Solution {
+    public int[] ReversePrint(ListNode head) {
+        List<int> ans = new List<int>();
+        for (; head != null; head = head.next) {
+            ans.Add(head.val);
+        }
+        ans.Reverse();
+        return ans.ToArray();
+    }
+}
+```
+
+#### Swift
+
+```swift
+/* public class ListNode {
+*    public var val: Int
+*    public var next: ListNode?
+*    public init(_ val: Int) {
+*        self.val = val
+*        self.next = nil
+*    }
+* }
+*/
+
+class Solution {
+    func reversePrint(_ head: ListNode?) -> [Int] {
+        var stack = [Int]()
+        var current = head
+        while let node = current {
+            stack.append(node.val)
+            current = node.next
+        }
+
+        return stack.reversed()
+    }
+}
 ```
 
 <!-- tabs:end -->
@@ -308,11 +339,11 @@ class Solution {
 class Solution {
 public:
     vector<int> reversePrint(ListNode* head) {
-        vector<int> ans;
-        for (; head; head = head->next) {
-            ans.push_back(head->val);
+        if (!head) {
+            return {};
         }
-        reverse(ans.begin(), ans.end());
+        vector<int> ans = reversePrint(head->next);
+        ans.push_back(head->val);
         return ans;
     }
 };
@@ -402,33 +433,6 @@ var reversePrint = function (head) {
 };
 ```
 
-#### Swift
-
-```swift
-/* public class ListNode {
-*    public var val: Int
-*    public var next: ListNode?
-*    public init(_ val: Int) {
-*        self.val = val
-*        self.next = nil
-*    }
-* }
-*/
-
-class Solution {
-    func reversePrint(_ head: ListNode?) -> [Int] {
-        var stack = [Int]()
-        var current = head
-        while let node = current {
-            stack.append(node.val)
-            current = node.next
-        }
-
-        return stack.reversed()
-    }
-}
-```
-
 <!-- tabs:end -->
 
 <!-- solution:end -->

lcof/面试题06. 从尾到头打印链表/Solution.cpp

@@ -9,9 +9,11 @@
 class Solution {
 public:
     vector<int> reversePrint(ListNode* head) {
-        if (!head) return {};
-        vector<int> ans = reversePrint(head->next);
-        ans.push_back(head->val);
+        vector<int> ans;
+        for (; head; head = head->next) {
+            ans.push_back(head->val);
+        }
+        reverse(ans.begin(), ans.end());
         return ans;
     }
 };

lcof/面试题06. 从尾到头打印链表/Solution.cs

@@ -3,17 +3,19 @@
  * public class ListNode {
  *     public int val;
  *     public ListNode next;
- *     public ListNode(int x) { val = x; }
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
  * }
  */
- public class Solution {
-     public int[] ReversePrint(ListNode head) {
-         List<int> ans = new List<int>();
-         while (head != null) {
-             ans.Add(head.val);
-             head = head.next;
-         }
-         ans.Reverse();
-         return ans.ToArray();
-     }
- }
+public class Solution {
+    public int[] ReversePrint(ListNode head) {
+        List<int> ans = new List<int>();
+        for (; head != null; head = head.next) {
+            ans.Add(head.val);
+        }
+        ans.Reverse();
+        return ans.ToArray();
+    }
+}

lcof/面试题06. 从尾到头打印链表/Solution.js

@@ -1,18 +1,18 @@
 /**
  * Definition for singly-linked list.
- * function ListNode(val) {
- *     this.val = val;
- *     this.next = null;
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
  * }
  */
 /**
  * @param {ListNode} head
  * @return {number[]}
  */
 var reversePrint = function (head) {
-    let ans = [];
-    for (; !!head; head = head.next) {
-        ans.unshift(head.val);
+    const ans = [];
+    for (; head; head = head.next) {
+        ans.push(head.val);
     }
-    return ans;
+    return ans.reverse();
 };

lcof/面试题06. 从尾到头打印链表/Solution.rs

@@ -16,13 +16,13 @@
 // }
 impl Solution {
     pub fn reverse_print(head: Option<Box<ListNode>>) -> Vec<i32> {
-        let mut arr: Vec<i32> = vec![];
+        let mut ans: Vec<i32> = vec![];
         let mut cur = head;
         while let Some(node) = cur {
-            arr.push(node.val);
+            ans.push(node.val);
             cur = node.next;
         }
-        arr.reverse();
-        arr
+        ans.reverse();
+        ans
     }
 }

lcof/面试题06. 从尾到头打印链表/Solution.ts

@@ -11,9 +11,9 @@
  */
 
 function reversePrint(head: ListNode | null): number[] {
-    let ans: number[] = [];
-    for (; !!head; head = head.next) {
-        ans.unshift(head.val);
+    const ans: number[] = [];
+    for (; head; head = head.next) {
+        ans.push(head.val);
     }
-    return ans;
+    return ans.reverse();
 }

lcof/面试题06. 从尾到头打印链表/Solution2.cpp

@@ -9,11 +9,11 @@
 class Solution {
 public:
     vector<int> reversePrint(ListNode* head) {
-        vector<int> ans;
-        for (; head; head = head->next) {
-            ans.push_back(head->val);
+        if (!head) {
+            return {};
         }
-        reverse(ans.begin(), ans.end());
+        vector<int> ans = reversePrint(head->next);
+        ans.push_back(head->val);
         return ans;
     }
 };

lcof/面试题11. 旋转数组的最小数字/README.md

@@ -52,8 +52,6 @@ edit_url: https://github.com/doocs/leetcode/edit/main/lcof/%E9%9D%A2%E8%AF%95%E9
 
 时间复杂度 $(\log n)$，空间复杂度 $O(1)$。其中 $n$ 为数组长度。
 
-注意，我们也可以每次取中间元素 `numbers[mid]` 与左端元素 `numbers[l]` 比较，但需要考虑当前 $[l,..r]$ 区间内的元素是否已经有序，即是否满足 `numbers[l] < numbers[r]`，如果满足，直接返回 `numbers[l]` 即可。其它情况与上述方法类似。
-
 <!-- tabs:start -->
 
 #### Python3
@@ -234,7 +232,9 @@ class Solution {
 
 <!-- solution:start-->
 
-### 方法二
+### 方法二：二分查找（写法二）
+
+注意，我们也可以每次取中间元素 `numbers[mid]` 与左端元素 `numbers[l]` 比较，但需要考虑当前 $[l,..r]$ 区间内的元素是否已经有序，即是否满足 `numbers[l] < numbers[r]`，如果满足，直接返回 `numbers[l]` 即可。其它情况与方法一类似。
 
 <!-- tabs:start -->