Skip to content

Commit 8772a41

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1836
No.1836.Remove Duplicates From an Unsorted Linked List
1 parent bbb9d0a commit 8772a41

File tree

6 files changed

+115
-46
lines changed

6 files changed

+115
-46
lines changed

‎solution/1800-1899/1836.Remove Duplicates From an Unsorted Linked List/README.md

Lines changed: 44 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,11 @@
4646

4747
<!-- 这里可写通用的实现逻辑 -->
4848

49-
“哈希表”实现。
49+
**方法一：哈希表**
50+
51+
我们可以用哈希表 `cnt` 统计链表中每个元素出现的次数，然后遍历链表，删除出现次数大于 1 的元素。
52+
53+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为链表的长度。
5054

5155
<!-- tabs:start -->
5256

@@ -62,16 +66,15 @@
6266
# self.next = next
6367
class Solution:
6468
def deleteDuplicatesUnsorted(self, head: ListNode) -> ListNode:
69+
cnt = Counter()
6570
cur = head
66-
counter = Counter()
6771
while cur:
68-
counter[cur.val] += 1
72+
cnt[cur.val] += 1
6973
cur = cur.next
70-
7174
dummy = ListNode(0, head)
7275
pre, cur = dummy, head
7376
while cur:
74-
if counter[cur.val] > 1:
77+
if cnt[cur.val] > 1:
7578
pre.next = cur.next
7679
else:
7780
pre = cur
@@ -96,14 +99,13 @@ class Solution:
9699
*/
97100
class Solution {
98101
public ListNode deleteDuplicatesUnsorted(ListNode head) {
99-
Map<Integer, Integer> counter = new HashMap<>();
102+
Map<Integer, Integer> cnt = new HashMap<>();
100103
for (ListNode cur = head; cur != null; cur = cur.next) {
101-
counter.put(cur.val, counter.getOrDefault(cur.val, 0) + 1);
104+
cnt.put(cur.val, cnt.getOrDefault(cur.val, 0) + 1);
102105
}
103-
104106
ListNode dummy = new ListNode(0, head);
105107
for (ListNode pre = dummy, cur = head; cur != null; cur = cur.next) {
106-
if (counter.get(cur.val) > 1) {
108+
if (cnt.get(cur.val) > 1) {
107109
pre.next = cur.next;
108110
} else {
109111
pre = cur;
@@ -130,14 +132,13 @@ class Solution {
130132
class Solution {
131133
public:
132134
ListNode* deleteDuplicatesUnsorted(ListNode* head) {
133-
unordered_map<int, int> counter;
134-
for (ListNode* cur = head; cur != nullptr; cur = cur->next) {
135-
++counter[cur->val];
135+
unordered_map<int, int> cnt;
136+
for (ListNode* cur = head; cur; cur = cur->next) {
137+
cnt[cur->val]++;
136138
}
137-
138139
ListNode* dummy = new ListNode(0, head);
139-
for (ListNode *pre = dummy, *cur = head; cur != nullptr; cur = cur->next) {
140-
if (counter[cur->val] > 1) {
140+
for (ListNode *pre = dummy, *cur = head; cur; cur = cur->next) {
141+
if (cnt[cur->val] > 1) {
141142
pre->next = cur->next;
142143
} else {
143144
pre = cur;
@@ -148,6 +149,34 @@ public:
148149
};
149150
```
150151
152+
### **Go**
153+
154+
```go
155+
/**
156+
* Definition for singly-linked list.
157+
* type ListNode struct {
158+
* Val int
159+
* Next *ListNode
160+
* }
161+
*/
162+
func deleteDuplicatesUnsorted(head *ListNode) *ListNode {
163+
cnt := map[int]int{}
164+
for cur := head; cur != nil; cur = cur.Next {
165+
cnt[cur.Val]++
166+
}
167+
dummy := &ListNode{0, head}
168+
for pre, cur := dummy, head; cur != nil; cur = cur.Next {
169+
if cnt[cur.Val] > 1 {
170+
pre.Next = cur.Next
171+
} else {
172+
pre = cur
173+
}
174+
}
175+
return dummy.Next
176+
}
177+
```
178+
179+
151180
### **...**
152181

153182
```

‎solution/1800-1899/1836.Remove Duplicates From an Unsorted Linked List/README_EN.md

Lines changed: 38 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -57,11 +57,8 @@
5757
<p><strong>Constraints:</strong></p>
5858

5959
<ul>
60-
6160
<li>The number of nodes in the list is in the range&nbsp;<code>[1, 10<sup>5</sup>]</code></li>
62-
6361
<li><code>1 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
64-
6562
</ul>
6663

6764
## Solutions
@@ -78,16 +75,15 @@
7875
# self.next = next
7976
class Solution:
8077
def deleteDuplicatesUnsorted(self, head: ListNode) -> ListNode:
78+
cnt = Counter()
8179
cur = head
82-
counter = Counter()
8380
while cur:
84-
counter[cur.val] += 1
81+
cnt[cur.val] += 1
8582
cur = cur.next
86-
8783
dummy = ListNode(0, head)
8884
pre, cur = dummy, head
8985
while cur:
90-
if counter[cur.val] > 1:
86+
if cnt[cur.val] > 1:
9187
pre.next = cur.next
9288
else:
9389
pre = cur
@@ -110,14 +106,13 @@ class Solution:
110106
*/
111107
class Solution {
112108
public ListNode deleteDuplicatesUnsorted(ListNode head) {
113-
Map<Integer, Integer> counter = new HashMap<>();
109+
Map<Integer, Integer> cnt = new HashMap<>();
114110
for (ListNode cur = head; cur != null; cur = cur.next) {
115-
counter.put(cur.val, counter.getOrDefault(cur.val, 0) + 1);
111+
cnt.put(cur.val, cnt.getOrDefault(cur.val, 0) + 1);
116112
}
117-
118113
ListNode dummy = new ListNode(0, head);
119114
for (ListNode pre = dummy, cur = head; cur != null; cur = cur.next) {
120-
if (counter.get(cur.val) > 1) {
115+
if (cnt.get(cur.val) > 1) {
121116
pre.next = cur.next;
122117
} else {
123118
pre = cur;
@@ -144,14 +139,13 @@ class Solution {
144139
class Solution {
145140
public:
146141
ListNode* deleteDuplicatesUnsorted(ListNode* head) {
147-
unordered_map<int, int> counter;
148-
for (ListNode* cur = head; cur != nullptr; cur = cur->next) {
149-
++counter[cur->val];
142+
unordered_map<int, int> cnt;
143+
for (ListNode* cur = head; cur; cur = cur->next) {
144+
cnt[cur->val]++;
150145
}
151-
152146
ListNode* dummy = new ListNode(0, head);
153-
for (ListNode *pre = dummy, *cur = head; cur != nullptr; cur = cur->next) {
154-
if (counter[cur->val] > 1) {
147+
for (ListNode *pre = dummy, *cur = head; cur; cur = cur->next) {
148+
if (cnt[cur->val] > 1) {
155149
pre->next = cur->next;
156150
} else {
157151
pre = cur;
@@ -162,6 +156,33 @@ public:
162156
};
163157
```
164158
159+
### **Go**
160+
161+
```go
162+
/**
163+
* Definition for singly-linked list.
164+
* type ListNode struct {
165+
* Val int
166+
* Next *ListNode
167+
* }
168+
*/
169+
func deleteDuplicatesUnsorted(head *ListNode) *ListNode {
170+
cnt := map[int]int{}
171+
for cur := head; cur != nil; cur = cur.Next {
172+
cnt[cur.Val]++
173+
}
174+
dummy := &ListNode{0, head}
175+
for pre, cur := dummy, head; cur != nil; cur = cur.Next {
176+
if cnt[cur.Val] > 1 {
177+
pre.Next = cur.Next
178+
} else {
179+
pre = cur
180+
}
181+
}
182+
return dummy.Next
183+
}
184+
```
185+
165186
### **...**
166187

167188
```

‎solution/1800-1899/1836.Remove Duplicates From an Unsorted Linked List/Solution.cpp

Lines changed: 5 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -11,14 +11,13 @@
1111
class Solution {
1212
public:
1313
ListNode* deleteDuplicatesUnsorted(ListNode* head) {
14-
unordered_map<int, int> counter;
15-
for (ListNode* cur = head; cur != nullptr; cur = cur->next) {
16-
++counter[cur->val];
14+
unordered_map<int, int> cnt;
15+
for (ListNode* cur = head; cur; cur = cur->next) {
16+
cnt[cur->val]++;
1717
}
18-
1918
ListNode* dummy = new ListNode(0, head);
20-
for (ListNode *pre = dummy, *cur = head; cur != nullptr; cur = cur->next) {
21-
if (counter[cur->val] > 1) {
19+
for (ListNode *pre = dummy, *cur = head; cur; cur = cur->next) {
20+
if (cnt[cur->val] > 1) {
2221
pre->next = cur->next;
2322
} else {
2423
pre = cur;

‎solution/1800-1899/1836.Remove Duplicates From an Unsorted Linked List/Solution.go

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* type ListNode struct {
4+
* Val int
5+
* Next *ListNode
6+
* }
7+
*/
8+
func deleteDuplicatesUnsorted(head *ListNode) *ListNode {
9+
cnt := map[int]int{}
10+
for cur := head; cur != nil; cur = cur.Next {
11+
cnt[cur.Val]++
12+
}
13+
dummy := &ListNode{0, head}
14+
for pre, cur := dummy, head; cur != nil; cur = cur.Next {
15+
if cnt[cur.Val] > 1 {
16+
pre.Next = cur.Next
17+
} else {
18+
pre = cur
19+
}
20+
}
21+
return dummy.Next
22+
}

‎solution/1800-1899/1836.Remove Duplicates From an Unsorted Linked List/Solution.java

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -10,14 +10,13 @@
1010
*/
1111
class Solution {
1212
public ListNode deleteDuplicatesUnsorted(ListNode head) {
13-
Map<Integer, Integer> counter = new HashMap<>();
13+
Map<Integer, Integer> cnt = new HashMap<>();
1414
for (ListNode cur = head; cur != null; cur = cur.next) {
15-
counter.put(cur.val, counter.getOrDefault(cur.val, 0) + 1);
15+
cnt.put(cur.val, cnt.getOrDefault(cur.val, 0) + 1);
1616
}
17-
1817
ListNode dummy = new ListNode(0, head);
1918
for (ListNode pre = dummy, cur = head; cur != null; cur = cur.next) {
20-
if (counter.get(cur.val) > 1) {
19+
if (cnt.get(cur.val) > 1) {
2120
pre.next = cur.next;
2221
} else {
2322
pre = cur;

‎solution/1800-1899/1836.Remove Duplicates From an Unsorted Linked List/Solution.py

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -5,16 +5,15 @@
55
# self.next = next
66
class Solution:
77
def deleteDuplicatesUnsorted(self, head: ListNode) -> ListNode:
8+
cnt = Counter()
89
cur = head
9-
counter = Counter()
1010
while cur:
11-
counter[cur.val] += 1
11+
cnt[cur.val] += 1
1212
cur = cur.next
13-
1413
dummy = ListNode(0, head)
1514
pre, cur = dummy, head
1615
while cur:
17-
if counter[cur.val] > 1:
16+
if cnt[cur.val] > 1:
1817
pre.next = cur.next
1918
else:
2019
pre = cur

0 commit comments

Comments
 (0)