Skip to content

Commit 485db21

Browse files
YangFongYangFong
committed
feat: add solutions to lc problem: No.0082
No.0082.Remove Duplicates from Sorted List II
1 parent a014ed1 commit 485db21

File tree

4 files changed

+314
-0
lines changed

4 files changed

+314
-0
lines changed

‎solution/0000-0099/0082.Remove Duplicates from Sorted List II/README.md

Lines changed: 124 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -131,6 +131,54 @@ public:
131131
};
132132
```
133133
134+
### **C#**
135+
136+
```cs
137+
public class Solution {
138+
private ListNode newHead;
139+
private ListNode last;
140+
private ListNode candidate;
141+
private int count;
142+
143+
public ListNode DeleteDuplicates(ListNode head) {
144+
while (head != null)
145+
{
146+
if (candidate == null || candidate.val != head.val)
147+
{
148+
TryAppend();
149+
candidate = head;
150+
count = 1;
151+
}
152+
else
153+
{
154+
++count;
155+
}
156+
157+
head = head.next;
158+
}
159+
TryAppend();
160+
if (last != null) last.next = null;
161+
return newHead;
162+
}
163+
164+
private void TryAppend()
165+
{
166+
if (count == 1)
167+
{
168+
if (newHead == null)
169+
{
170+
newHead = last = candidate;
171+
}
172+
else
173+
{
174+
last.next = candidate;
175+
last = last.next;
176+
}
177+
}
178+
}
179+
}
180+
```
181+
134182
### **JavaScript**
135183

136184
```js
@@ -172,6 +220,82 @@ var deleteDuplicates = function (head) {
172220
};
173221
```
174222

223+
### **TypeScript**
224+
225+
```ts
226+
/**
227+
* Definition for singly-linked list.
228+
* class ListNode {
229+
* val: number
230+
* next: ListNode | null
231+
* constructor(val?: number, next?: ListNode | null) {
232+
* this.val = (val===undefined ? 0 : val)
233+
* this.next = (next===undefined ? null : next)
234+
* }
235+
* }
236+
*/
237+
238+
function deleteDuplicates(head: ListNode | null): ListNode | null {
239+
const dummy = new ListNode(101, head);
240+
let p = dummy;
241+
let c = dummy;
242+
let count = 1;
243+
while (c != null) {
244+
if (c.val !== (c.next ?? {}).val) {
245+
if (count === 1) {
246+
p = c;
247+
} else {
248+
p.next = c.next;
249+
}
250+
count = 0;
251+
}
252+
c = c.next;
253+
count++;
254+
}
255+
return dummy.next;
256+
}
257+
```
258+
259+
### **Rust**
260+
261+
```rust
262+
// Definition for singly-linked list.
263+
// #[derive(PartialEq, Eq, Clone, Debug)]
264+
// pub struct ListNode {
265+
// pub val: i32,
266+
// pub next: Option<Box<ListNode>>
267+
// }
268+
//
269+
// impl ListNode {
270+
// #[inline]
271+
// fn new(val: i32) -> Self {
272+
// ListNode {
273+
// next: None,
274+
// val
275+
// }
276+
// }
277+
// }
278+
impl Solution {
279+
pub fn delete_duplicates(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
280+
let mut dummy = Some(Box::new(ListNode::new(101)));
281+
let mut pev = dummy.as_mut().unwrap();
282+
let mut cur = head;
283+
let mut pre = 101;
284+
while let Some(mut node) = cur {
285+
cur = node.next.take();
286+
if node.val == pre || (cur.is_some() && cur.as_ref().unwrap().val == node.val) {
287+
pre = node.val;
288+
} else {
289+
pre = node.val;
290+
pev.next = Some(node);
291+
pev = pev.next.as_mut().unwrap();
292+
}
293+
}
294+
dummy.unwrap().next
295+
}
296+
}
297+
```
298+
175299
### **...**
176300

177301
```

‎solution/0000-0099/0082.Remove Duplicates from Sorted List II/README_EN.md

Lines changed: 124 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -121,6 +121,54 @@ public:
121121
};
122122
```
123123
124+
### **C#**
125+
126+
```cs
127+
public class Solution {
128+
private ListNode newHead;
129+
private ListNode last;
130+
private ListNode candidate;
131+
private int count;
132+
133+
public ListNode DeleteDuplicates(ListNode head) {
134+
while (head != null)
135+
{
136+
if (candidate == null || candidate.val != head.val)
137+
{
138+
TryAppend();
139+
candidate = head;
140+
count = 1;
141+
}
142+
else
143+
{
144+
++count;
145+
}
146+
147+
head = head.next;
148+
}
149+
TryAppend();
150+
if (last != null) last.next = null;
151+
return newHead;
152+
}
153+
154+
private void TryAppend()
155+
{
156+
if (count == 1)
157+
{
158+
if (newHead == null)
159+
{
160+
newHead = last = candidate;
161+
}
162+
else
163+
{
164+
last.next = candidate;
165+
last = last.next;
166+
}
167+
}
168+
}
169+
}
170+
```
171+
124172
### **JavaScript**
125173

126174
```js
@@ -162,6 +210,82 @@ var deleteDuplicates = function (head) {
162210
};
163211
```
164212

213+
### **TypeScript**
214+
215+
```ts
216+
/**
217+
* Definition for singly-linked list.
218+
* class ListNode {
219+
* val: number
220+
* next: ListNode | null
221+
* constructor(val?: number, next?: ListNode | null) {
222+
* this.val = (val===undefined ? 0 : val)
223+
* this.next = (next===undefined ? null : next)
224+
* }
225+
* }
226+
*/
227+
228+
function deleteDuplicates(head: ListNode | null): ListNode | null {
229+
const dummy = new ListNode(101, head);
230+
let p = dummy;
231+
let c = dummy;
232+
let count = 1;
233+
while (c != null) {
234+
if (c.val !== (c.next ?? {}).val) {
235+
if (count === 1) {
236+
p = c;
237+
} else {
238+
p.next = c.next;
239+
}
240+
count = 0;
241+
}
242+
c = c.next;
243+
count++;
244+
}
245+
return dummy.next;
246+
}
247+
```
248+
249+
### **Rust**
250+
251+
```rust
252+
// Definition for singly-linked list.
253+
// #[derive(PartialEq, Eq, Clone, Debug)]
254+
// pub struct ListNode {
255+
// pub val: i32,
256+
// pub next: Option<Box<ListNode>>
257+
// }
258+
//
259+
// impl ListNode {
260+
// #[inline]
261+
// fn new(val: i32) -> Self {
262+
// ListNode {
263+
// next: None,
264+
// val
265+
// }
266+
// }
267+
// }
268+
impl Solution {
269+
pub fn delete_duplicates(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
270+
let mut dummy = Some(Box::new(ListNode::new(101)));
271+
let mut pev = dummy.as_mut().unwrap();
272+
let mut cur = head;
273+
let mut pre = 101;
274+
while let Some(mut node) = cur {
275+
cur = node.next.take();
276+
if node.val == pre || (cur.is_some() && cur.as_ref().unwrap().val == node.val) {
277+
pre = node.val;
278+
} else {
279+
pre = node.val;
280+
pev.next = Some(node);
281+
pev = pev.next.as_mut().unwrap();
282+
}
283+
}
284+
dummy.unwrap().next
285+
}
286+
}
287+
```
288+
165289
### **...**
166290

167291
```

‎solution/0000-0099/0082.Remove Duplicates from Sorted List II/Solution.rs

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
// Definition for singly-linked list.
2+
// #[derive(PartialEq, Eq, Clone, Debug)]
3+
// pub struct ListNode {
4+
// pub val: i32,
5+
// pub next: Option<Box<ListNode>>
6+
// }
7+
//
8+
// impl ListNode {
9+
// #[inline]
10+
// fn new(val: i32) -> Self {
11+
// ListNode {
12+
// next: None,
13+
// val
14+
// }
15+
// }
16+
// }
17+
impl Solution {
18+
pub fn delete_duplicates(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
19+
let mut dummy = Some(Box::new(ListNode::new(101)));
20+
let mut pev = dummy.as_mut().unwrap();
21+
let mut cur = head;
22+
let mut pre = 101;
23+
while let Some(mut node) = cur {
24+
cur = node.next.take();
25+
if node.val == pre || (cur.is_some() && cur.as_ref().unwrap().val == node.val) {
26+
pre = node.val;
27+
} else {
28+
pre = node.val;
29+
pev.next = Some(node);
30+
pev = pev.next.as_mut().unwrap();
31+
}
32+
}
33+
dummy.unwrap().next
34+
}
35+
}

‎solution/0000-0099/0082.Remove Duplicates from Sorted List II/Solution.ts

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* class ListNode {
4+
* val: number
5+
* next: ListNode | null
6+
* constructor(val?: number, next?: ListNode | null) {
7+
* this.val = (val===undefined ? 0 : val)
8+
* this.next = (next===undefined ? null : next)
9+
* }
10+
* }
11+
*/
12+
13+
function deleteDuplicates(head: ListNode | null): ListNode | null {
14+
const dummy = new ListNode(101, head);
15+
let pev = dummy;
16+
let cur = dummy;
17+
let count = 1;
18+
while (cur != null) {
19+
if (cur.val !== (cur.next ?? {}).val) {
20+
if (count === 1) {
21+
pev = cur;
22+
} else {
23+
pev.next = cur.next;
24+
}
25+
count = 0;
26+
}
27+
cur = cur.next;
28+
count++;
29+
}
30+
return dummy.next;
31+
}

0 commit comments

Comments
 (0)