diff --git a/solution/0000-0099/0086.Partition List/README.md b/solution/0000-0099/0086.Partition List/README.md
index 3bf0d42492bbf..4408137d556fb 100644
--- a/solution/0000-0099/0086.Partition List/README.md
+++ b/solution/0000-0099/0086.Partition List/README.md
@@ -55,9 +55,9 @@ tags:
### 方法一：模拟
-我们创建两个链表，一个存放小于 $x$ 的节点，另一个存放大于等于 $x$ 的节点，之后进行拼接即可。
+我们创建两个链表 $l$ 和 $r$，一个用来存储小于 $x$ 的节点，另一个用来存储大于等于 $x$ 的节点。然后我们将它们拼接起来。
-时间复杂度 $O(n)，其中 $n$ 是原链表的长度。空间复杂度 $O(1)$。
+时间复杂度 $O(n)$，其中 $n$ 是原链表的长度。空间复杂度 $O(1)$。
<!-- tabs:start -->
@@ -71,19 +71,20 @@ tags:
# self.next = next
class Solution:
def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:
- d1, d2 = ListNode(), ListNode()
- t1, t2 = d1, d2
+ l = ListNode()
+ r = ListNode()
+ tl, tr = l, r
while head:
if head.val < x:
- t1.next = head
- t1 = t1.next
+ tl.next = head
+ tl = tl.next
else:
- t2.next = head
- t2 = t2.next
+ tr.next = head
+ tr = tr.next
head = head.next
- t1.next = d2.next
- t2.next = None
- return d1.next
+ tr.next = None
+ tl.next = r.next
+ return l.next
```
#### Java
@@ -101,22 +102,21 @@ class Solution:
*/
class Solution {
public ListNode partition(ListNode head, int x) {
- ListNode d1 = new ListNode();
- ListNode d2 = new ListNode();
- ListNode t1 = d1, t2 = d2;
- while (head != null) {
+ ListNode l = new ListNode();
+ ListNode r = new ListNode();
+ ListNode tl = l, tr = r;
+ for (; head != null; head = head.next) {
if (head.val < x) {
- t1.next = head;
- t1 = t1.next;
+ tl.next = head;
+ tl = tl.next;
} else {
- t2.next = head;
- t2 = t2.next;
+ tr.next = head;
+ tr = tr.next;
}
- head = head.next;
}
- t1.next = d2.next;
- t2.next = null;
- return d1.next;
+ tr.next = null;
+ tl.next = r.next;
+ return l.next;
}
}
```
@@ -137,23 +137,22 @@ class Solution {
class Solution {
public:
ListNode* partition(ListNode* head, int x) {
- ListNode* d1 = new ListNode();
- ListNode* d2 = new ListNode();
- ListNode* t1 = d1;
- ListNode* t2 = d2;
- while (head) {
+ ListNode* l = new ListNode();
+ ListNode* r = new ListNode();
+ ListNode* tl = l;
+ ListNode* tr = r;
+ for (; head; head = head->next) {
if (head->val < x) {
- t1->next = head;
- t1 = t1->next;
+ tl->next = head;
+ tl = tl->next;
} else {
- t2->next = head;
- t2 = t2->next;
+ tr->next = head;
+ tr = tr->next;
}
- head = head->next;
}
- t1->next = d2->next;
- t2->next = nullptr;
- return d1->next;
+ tr->next = nullptr;
+ tl->next = r->next;
+ return l->next;
}
};
```
@@ -169,21 +168,53 @@ public:
* }
*/
func partition(head *ListNode, x int) *ListNode {
- d1, d2 := &ListNode{}, &ListNode{}
- t1, t2 := d1, d2
- for head != nil {
+ l, r := &ListNode{}, &ListNode{}
+ tl, tr := l, r
+ for ; head != nil; head = head.Next {
if head.Val < x {
- t1.Next = head
- t1 = t1.Next
+ tl.Next = head
+ tl = tl.Next
} else {
- t2.Next = head
- t2 = t2.Next
+ tr.Next = head
+ tr = tr.Next
}
- head = head.Next
}
- t1.Next = d2.Next
- t2.Next = nil
- return d1.Next
+ tr.Next = nil
+ tl.Next = r.Next
+ return l.Next
+}
+```
+
+#### TypeScript
+
+```ts
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ * val: number
+ * next: ListNode | null
+ * constructor(val?: number, next?: ListNode | null) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.next = (next===undefined ? null : next)
+ * }
+ * }
+ */
+
+function partition(head: ListNode | null, x: number): ListNode | null {
+ const [l, r] = [new ListNode(), new ListNode()];
+ let [tl, tr] = [l, r];
+ for (; head; head = head.next) {
+ if (head.val < x) {
+ tl.next = head;
+ tl = tl.next;
+ } else {
+ tr.next = head;
+ tr = tr.next;
+ }
+ }
+ tr.next = null;
+ tl.next = r.next;
+ return l.next;
}
```
@@ -208,22 +239,24 @@ func partition(head *ListNode, x int) *ListNode {
// }
impl Solution {
pub fn partition(head: Option<Box<ListNode>>, x: i32) -> Option<Box<ListNode>> {
- let mut head = head;
- let mut d1 = Some(Box::new(ListNode::new(0)));
- let mut d2 = Some(Box::new(ListNode::new(0)));
- let (mut t1, mut t2) = (&mut d1, &mut d2);
- while let Some(mut node) = head {
- head = node.next.take();
+ let mut l = ListNode::new(0);
+ let mut r = ListNode::new(0);
+ let mut tl = &mut l;
+ let mut tr = &mut r;
+ let mut current = head;
+ while let Some(mut node) = current {
+ current = node.next.take();
if node.val < x {
- t1.as_mut().unwrap().next = Some(node);
- t1 = &mut t1.as_mut().unwrap().next;
+ tl.next = Some(node);
+ tl = tl.next.as_mut().unwrap();
} else {
- t2.as_mut().unwrap().next = Some(node);
- t2 = &mut t2.as_mut().unwrap().next;
+ tr.next = Some(node);
+ tr = tr.next.as_mut().unwrap();
}
}
- t1.as_mut().unwrap().next = d2.unwrap().next;
- d1.unwrap().next
+ tr.next = None;
+ tl.next = r.next;
+ l.next
}
}
```
@@ -244,26 +277,58 @@ impl Solution {
* @return {ListNode}
*/
var partition = function (head, x) {
- const d1 = new ListNode();
- const d2 = new ListNode();
- let t1 = d1,
- t2 = d2;
- while (head) {
+ const [l, r] = [new ListNode(), new ListNode()];
+ let [tl, tr] = [l, r];
+ for (; head; head = head.next) {
if (head.val < x) {
- t1.next = head;
- t1 = t1.next;
+ tl.next = head;
+ tl = tl.next;
} else {
- t2.next = head;
- t2 = t2.next;
+ tr.next = head;
+ tr = tr.next;
}
- head = head.next;
}
- t1.next = d2.next;
- t2.next = null;
- return d1.next;
+ tr.next = null;
+ tl.next = r.next;
+ return l.next;
};
```
+#### 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 ListNode Partition(ListNode head, int x) {
+ ListNode l = new ListNode();
+ ListNode r = new ListNode();
+ ListNode tl = l, tr = r;
+ for (; head != null; head = head.next) {
+ if (head.val < x) {
+ tl.next = head;
+ tl = tl.next;
+ } else {
+ tr.next = head;
+ tr = tr.next;
+ }
+ }
+ tr.next = null;
+ tl.next = r.next;
+ return l.next;
+ }
+}
+```
+
<!-- tabs:end -->
<!-- solution:end -->
diff --git a/solution/0000-0099/0086.Partition List/README_EN.md b/solution/0000-0099/0086.Partition List/README_EN.md
index a44e7933ee2f6..ee0bc4a48bd86 100644
--- a/solution/0000-0099/0086.Partition List/README_EN.md
+++ b/solution/0000-0099/0086.Partition List/README_EN.md
@@ -53,7 +53,7 @@ tags:
### Solution 1: Simulation
-We create two linked lists, one to store nodes less than $x$, and the other to store nodes greater than or equal to $x$. Then we concatenate them.
+We create two linked lists $l$ and $r$, one to store nodes less than $x$ and the other to store nodes greater than or equal to $x$. Then we concatenate them.
The time complexity is $O(n)$, where $n$ is the length of the original linked list. The space complexity is $O(1)$.
@@ -69,19 +69,20 @@ The time complexity is $O(n)$, where $n$ is the length of the original linked li
# self.next = next
class Solution:
def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:
- d1, d2 = ListNode(), ListNode()
- t1, t2 = d1, d2
+ l = ListNode()
+ r = ListNode()
+ tl, tr = l, r
while head:
if head.val < x:
- t1.next = head
- t1 = t1.next
+ tl.next = head
+ tl = tl.next
else:
- t2.next = head
- t2 = t2.next
+ tr.next = head
+ tr = tr.next
head = head.next
- t1.next = d2.next
- t2.next = None
- return d1.next
+ tr.next = None
+ tl.next = r.next
+ return l.next
```
#### Java
@@ -99,22 +100,21 @@ class Solution:
*/
class Solution {
public ListNode partition(ListNode head, int x) {
- ListNode d1 = new ListNode();
- ListNode d2 = new ListNode();
- ListNode t1 = d1, t2 = d2;
- while (head != null) {
+ ListNode l = new ListNode();
+ ListNode r = new ListNode();
+ ListNode tl = l, tr = r;
+ for (; head != null; head = head.next) {
if (head.val < x) {
- t1.next = head;
- t1 = t1.next;
+ tl.next = head;
+ tl = tl.next;
} else {
- t2.next = head;
- t2 = t2.next;
+ tr.next = head;
+ tr = tr.next;
}
- head = head.next;
}
- t1.next = d2.next;
- t2.next = null;
- return d1.next;
+ tr.next = null;
+ tl.next = r.next;
+ return l.next;
}
}
```
@@ -135,23 +135,22 @@ class Solution {
class Solution {
public:
ListNode* partition(ListNode* head, int x) {
- ListNode* d1 = new ListNode();
- ListNode* d2 = new ListNode();
- ListNode* t1 = d1;
- ListNode* t2 = d2;
- while (head) {
+ ListNode* l = new ListNode();
+ ListNode* r = new ListNode();
+ ListNode* tl = l;
+ ListNode* tr = r;
+ for (; head; head = head->next) {
if (head->val < x) {
- t1->next = head;
- t1 = t1->next;
+ tl->next = head;
+ tl = tl->next;
} else {
- t2->next = head;
- t2 = t2->next;
+ tr->next = head;
+ tr = tr->next;
}
- head = head->next;
}
- t1->next = d2->next;
- t2->next = nullptr;
- return d1->next;
+ tr->next = nullptr;
+ tl->next = r->next;
+ return l->next;
}
};
```
@@ -167,21 +166,53 @@ public:
* }
*/
func partition(head *ListNode, x int) *ListNode {
- d1, d2 := &ListNode{}, &ListNode{}
- t1, t2 := d1, d2
- for head != nil {
+ l, r := &ListNode{}, &ListNode{}
+ tl, tr := l, r
+ for ; head != nil; head = head.Next {
if head.Val < x {
- t1.Next = head
- t1 = t1.Next
+ tl.Next = head
+ tl = tl.Next
} else {
- t2.Next = head
- t2 = t2.Next
+ tr.Next = head
+ tr = tr.Next
}
- head = head.Next
}
- t1.Next = d2.Next
- t2.Next = nil
- return d1.Next
+ tr.Next = nil
+ tl.Next = r.Next
+ return l.Next
+}
+```
+
+#### TypeScript
+
+```ts
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ * val: number
+ * next: ListNode | null
+ * constructor(val?: number, next?: ListNode | null) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.next = (next===undefined ? null : next)
+ * }
+ * }
+ */
+
+function partition(head: ListNode | null, x: number): ListNode | null {
+ const [l, r] = [new ListNode(), new ListNode()];
+ let [tl, tr] = [l, r];
+ for (; head; head = head.next) {
+ if (head.val < x) {
+ tl.next = head;
+ tl = tl.next;
+ } else {
+ tr.next = head;
+ tr = tr.next;
+ }
+ }
+ tr.next = null;
+ tl.next = r.next;
+ return l.next;
}
```
@@ -206,22 +237,24 @@ func partition(head *ListNode, x int) *ListNode {
// }
impl Solution {
pub fn partition(head: Option<Box<ListNode>>, x: i32) -> Option<Box<ListNode>> {
- let mut head = head;
- let mut d1 = Some(Box::new(ListNode::new(0)));
- let mut d2 = Some(Box::new(ListNode::new(0)));
- let (mut t1, mut t2) = (&mut d1, &mut d2);
- while let Some(mut node) = head {
- head = node.next.take();
+ let mut l = ListNode::new(0);
+ let mut r = ListNode::new(0);
+ let mut tl = &mut l;
+ let mut tr = &mut r;
+ let mut current = head;
+ while let Some(mut node) = current {
+ current = node.next.take();
if node.val < x {
- t1.as_mut().unwrap().next = Some(node);
- t1 = &mut t1.as_mut().unwrap().next;
+ tl.next = Some(node);
+ tl = tl.next.as_mut().unwrap();
} else {
- t2.as_mut().unwrap().next = Some(node);
- t2 = &mut t2.as_mut().unwrap().next;
+ tr.next = Some(node);
+ tr = tr.next.as_mut().unwrap();
}
}
- t1.as_mut().unwrap().next = d2.unwrap().next;
- d1.unwrap().next
+ tr.next = None;
+ tl.next = r.next;
+ l.next
}
}
```
@@ -242,26 +275,58 @@ impl Solution {
* @return {ListNode}
*/
var partition = function (head, x) {
- const d1 = new ListNode();
- const d2 = new ListNode();
- let t1 = d1,
- t2 = d2;
- while (head) {
+ const [l, r] = [new ListNode(), new ListNode()];
+ let [tl, tr] = [l, r];
+ for (; head; head = head.next) {
if (head.val < x) {
- t1.next = head;
- t1 = t1.next;
+ tl.next = head;
+ tl = tl.next;
} else {
- t2.next = head;
- t2 = t2.next;
+ tr.next = head;
+ tr = tr.next;
}
- head = head.next;
}
- t1.next = d2.next;
- t2.next = null;
- return d1.next;
+ tr.next = null;
+ tl.next = r.next;
+ return l.next;
};
```
+#### 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 ListNode Partition(ListNode head, int x) {
+ ListNode l = new ListNode();
+ ListNode r = new ListNode();
+ ListNode tl = l, tr = r;
+ for (; head != null; head = head.next) {
+ if (head.val < x) {
+ tl.next = head;
+ tl = tl.next;
+ } else {
+ tr.next = head;
+ tr = tr.next;
+ }
+ }
+ tr.next = null;
+ tl.next = r.next;
+ return l.next;
+ }
+}
+```
+
<!-- tabs:end -->
<!-- solution:end -->
diff --git a/solution/0000-0099/0086.Partition List/Solution.cpp b/solution/0000-0099/0086.Partition List/Solution.cpp
index d04f17777dbe3..05eec2c5fa150 100644
--- a/solution/0000-0099/0086.Partition List/Solution.cpp
+++ b/solution/0000-0099/0086.Partition List/Solution.cpp
@@ -11,22 +11,21 @@
class Solution {
public:
ListNode* partition(ListNode* head, int x) {
- ListNode* d1 = new ListNode();
- ListNode* d2 = new ListNode();
- ListNode* t1 = d1;
- ListNode* t2 = d2;
- while (head) {
+ ListNode* l = new ListNode();
+ ListNode* r = new ListNode();
+ ListNode* tl = l;
+ ListNode* tr = r;
+ for (; head; head = head->next) {
if (head->val < x) {
- t1->next = head;
- t1 = t1->next;
+ tl->next = head;
+ tl = tl->next;
} else {
- t2->next = head;
- t2 = t2->next;
+ tr->next = head;
+ tr = tr->next;
}
- head = head->next;
}
- t1->next = d2->next;
- t2->next = nullptr;
- return d1->next;
+ tr->next = nullptr;
+ tl->next = r->next;
+ return l->next;
}
-};
\ No newline at end of file
+};
diff --git a/solution/0000-0099/0086.Partition List/Solution.cs b/solution/0000-0099/0086.Partition List/Solution.cs
new file mode 100644
index 0000000000000..e20ecae1ffff7
--- /dev/null
+++ b/solution/0000-0099/0086.Partition List/Solution.cs
@@ -0,0 +1,30 @@
+/**
+ * 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 ListNode Partition(ListNode head, int x) {
+ ListNode l = new ListNode();
+ ListNode r = new ListNode();
+ ListNode tl = l, tr = r;
+ for (; head != null; head = head.next) {
+ if (head.val < x) {
+ tl.next = head;
+ tl = tl.next;
+ } else {
+ tr.next = head;
+ tr = tr.next;
+ }
+ }
+ tr.next = null;
+ tl.next = r.next;
+ return l.next;
+ }
+}
diff --git a/solution/0000-0099/0086.Partition List/Solution.go b/solution/0000-0099/0086.Partition List/Solution.go
index 88c4af0e9efab..79466943969b6 100644
--- a/solution/0000-0099/0086.Partition List/Solution.go
+++ b/solution/0000-0099/0086.Partition List/Solution.go
@@ -6,19 +6,18 @@
* }
*/
func partition(head *ListNode, x int) *ListNode {
- d1, d2 := &ListNode{}, &ListNode{}
- t1, t2 := d1, d2
- for head != nil {
+ l, r := &ListNode{}, &ListNode{}
+ tl, tr := l, r
+ for ; head != nil; head = head.Next {
if head.Val < x {
- t1.Next = head
- t1 = t1.Next
+ tl.Next = head
+ tl = tl.Next
} else {
- t2.Next = head
- t2 = t2.Next
+ tr.Next = head
+ tr = tr.Next
}
- head = head.Next
}
- t1.Next = d2.Next
- t2.Next = nil
- return d1.Next
-}
\ No newline at end of file
+ tr.Next = nil
+ tl.Next = r.Next
+ return l.Next
+}
diff --git a/solution/0000-0099/0086.Partition List/Solution.java b/solution/0000-0099/0086.Partition List/Solution.java
index 75f9c836a553e..a185ea0207875 100644
--- a/solution/0000-0099/0086.Partition List/Solution.java
+++ b/solution/0000-0099/0086.Partition List/Solution.java
@@ -10,21 +10,20 @@
*/
class Solution {
public ListNode partition(ListNode head, int x) {
- ListNode d1 = new ListNode();
- ListNode d2 = new ListNode();
- ListNode t1 = d1, t2 = d2;
- while (head != null) {
+ ListNode l = new ListNode();
+ ListNode r = new ListNode();
+ ListNode tl = l, tr = r;
+ for (; head != null; head = head.next) {
if (head.val < x) {
- t1.next = head;
- t1 = t1.next;
+ tl.next = head;
+ tl = tl.next;
} else {
- t2.next = head;
- t2 = t2.next;
+ tr.next = head;
+ tr = tr.next;
}
- head = head.next;
}
- t1.next = d2.next;
- t2.next = null;
- return d1.next;
+ tr.next = null;
+ tl.next = r.next;
+ return l.next;
}
-}
\ No newline at end of file
+}
diff --git a/solution/0000-0099/0086.Partition List/Solution.js b/solution/0000-0099/0086.Partition List/Solution.js
index f491a463c0de4..5b328b5fdce87 100644
--- a/solution/0000-0099/0086.Partition List/Solution.js
+++ b/solution/0000-0099/0086.Partition List/Solution.js
@@ -11,21 +11,18 @@
* @return {ListNode}
*/
var partition = function (head, x) {
- const d1 = new ListNode();
- const d2 = new ListNode();
- let t1 = d1,
- t2 = d2;
- while (head) {
+ const [l, r] = [new ListNode(), new ListNode()];
+ let [tl, tr] = [l, r];
+ for (; head; head = head.next) {
if (head.val < x) {
- t1.next = head;
- t1 = t1.next;
+ tl.next = head;
+ tl = tl.next;
} else {
- t2.next = head;
- t2 = t2.next;
+ tr.next = head;
+ tr = tr.next;
}
- head = head.next;
}
- t1.next = d2.next;
- t2.next = null;
- return d1.next;
+ tr.next = null;
+ tl.next = r.next;
+ return l.next;
};
diff --git a/solution/0000-0099/0086.Partition List/Solution.py b/solution/0000-0099/0086.Partition List/Solution.py
index 82a4e4220ebd1..a19cb0ab393d4 100644
--- a/solution/0000-0099/0086.Partition List/Solution.py
+++ b/solution/0000-0099/0086.Partition List/Solution.py
@@ -5,16 +5,17 @@
# self.next = next
class Solution:
def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:
- d1, d2 = ListNode(), ListNode()
- t1, t2 = d1, d2
+ l = ListNode()
+ r = ListNode()
+ tl, tr = l, r
while head:
if head.val < x:
- t1.next = head
- t1 = t1.next
+ tl.next = head
+ tl = tl.next
else:
- t2.next = head
- t2 = t2.next
+ tr.next = head
+ tr = tr.next
head = head.next
- t1.next = d2.next
- t2.next = None
- return d1.next
+ tr.next = None
+ tl.next = r.next
+ return l.next
diff --git a/solution/0000-0099/0086.Partition List/Solution.rs b/solution/0000-0099/0086.Partition List/Solution.rs
index 6f4beb3366b2c..76675106da012 100644
--- a/solution/0000-0099/0086.Partition List/Solution.rs
+++ b/solution/0000-0099/0086.Partition List/Solution.rs
@@ -16,21 +16,23 @@
// }
impl Solution {
pub fn partition(head: Option<Box<ListNode>>, x: i32) -> Option<Box<ListNode>> {
- let mut head = head;
- let mut d1 = Some(Box::new(ListNode::new(0)));
- let mut d2 = Some(Box::new(ListNode::new(0)));
- let (mut t1, mut t2) = (&mut d1, &mut d2);
- while let Some(mut node) = head {
- head = node.next.take();
+ let mut l = ListNode::new(0);
+ let mut r = ListNode::new(0);
+ let mut tl = &mut l;
+ let mut tr = &mut r;
+ let mut current = head;
+ while let Some(mut node) = current {
+ current = node.next.take();
if node.val < x {
- t1.as_mut().unwrap().next = Some(node);
- t1 = &mut t1.as_mut().unwrap().next;
+ tl.next = Some(node);
+ tl = tl.next.as_mut().unwrap();
} else {
- t2.as_mut().unwrap().next = Some(node);
- t2 = &mut t2.as_mut().unwrap().next;
+ tr.next = Some(node);
+ tr = tr.next.as_mut().unwrap();
}
}
- t1.as_mut().unwrap().next = d2.unwrap().next;
- d1.unwrap().next
+ tr.next = None;
+ tl.next = r.next;
+ l.next
}
}
diff --git a/solution/0000-0099/0086.Partition List/Solution.ts b/solution/0000-0099/0086.Partition List/Solution.ts
new file mode 100644
index 0000000000000..1b01a685dd479
--- /dev/null
+++ b/solution/0000-0099/0086.Partition List/Solution.ts
@@ -0,0 +1,28 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ * val: number
+ * next: ListNode | null
+ * constructor(val?: number, next?: ListNode | null) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.next = (next===undefined ? null : next)
+ * }
+ * }
+ */
+
+function partition(head: ListNode | null, x: number): ListNode | null {
+ const [l, r] = [new ListNode(), new ListNode()];
+ let [tl, tr] = [l, r];
+ for (; head; head = head.next) {
+ if (head.val < x) {
+ tl.next = head;
+ tl = tl.next;
+ } else {
+ tr.next = head;
+ tr = tr.next;
+ }
+ }
+ tr.next = null;
+ tl.next = r.next;
+ return l.next;
+}