Skip to content

Commit 872a87c

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1171
No.1171.Remove Zero Sum Consecutive Nodes from Linked List
1 parent 5447162 commit 872a87c

File tree

6 files changed

+265
-61
lines changed

6 files changed

+265
-61
lines changed

‎solution/1100-1199/1171.Remove Zero Sum Consecutive Nodes from Linked List/README.md

Lines changed: 97 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -48,13 +48,17 @@
4848

4949
<!-- 这里可写通用的实现逻辑 -->
5050

51-
“前缀和 + 哈希表”实现。
51+
**方法一：前缀和 + 哈希表**
5252

53-
若链表节点的两个前缀和相等，说明两个前缀和之间的连续节点序列的和为 0，那么可以消去这部分连续节点。
53+
若链表节点的两个前缀和相等，说明两个前缀和之间的连续节点序列的和为 $0$，那么可以消去这部分连续节点。
5454

55-
第一次遍历链表，用哈希表 `pre_sum_node` 记录前缀和以及对应的链表节点，同一前缀和 s，**后者的链表节点覆盖前者**。
55+
第一次遍历链表，用哈希表 `last` 记录前缀和以及对应的链表节点，同一前缀和 $s$，**后者的链表节点覆盖前者**。
5656

57-
第二次遍历链表，若当前节点 cur 的前缀和 s 在 `pre_sum_node` 出现，说明 cur 与 pre_sum_node[s] 之间的所有节点和为 0，直接修改 cur 的指向，`cur.next = pre_sum_node[s].next`，就删去了这部分和为 0 的连续节点。
57+
第二次遍历链表，若当前节点 `cur` 的前缀和 $s$ 在 `last` 出现，说明 `cur` 与 `last[s]` 之间的所有节点和为 $0$，直接修改 `cur` 的指向，`cur.next = last[s].next`，就删去了这部分和为 $0$ 的连续节点。继续往后遍历，删除所有和为 $0$ 的连续节点。
58+
59+
最后返回链表的头节点 `dummy.next`。
60+
61+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为链表的长度。
5862

5963
<!-- tabs:start -->
6064

@@ -65,25 +69,22 @@
6569
```python
6670
# Definition for singly-linked list.
6771
# class ListNode:
68-
# def __init__(self, x):
69-
# self.val = x
70-
# self.next = None
71-
72-
72+
# def __init__(self, val=0, next=None):
73+
# self.val = val
74+
# self.next = next
7375
class Solution:
74-
def removeZeroSumSublists(self, head: ListNode) -> ListNode:
75-
dummy = ListNode(0)
76-
dummy.next = head
76+
def removeZeroSumSublists(self, head: Optional[ListNode]) -> Optional[ListNode]:
77+
dummy = ListNode(next=head)
78+
last = {}
7779
s, cur = 0, dummy
78-
pre_sum_node = {}
7980
while cur:
8081
s += cur.val
81-
pre_sum_node[s] = cur
82+
last[s] = cur
8283
cur = cur.next
8384
s, cur = 0, dummy
8485
while cur:
8586
s += cur.val
86-
cur.next = pre_sum_node[s].next
87+
cur.next = last[s].next
8788
cur = cur.next
8889
return dummy.next
8990
```
@@ -98,29 +99,102 @@ class Solution:
9899
* public class ListNode {
99100
* int val;
100101
* ListNode next;
101-
* ListNode(int x) { val = x; }
102+
* ListNode() {}
103+
* ListNode(int val) { this.val = val; }
104+
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
102105
* }
103106
*/
104107
class Solution {
105108
public ListNode removeZeroSumSublists(ListNode head) {
106-
ListNode dummy = new ListNode(0);
107-
dummy.next = head;
108-
Map<Integer, ListNode> preSumNode = new HashMap<>();
109+
ListNode dummy = new ListNode(0, head);
110+
Map<Integer, ListNode> last = new HashMap<>();
109111
int s = 0;
110-
for (ListNode cur = dummy; cur != null; cur = cur.next) {
112+
ListNode cur = dummy;
113+
while (cur != null) {
111114
s += cur.val;
112-
preSumNode.put(s, cur);
115+
last.put(s, cur);
116+
cur = cur.next;
113117
}
114118
s = 0;
115-
for (ListNode cur = dummy; cur != null; cur = cur.next) {
119+
cur = dummy;
120+
while (cur != null) {
116121
s += cur.val;
117-
cur.next = preSumNode.get(s).next;
122+
cur.next = last.get(s).next;
123+
cur = cur.next;
118124
}
119125
return dummy.next;
120126
}
121127
}
122128
```
123129

130+
### **C++**
131+
132+
```cpp
133+
/**
134+
* Definition for singly-linked list.
135+
* struct ListNode {
136+
* int val;
137+
* ListNode *next;
138+
* ListNode() : val(0), next(nullptr) {}
139+
* ListNode(int x) : val(x), next(nullptr) {}
140+
* ListNode(int x, ListNode *next) : val(x), next(next) {}
141+
* };
142+
*/
143+
class Solution {
144+
public:
145+
ListNode* removeZeroSumSublists(ListNode* head) {
146+
ListNode* dummy = new ListNode(0, head);
147+
unordered_map<int, ListNode*> last;
148+
ListNode* cur = dummy;
149+
int s = 0;
150+
while (cur) {
151+
s += cur->val;
152+
last[s] = cur;
153+
cur = cur->next;
154+
}
155+
s = 0;
156+
cur = dummy;
157+
while (cur) {
158+
s += cur->val;
159+
cur->next = last[s]->next;
160+
cur = cur->next;
161+
}
162+
return dummy->next;
163+
}
164+
};
165+
```
166+
167+
### **Go**
168+
169+
```go
170+
/**
171+
* Definition for singly-linked list.
172+
* type ListNode struct {
173+
* Val int
174+
* Next *ListNode
175+
* }
176+
*/
177+
func removeZeroSumSublists(head *ListNode) *ListNode {
178+
dummy := &ListNode{0, head}
179+
last := map[int]*ListNode{}
180+
cur := dummy
181+
s := 0
182+
for cur != nil {
183+
s += cur.Val
184+
last[s] = cur
185+
cur = cur.Next
186+
}
187+
s = 0
188+
cur = dummy
189+
for cur != nil {
190+
s += cur.Val
191+
cur.Next = last[s].Next
192+
cur = cur.Next
193+
}
194+
return dummy.Next
195+
}
196+
```
197+
124198
### **...**
125199

126200
```

‎solution/1100-1199/1171.Remove Zero Sum Consecutive Nodes from Linked List/README_EN.md

Lines changed: 89 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -50,25 +50,22 @@
5050
```python
5151
# Definition for singly-linked list.
5252
# class ListNode:
53-
# def __init__(self, x):
54-
# self.val = x
55-
# self.next = None
56-
57-
53+
# def __init__(self, val=0, next=None):
54+
# self.val = val
55+
# self.next = next
5856
class Solution:
59-
def removeZeroSumSublists(self, head: ListNode) -> ListNode:
60-
dummy = ListNode(0)
61-
dummy.next = head
57+
def removeZeroSumSublists(self, head: Optional[ListNode]) -> Optional[ListNode]:
58+
dummy = ListNode(next=head)
59+
last = {}
6260
s, cur = 0, dummy
63-
pre_sum_node = {}
6461
while cur:
6562
s += cur.val
66-
pre_sum_node[s] = cur
63+
last[s] = cur
6764
cur = cur.next
6865
s, cur = 0, dummy
6966
while cur:
7067
s += cur.val
71-
cur.next = pre_sum_node[s].next
68+
cur.next = last[s].next
7269
cur = cur.next
7370
return dummy.next
7471
```
@@ -81,29 +78,102 @@ class Solution:
8178
* public class ListNode {
8279
* int val;
8380
* ListNode next;
84-
* ListNode(int x) { val = x; }
81+
* ListNode() {}
82+
* ListNode(int val) { this.val = val; }
83+
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
8584
* }
8685
*/
8786
class Solution {
8887
public ListNode removeZeroSumSublists(ListNode head) {
89-
ListNode dummy = new ListNode(0);
90-
dummy.next = head;
91-
Map<Integer, ListNode> preSumNode = new HashMap<>();
88+
ListNode dummy = new ListNode(0, head);
89+
Map<Integer, ListNode> last = new HashMap<>();
9290
int s = 0;
93-
for (ListNode cur = dummy; cur != null; cur = cur.next) {
91+
ListNode cur = dummy;
92+
while (cur != null) {
9493
s += cur.val;
95-
preSumNode.put(s, cur);
94+
last.put(s, cur);
95+
cur = cur.next;
9696
}
9797
s = 0;
98-
for (ListNode cur = dummy; cur != null; cur = cur.next) {
98+
cur = dummy;
99+
while (cur != null) {
99100
s += cur.val;
100-
cur.next = preSumNode.get(s).next;
101+
cur.next = last.get(s).next;
102+
cur = cur.next;
101103
}
102104
return dummy.next;
103105
}
104106
}
105107
```
106108

109+
### **C++**
110+
111+
```cpp
112+
/**
113+
* Definition for singly-linked list.
114+
* struct ListNode {
115+
* int val;
116+
* ListNode *next;
117+
* ListNode() : val(0), next(nullptr) {}
118+
* ListNode(int x) : val(x), next(nullptr) {}
119+
* ListNode(int x, ListNode *next) : val(x), next(next) {}
120+
* };
121+
*/
122+
class Solution {
123+
public:
124+
ListNode* removeZeroSumSublists(ListNode* head) {
125+
ListNode* dummy = new ListNode(0, head);
126+
unordered_map<int, ListNode*> last;
127+
ListNode* cur = dummy;
128+
int s = 0;
129+
while (cur) {
130+
s += cur->val;
131+
last[s] = cur;
132+
cur = cur->next;
133+
}
134+
s = 0;
135+
cur = dummy;
136+
while (cur) {
137+
s += cur->val;
138+
cur->next = last[s]->next;
139+
cur = cur->next;
140+
}
141+
return dummy->next;
142+
}
143+
};
144+
```
145+
146+
### **Go**
147+
148+
```go
149+
/**
150+
* Definition for singly-linked list.
151+
* type ListNode struct {
152+
* Val int
153+
* Next *ListNode
154+
* }
155+
*/
156+
func removeZeroSumSublists(head *ListNode) *ListNode {
157+
dummy := &ListNode{0, head}
158+
last := map[int]*ListNode{}
159+
cur := dummy
160+
s := 0
161+
for cur != nil {
162+
s += cur.Val
163+
last[s] = cur
164+
cur = cur.Next
165+
}
166+
s = 0
167+
cur = dummy
168+
for cur != nil {
169+
s += cur.Val
170+
cur.Next = last[s].Next
171+
cur = cur.Next
172+
}
173+
return dummy.Next
174+
}
175+
```
176+
107177
### **...**
108178

109179
```

‎solution/1100-1199/1171.Remove Zero Sum Consecutive Nodes from Linked List/Solution.cpp

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* struct ListNode {
4+
* int val;
5+
* ListNode *next;
6+
* ListNode() : val(0), next(nullptr) {}
7+
* ListNode(int x) : val(x), next(nullptr) {}
8+
* ListNode(int x, ListNode *next) : val(x), next(next) {}
9+
* };
10+
*/
11+
class Solution {
12+
public:
13+
ListNode* removeZeroSumSublists(ListNode* head) {
14+
ListNode* dummy = new ListNode(0, head);
15+
unordered_map<int, ListNode*> last;
16+
ListNode* cur = dummy;
17+
int s = 0;
18+
while (cur) {
19+
s += cur->val;
20+
last[s] = cur;
21+
cur = cur->next;
22+
}
23+
s = 0;
24+
cur = dummy;
25+
while (cur) {
26+
s += cur->val;
27+
cur->next = last[s]->next;
28+
cur = cur->next;
29+
}
30+
return dummy->next;
31+
}
32+
};

‎solution/1100-1199/1171.Remove Zero Sum Consecutive Nodes from Linked List/Solution.go

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

0 commit comments

Comments
 (0)