Skip to content

Commit 756f0eb

Browse files
maolonglongmaolonglong
committed
chore: copy the same problem solutions from lc to lcof2: No.021,022,023
1 parent f51f022 commit 756f0eb

File tree

21 files changed

+861
-3
lines changed

21 files changed

+861
-3
lines changed

‎lcof2/剑指 Offer II 021. 删除链表的倒数第 n 个结点/README.md

Lines changed: 161 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -55,22 +55,182 @@
5555

5656
<!-- 这里可写通用的实现逻辑 -->
5757

58+
利用快慢指针和虚拟头节点
59+
5860
<!-- tabs:start -->
5961

6062
### **Python3**
6163

6264
<!-- 这里可写当前语言的特殊实现逻辑 -->
6365

6466
```python
65-
67+
# Definition for singly-linked list.
68+
# class ListNode:
69+
# def __init__(self, val=0, next=None):
70+
# self.val = val
71+
# self.next = next
72+
class Solution:
73+
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
74+
dummy = ListNode(next=head)
75+
slow, fast = dummy, dummy
76+
for _ in range(n):
77+
fast = fast.next
78+
while fast.next:
79+
slow = slow.next
80+
fast = fast.next
81+
slow.next = slow.next.next
82+
return dummy.next
6683
```
6784

6885
### **Java**
6986

7087
<!-- 这里可写当前语言的特殊实现逻辑 -->
7188

7289
```java
90+
/**
91+
* Definition for singly-linked list.
92+
* public class ListNode {
93+
* int val;
94+
* ListNode next;
95+
* ListNode() {}
96+
* ListNode(int val) { this.val = val; }
97+
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
98+
* }
99+
*/
100+
class Solution {
101+
public ListNode removeNthFromEnd(ListNode head, int n) {
102+
ListNode dummy = new ListNode(0, head);
103+
ListNode fast = dummy, slow = dummy;
104+
while (n-- > 0) {
105+
fast = fast.next;
106+
}
107+
while (fast.next != null) {
108+
slow = slow.next;
109+
fast = fast.next;
110+
}
111+
slow.next = slow.next.next;
112+
return dummy.next;
113+
}
114+
}
115+
```
116+
117+
### **C++**
118+
119+
```cpp
120+
/**
121+
* Definition for singly-linked list.
122+
* struct ListNode {
123+
* int val;
124+
* ListNode *next;
125+
* ListNode() : val(0), next(nullptr) {}
126+
* ListNode(int x) : val(x), next(nullptr) {}
127+
* ListNode(int x, ListNode *next) : val(x), next(next) {}
128+
* };
129+
*/
130+
class Solution {
131+
public:
132+
ListNode* removeNthFromEnd(ListNode* head, int n) {
133+
ListNode* dummy = new ListNode(0, head);
134+
ListNode* fast = dummy;
135+
ListNode* slow = dummy;
136+
while (n--) {
137+
fast = fast->next;
138+
}
139+
while (fast->next) {
140+
slow = slow->next;
141+
fast = fast->next;
142+
}
143+
slow->next = slow->next->next;
144+
return dummy->next;
145+
}
146+
};
147+
```
148+
149+
### **Go**
150+
151+
```go
152+
/**
153+
* Definition for singly-linked list.
154+
* type ListNode struct {
155+
* Val int
156+
* Next *ListNode
157+
* }
158+
*/
159+
func removeNthFromEnd(head *ListNode, n int) *ListNode {
160+
dummy := &ListNode{0, head}
161+
fast := dummy
162+
slow := dummy
163+
for n > 0 {
164+
fast = fast.Next
165+
n -= 1
166+
}
167+
for fast.Next != nil {
168+
slow = slow.Next
169+
fast = fast.Next
170+
}
171+
slow.Next = slow.Next.Next
172+
return dummy.Next
173+
}
174+
```
175+
176+
### **JavaScript**
177+
178+
```js
179+
/**
180+
* Definition for singly-linked list.
181+
* function ListNode(val, next) {
182+
* this.val = (val===undefined ? 0 : val)
183+
* this.next = (next===undefined ? null : next)
184+
* }
185+
*/
186+
/**
187+
* @param {ListNode} head
188+
* @param {number} n
189+
* @return {ListNode}
190+
*/
191+
var removeNthFromEnd = function(head, n) {
192+
const dummy = new ListNode(0, head);
193+
let fast = dummy, slow = dummy;
194+
while (n--) {
195+
fast = fast.next;
196+
}
197+
while (fast.next) {
198+
slow = slow.next;
199+
fast = fast.next;
200+
}
201+
slow.next = slow.next.next;
202+
return dummy.next;
203+
};
204+
```
73205

206+
### **Ruby**
207+
208+
```rb
209+
# Definition for singly-linked list.
210+
# class ListNode
211+
# attr_accessor :val, :next
212+
# def initialize(val = 0, _next = nil)
213+
# @val = val
214+
# @next = _next
215+
# end
216+
# end
217+
# @param {ListNode} head
218+
# @param {Integer} n
219+
# @return {ListNode}
220+
def remove_nth_from_end(head, n)
221+
dummy = ListNode.new(0, head)
222+
fast = slow = dummy
223+
while n > 0
224+
fast = fast.next
225+
n -= 1
226+
end
227+
while fast.next
228+
slow = slow.next
229+
fast = fast.next
230+
end
231+
slow.next = slow.next.next
232+
return dummy.next
233+
end
74234
```
75235

76236
### **...**

‎lcof2/剑指 Offer II 021. 删除链表的倒数第 n 个结点/Solution.cpp

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
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* removeNthFromEnd(ListNode* head, int n) {
14+
ListNode* dummy = new ListNode(0, head);
15+
ListNode* fast = dummy;
16+
ListNode* slow = dummy;
17+
while (n--) {
18+
fast = fast->next;
19+
}
20+
while (fast->next) {
21+
slow = slow->next;
22+
fast = fast->next;
23+
}
24+
slow->next = slow->next->next;
25+
return dummy->next;
26+
}
27+
};

‎lcof2/剑指 Offer II 021. 删除链表的倒数第 n 个结点/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 removeNthFromEnd(head *ListNode, n int) *ListNode {
9+
dummy := &ListNode{0, head}
10+
fast := dummy
11+
slow := dummy
12+
for n > 0 {
13+
fast = fast.Next
14+
n -= 1
15+
}
16+
for fast.Next != nil {
17+
slow = slow.Next
18+
fast = fast.Next
19+
}
20+
slow.Next = slow.Next.Next
21+
return dummy.Next
22+
}

‎lcof2/剑指 Offer II 021. 删除链表的倒数第 n 个结点/Solution.java

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* public class ListNode {
4+
* int val;
5+
* ListNode next;
6+
* ListNode() {}
7+
* ListNode(int val) { this.val = val; }
8+
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
9+
* }
10+
*/
11+
class Solution {
12+
public ListNode removeNthFromEnd(ListNode head, int n) {
13+
ListNode dummy = new ListNode(0, head);
14+
ListNode fast = dummy, slow = dummy;
15+
while (n-- > 0) {
16+
fast = fast.next;
17+
}
18+
while (fast.next != null) {
19+
slow = slow.next;
20+
fast = fast.next;
21+
}
22+
slow.next = slow.next.next;
23+
return dummy.next;
24+
}
25+
}

‎lcof2/剑指 Offer II 021. 删除链表的倒数第 n 个结点/Solution.js

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* function ListNode(val, next) {
4+
* this.val = (val===undefined ? 0 : val)
5+
* this.next = (next===undefined ? null : next)
6+
* }
7+
*/
8+
/**
9+
* @param {ListNode} head
10+
* @param {number} n
11+
* @return {ListNode}
12+
*/
13+
var removeNthFromEnd = function(head, n) {
14+
const dummy = new ListNode(0, head);
15+
let fast = dummy, slow = dummy;
16+
while (n--) {
17+
fast = fast.next;
18+
}
19+
while (fast.next) {
20+
slow = slow.next;
21+
fast = fast.next;
22+
}
23+
slow.next = slow.next.next;
24+
return dummy.next;
25+
};

‎lcof2/剑指 Offer II 021. 删除链表的倒数第 n 个结点/Solution.py

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
# Definition for singly-linked list.
2+
# class ListNode:
3+
# def __init__(self, val=0, next=None):
4+
# self.val = val
5+
# self.next = next
6+
class Solution:
7+
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
8+
dummy = ListNode(next=head)
9+
slow, fast = dummy, dummy
10+
for _ in range(n):
11+
fast = fast.next
12+
while fast.next:
13+
slow = slow.next
14+
fast = fast.next
15+
slow.next = slow.next.next
16+
return dummy.next

‎lcof2/剑指 Offer II 021. 删除链表的倒数第 n 个结点/Solution.rb

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
# Definition for singly-linked list.
2+
# class ListNode
3+
# attr_accessor :val, :next
4+
# def initialize(val = 0, _next = nil)
5+
# @val = val
6+
# @next = _next
7+
# end
8+
# end
9+
# @param {ListNode} head
10+
# @param {Integer} n
11+
# @return {ListNode}
12+
def remove_nth_from_end(head, n)
13+
dummy = ListNode.new(0, head)
14+
fast = slow = dummy
15+
while n > 0
16+
fast = fast.next
17+
n -= 1
18+
end
19+
while fast.next
20+
slow = slow.next
21+
fast = fast.next
22+
end
23+
slow.next = slow.next.next
24+
return dummy.next
25+
end

0 commit comments

Comments
 (0)