fix: update

yanglbme · yanglbme · commit bfe2363f7262 · 2024-09-20T15:47:51.000+08:00
diff --git a/solution/3200-3299/3294.Convert Doubly Linked List to Array II/README.md b/solution/3200-3299/3294.Convert Doubly Linked List to Array II/README.md
@@ -77,13 +77,12 @@ class Node:
 
 class Solution:
     def toArray(self, node: "Optional[Node]") -> List[int]:
-        cur = node
-        while cur and cur.prev:
-            cur = cur.prev
+        while node.prev:
+            node = node.prev
         ans = []
-        while cur:
-            ans.append(cur.val)
-            cur = cur.next
+        while node:
+            ans.append(node.val)
+            node = node.next
         return ans
 ```
 
@@ -101,14 +100,12 @@ class Node {
 
 class Solution {
     public int[] toArray(Node node) {
-        var cur = node;
-        while (cur != null && cur.prev != null) {
-            cur = cur.prev;
+        while (node != null && node.prev != null) {
+            node = node.prev;
         }
         var ans = new ArrayList<Integer>();
-        while (cur != null) {
-            ans.add(cur.val);
-            cur = cur.next;
+        for (; node != null; node = node.next) {
+            ans.add(node.val);
         }
         return ans.stream().mapToInt(i -> i).toArray();
     }
@@ -132,14 +129,12 @@ class Solution {
 class Solution {
 public:
     vector<int> toArray(Node* node) {
-        Node* cur = node;
-        while (cur && cur->prev) {
-            cur = cur->prev;
+        while (node && node->prev) {
+            node = node->prev;
         }
         vector<int> ans;
-        while (cur) {
-            ans.push_back(cur->val);
-            cur = cur->next;
+        for (; node; node = node->next) {
+            ans.push_back(node->val);
         }
         return ans;
     }
@@ -159,13 +154,11 @@ public:
  */
 
 func toArray(node *Node) (ans []int) {
-	cur := node
-	for cur != nil && cur.Prev != nil {
-		cur = cur.Prev
+	for node != nil && node.Prev != nil {
+		node = node.Prev
 	}
-	for cur != nil {
-		ans = append(ans, cur.Val)
-		cur = cur.Next
+	for ; node != nil; node = node.Next {
+		ans = append(ans, node.Val)
 	}
 	return
 }
@@ -190,14 +183,12 @@ func toArray(node *Node) (ans []int) {
  */
 
 function toArray(node: _Node | null): number[] {
-    let cur = node;
-    while (cur && cur.prev) {
-        cur = cur.prev;
+    while (node && node.prev) {
+        node = node.prev;
     }
     const ans: number[] = [];
-    while (cur) {
-        ans.push(cur.val);
-        cur = cur.next;
+    for (; node; node = node.next) {
+        ans.push(node.val);
     }
     return ans;
 }
diff --git a/solution/3200-3299/3294.Convert Doubly Linked List to Array II/README_EN.md b/solution/3200-3299/3294.Convert Doubly Linked List to Array II/README_EN.md
@@ -75,13 +75,12 @@ class Node:
 
 class Solution:
     def toArray(self, node: "Optional[Node]") -> List[int]:
-        cur = node
-        while cur and cur.prev:
-            cur = cur.prev
+        while node.prev:
+            node = node.prev
         ans = []
-        while cur:
-            ans.append(cur.val)
-            cur = cur.next
+        while node:
+            ans.append(node.val)
+            node = node.next
         return ans
 ```
 
@@ -99,14 +98,12 @@ class Node {
 
 class Solution {
     public int[] toArray(Node node) {
-        var cur = node;
-        while (cur != null && cur.prev != null) {
-            cur = cur.prev;
+        while (node != null && node.prev != null) {
+            node = node.prev;
         }
         var ans = new ArrayList<Integer>();
-        while (cur != null) {
-            ans.add(cur.val);
-            cur = cur.next;
+        for (; node != null; node = node.next) {
+            ans.add(node.val);
         }
         return ans.stream().mapToInt(i -> i).toArray();
     }
@@ -130,14 +127,12 @@ class Solution {
 class Solution {
 public:
     vector<int> toArray(Node* node) {
-        Node* cur = node;
-        while (cur && cur->prev) {
-            cur = cur->prev;
+        while (node && node->prev) {
+            node = node->prev;
         }
         vector<int> ans;
-        while (cur) {
-            ans.push_back(cur->val);
-            cur = cur->next;
+        for (; node; node = node->next) {
+            ans.push_back(node->val);
         }
         return ans;
     }
@@ -157,13 +152,11 @@ public:
  */
 
 func toArray(node *Node) (ans []int) {
-	cur := node
-	for cur != nil && cur.Prev != nil {
-		cur = cur.Prev
+	for node != nil && node.Prev != nil {
+		node = node.Prev
 	}
-	for cur != nil {
-		ans = append(ans, cur.Val)
-		cur = cur.Next
+	for ; node != nil; node = node.Next {
+		ans = append(ans, node.Val)
 	}
 	return
 }
@@ -188,14 +181,12 @@ func toArray(node *Node) (ans []int) {
  */
 
 function toArray(node: _Node | null): number[] {
-    let cur = node;
-    while (cur && cur.prev) {
-        cur = cur.prev;
+    while (node && node.prev) {
+        node = node.prev;
     }
     const ans: number[] = [];
-    while (cur) {
-        ans.push(cur.val);
-        cur = cur.next;
+    for (; node; node = node.next) {
+        ans.push(node.val);
     }
     return ans;
 }
diff --git a/solution/3200-3299/3294.Convert Doubly Linked List to Array II/Solution.cpp b/solution/3200-3299/3294.Convert Doubly Linked List to Array II/Solution.cpp
@@ -12,14 +12,12 @@
 class Solution {
 public:
     vector<int> toArray(Node* node) {
-        Node* cur = node;
-        while (cur && cur->prev) {
-            cur = cur->prev;
+        while (node && node->prev) {
+            node = node->prev;
         }
         vector<int> ans;
-        while (cur) {
-            ans.push_back(cur->val);
-            cur = cur->next;
+        for (; node; node = node->next) {
+            ans.push_back(node->val);
         }
         return ans;
     }
diff --git a/solution/3200-3299/3294.Convert Doubly Linked List to Array II/Solution.go b/solution/3200-3299/3294.Convert Doubly Linked List to Array II/Solution.go
@@ -8,13 +8,11 @@
  */
 
 func toArray(node *Node) (ans []int) {
-	cur := node
-	for cur != nil && cur.Prev != nil {
-		cur = cur.Prev
+	for node != nil && node.Prev != nil {
+		node = node.Prev
 	}
-	for cur != nil {
-		ans = append(ans, cur.Val)
-		cur = cur.Next
+	for ; node != nil; node = node.Next {
+		ans = append(ans, node.Val)
 	}
 	return
 }
diff --git a/solution/3200-3299/3294.Convert Doubly Linked List to Array II/Solution.java b/solution/3200-3299/3294.Convert Doubly Linked List to Array II/Solution.java
@@ -9,14 +9,12 @@ class Node {
 
 class Solution {
     public int[] toArray(Node node) {
-        var cur = node;
-        while (cur != null && cur.prev != null) {
-            cur = cur.prev;
+        while (node != null && node.prev != null) {
+            node = node.prev;
         }
         var ans = new ArrayList<Integer>();
-        while (cur != null) {
-            ans.add(cur.val);
-            cur = cur.next;
+        for (; node != null; node = node.next) {
+            ans.add(node.val);
         }
         return ans.stream().mapToInt(i -> i).toArray();
     }
diff --git a/solution/3200-3299/3294.Convert Doubly Linked List to Array II/Solution.py b/solution/3200-3299/3294.Convert Doubly Linked List to Array II/Solution.py
@@ -10,11 +10,10 @@ def __init__(self, val, prev=None, next=None):
 
 class Solution:
     def toArray(self, node: "Optional[Node]") -> List[int]:
-        cur = node
-        while cur and cur.prev:
-            cur = cur.prev
+        while node.prev:
+            node = node.prev
         ans = []
-        while cur:
-            ans.append(cur.val)
-            cur = cur.next
+        while node:
+            ans.append(node.val)
+            node = node.next
         return ans
diff --git a/solution/3200-3299/3294.Convert Doubly Linked List to Array II/Solution.ts b/solution/3200-3299/3294.Convert Doubly Linked List to Array II/Solution.ts
@@ -14,14 +14,12 @@
  */
 
 function toArray(node: _Node | null): number[] {
-    let cur = node;
-    while (cur && cur.prev) {
-        cur = cur.prev;
+    while (node && node.prev) {
+        node = node.prev;
     }
     const ans: number[] = [];
-    while (cur) {
-        ans.push(cur.val);
-        cur = cur.next;
+    for (; node; node = node.next) {
+        ans.push(node.val);
     }
     return ans;
 }

Original file line number	Diff line number	Diff line change
`@@ -12,14 +12,12 @@`
`12`	`12`	`class Solution {`
`13`	`13`	`public:`
`14`	`14`	`vector<int> toArray(Node* node) {`
`15`		`- Node* cur = node;`
`16`		`- while (cur && cur->prev) {`
`17`		`- cur = cur->prev;`
	`15`	`+ while (node && node->prev) {`
	`16`	`+ node = node->prev;`
`18`	`17`	`}`
`19`	`18`	`vector<int> ans;`
`20`		`- while (cur) {`
`21`		`- ans.push_back(cur->val);`
`22`		`- cur = cur->next;`
	`19`	`+ for (; node; node = node->next) {`
	`20`	`+ ans.push_back(node->val);`
`23`	`21`	`}`
`24`	`22`	`return ans;`
`25`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,13 +8,11 @@`
`8`	`8`	`*/`
`9`	`9`
`10`	`10`	`func toArray(node *Node) (ans []int) {`
`11`		`- cur := node`
`12`		`- for cur != nil && cur.Prev != nil {`
`13`		`- cur = cur.Prev`
	`11`	`+ for node != nil && node.Prev != nil {`
	`12`	`+ node = node.Prev`
`14`	`13`	`}`
`15`		`- for cur != nil {`
`16`		`- ans = append(ans, cur.Val)`
`17`		`- cur = cur.Next`
	`14`	`+ for ; node != nil; node = node.Next {`
	`15`	`+ ans = append(ans, node.Val)`
`18`	`16`	`}`
`19`	`17`	`return`
`20`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,14 +9,12 @@ class Node {`
`9`	`9`
`10`	`10`	`class Solution {`
`11`	`11`	`public int[] toArray(Node node) {`
`12`		`- var cur = node;`
`13`		`- while (cur != null && cur.prev != null) {`
`14`		`- cur = cur.prev;`
	`12`	`+ while (node != null && node.prev != null) {`
	`13`	`+ node = node.prev;`
`15`	`14`	`}`
`16`	`15`	`var ans = new ArrayList<Integer>();`
`17`		`- while (cur != null) {`
`18`		`- ans.add(cur.val);`
`19`		`- cur = cur.next;`
	`16`	`+ for (; node != null; node = node.next) {`
	`17`	`+ ans.add(node.val);`
`20`	`18`	`}`
`21`	`19`	`return ans.stream().mapToInt(i -> i).toArray();`
`22`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,14 +14,12 @@`
`14`	`14`	`*/`
`15`	`15`
`16`	`16`	`function toArray(node: _Node \| null): number[] {`
`17`		`- let cur = node;`
`18`		`- while (cur && cur.prev) {`
`19`		`- cur = cur.prev;`
	`17`	`+ while (node && node.prev) {`
	`18`	`+ node = node.prev;`
`20`	`19`	`}`
`21`	`20`	`const ans: number[] = [];`
`22`		`- while (cur) {`
`23`		`- ans.push(cur.val);`
`24`		`- cur = cur.next;`
	`21`	`+ for (; node; node = node.next) {`
	`22`	`+ ans.push(node.val);`
`25`	`23`	`}`
`26`	`24`	`return ans;`
`27`	`25`	`}`