Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 0bb033f

Browse files
feat: add solutions to lc problem: No.0025 (doocs#3902)
No.0025.Reverse Nodes in k-Group
1 parent 2f30bab commit 0bb033f

File tree

11 files changed

+530
-682
lines changed

11 files changed

+530
-682
lines changed

‎solution/0000-0099/0025.Reverse Nodes in k-Group/README.md‎

Lines changed: 162 additions & 234 deletions
Large diffs are not rendered by default.

‎solution/0000-0099/0025.Reverse Nodes in k-Group/README_EN.md‎

Lines changed: 162 additions & 234 deletions
Large diffs are not rendered by default.
Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
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* reverseKGroup(ListNode* head, int k) {
14+
ListNode* dummy = new ListNode(0, head);
15+
ListNode* pre = dummy;
16+
17+
while (pre != nullptr) {
18+
ListNode* cur = pre;
19+
for (int i = 0; i < k; i++) {
20+
cur = cur->next;
21+
if (cur == nullptr) {
22+
return dummy->next;
23+
}
24+
}
25+
26+
ListNode* node = pre->next;
27+
ListNode* nxt = cur->next;
28+
cur->next = nullptr;
29+
pre->next = reverse(node);
30+
node->next = nxt;
31+
pre = node;
32+
}
33+
return dummy->next;
34+
}
35+
36+
private:
37+
ListNode* reverse(ListNode* head) {
38+
ListNode* dummy = new ListNode();
39+
ListNode* cur = head;
40+
while (cur != nullptr) {
41+
ListNode* nxt = cur->next;
42+
cur->next = dummy->next;
43+
dummy->next = cur;
44+
cur = nxt;
45+
}
46+
return dummy->next;
47+
}
48+
};

‎solution/0000-0099/0025.Reverse Nodes in k-Group/Solution.cs‎

Lines changed: 27 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -3,46 +3,47 @@
33
* public class ListNode {
44
* public int val;
55
* public ListNode next;
6-
* public ListNode(int val=0, ListNode next=null) {
6+
* public ListNode(int val = 0, ListNode next = null) {
77
* this.val = val;
88
* this.next = next;
99
* }
1010
* }
1111
*/
1212
public class Solution {
1313
public ListNode ReverseKGroup(ListNode head, int k) {
14-
ListNode dummy = new ListNode(0, head);
15-
ListNode pre = dummy, cur = dummy;
16-
while (cur.next != null)
17-
{
18-
for (int i = 0; i < k && cur != null; ++i)
19-
{
14+
var dummy = new ListNode(0);
15+
dummy.next = head;
16+
var pre = dummy;
17+
18+
while (pre != null) {
19+
var cur = pre;
20+
for (int i = 0; i < k; i++) {
21+
if (cur.next == null) {
22+
return dummy.next;
23+
}
2024
cur = cur.next;
2125
}
22-
if (cur == null)
23-
{
24-
return dummy.next;
25-
}
26-
ListNode t = cur.next;
26+
27+
var node = pre.next;
28+
var nxt = cur.next;
2729
cur.next = null;
28-
ListNode start = pre.next;
29-
pre.next = ReverseList(start);
30-
start.next = t;
31-
pre = start;
32-
cur = pre;
30+
pre.next = Reverse(node);
31+
node.next = nxt;
32+
pre = node;
3333
}
34+
3435
return dummy.next;
3536
}
3637

37-
private ListNode ReverseList(ListNode head) {
38-
ListNode pre = null,p=head;
39-
while(p!=null)
40-
{
41-
ListNodeq = p.next;
42-
p.next = pre;
43-
pre = p;
44-
p = q;
38+
private ListNode Reverse(ListNode head) {
39+
ListNode prev = null;
40+
varcur=head;
41+
while(cur!=null){
42+
varnxt = cur.next;
43+
cur.next = prev;
44+
prev = cur;
45+
cur = nxt;
4546
}
46-
return pre;
47+
return prev;
4748
}
4849
}

‎solution/0000-0099/0025.Reverse Nodes in k-Group/Solution.go‎

Lines changed: 23 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -6,28 +6,36 @@
66
* }
77
*/
88
func reverseKGroup(head *ListNode, k int) *ListNode {
9-
var dummy *ListNode = &ListNode{}
10-
p, cur := dummy, head
11-
for cur != nil {
12-
start := cur
9+
dummy := &ListNode{Next: head}
10+
pre := dummy
11+
12+
for pre != nil {
13+
cur := pre
1314
for i := 0; i < k; i++ {
15+
cur = cur.Next
1416
if cur == nil {
15-
p.Next = start
1617
return dummy.Next
1718
}
18-
cur = cur.Next
1919
}
20-
p.Next, p = reverse(start, cur), start
20+
21+
node := pre.Next
22+
nxt := cur.Next
23+
cur.Next = nil
24+
pre.Next = reverse(node)
25+
node.Next = nxt
26+
pre = node
2127
}
2228
return dummy.Next
2329
}
2430

25-
func reverse(start, end *ListNode) *ListNode {
26-
var pre *ListNode = nil
27-
for start != end {
28-
tmp := start.Next
29-
start.Next, pre = pre, start
30-
start = tmp
31+
func reverse(head *ListNode) *ListNode {
32+
var dummy *ListNode
33+
cur := head
34+
for cur != nil {
35+
nxt := cur.Next
36+
cur.Next = dummy
37+
dummy = cur
38+
cur = nxt
3139
}
32-
return pre
33-
}
40+
return dummy
41+
}

‎solution/0000-0099/0025.Reverse Nodes in k-Group/Solution.java‎

Lines changed: 23 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -11,33 +11,35 @@
1111
class Solution {
1212
public ListNode reverseKGroup(ListNode head, int k) {
1313
ListNode dummy = new ListNode(0, head);
14-
ListNode pre = dummy, cur = dummy;
15-
while (cur.next != null) {
16-
for (int i = 0; i < k && cur != null; ++i) {
14+
dummy.next = head;
15+
ListNode pre = dummy;
16+
while (pre != null) {
17+
ListNode cur = pre;
18+
for (int i = 0; i < k; i++) {
1719
cur = cur.next;
20+
if (cur == null) {
21+
return dummy.next;
22+
}
1823
}
19-
if (cur == null) {
20-
return dummy.next;
21-
}
22-
ListNode t = cur.next;
24+
ListNode node = pre.next;
25+
ListNode nxt = cur.next;
2326
cur.next = null;
24-
ListNode start = pre.next;
25-
pre.next = reverseList(start);
26-
start.next = t;
27-
pre = start;
28-
cur = pre;
27+
pre.next = reverse(node);
28+
node.next = nxt;
29+
pre = node;
2930
}
3031
return dummy.next;
3132
}
3233

33-
private ListNode reverseList(ListNode head) {
34-
ListNode pre = null, p = head;
35-
while (p != null) {
36-
ListNode q = p.next;
37-
p.next = pre;
38-
pre = p;
39-
p = q;
34+
private ListNode reverse(ListNode head) {
35+
ListNode dummy = new ListNode();
36+
ListNode cur = head;
37+
while (cur != null) {
38+
ListNode nxt = cur.next;
39+
cur.next = dummy.next;
40+
dummy.next = cur;
41+
cur = nxt;
4042
}
41-
return pre;
43+
return dummy.next;
4244
}
43-
}
45+
}
Lines changed: 43 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -1,51 +1,59 @@
1-
# Definitionforsingly-linkedlist.
2-
# classListNode {
3-
# public$val;
4-
# public $next;
5-
# public function__construct($val=0, $next = null)
6-
# {
7-
# $this->val = $val;
8-
# $this->next = $next;
9-
# }
10-
# }
11-
1+
/**
2+
* Definition for a singly-linked list.
3+
* class ListNode {
4+
* public $val = 0;
5+
* public $next = null;
6+
* function __construct($val = 0, $next = null) {
7+
* $this->val = $val;
8+
* $this->next = $next;
9+
* }
10+
* }
11+
*/
1212
class Solution {
1313
/**
1414
* @param ListNode $head
15-
* @param int $k
15+
* @param Integer $k
1616
* @return ListNode
1717
*/
18-
1918
function reverseKGroup($head, $k) {
2019
$dummy = new ListNode(0);
2120
$dummy->next = $head;
22-
$prevGroupTail = $dummy;
21+
$pre = $dummy;
2322

24-
while ($head !== null) {
25-
$count = 0;
26-
$groupHead = $head;
27-
$groupTail = $head;
28-
29-
while ($count < $k && $head !== null) {
30-
$head = $head->next;
31-
$count++;
32-
}
33-
if ($count < $k) {
34-
$prevGroupTail->next = $groupHead;
35-
break;
36-
}
37-
38-
$prev = null;
23+
while ($pre !== null) {
24+
$cur = $pre;
3925
for ($i = 0; $i < $k; $i++) {
40-
$next=$groupHead->next;
41-
$groupHead->next=$prev;
42-
$prev=$groupHead;
43-
$groupHead = $next;
26+
if ($cur->next === null) {
27+
return $dummy->next;
28+
}
29+
$cur = $cur->next;
4430
}
45-
$prevGroupTail->next = $prev;
46-
$prevGroupTail = $groupTail;
31+
32+
$node = $pre->next;
33+
$nxt = $cur->next;
34+
$cur->next = null;
35+
$pre->next = $this->reverse($node);
36+
$node->next = $nxt;
37+
$pre = $node;
4738
}
4839

4940
return $dummy->next;
5041
}
42+
43+
/**
44+
* Helper function to reverse a linked list.
45+
* @param ListNode $head
46+
* @return ListNode
47+
*/
48+
function reverse($head) {
49+
$prev = null;
50+
$cur = $head;
51+
while ($cur !== null) {
52+
$nxt = $cur->next;
53+
$cur->next = $prev;
54+
$prev = $cur;
55+
$cur = $nxt;
56+
}
57+
return $prev;
58+
}
5159
}

‎solution/0000-0099/0025.Reverse Nodes in k-Group/Solution.py‎

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -4,28 +4,28 @@
44
# self.val = val
55
# self.next = next
66
class Solution:
7-
def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
8-
def reverseList(head):
9-
pre, p = None, head
10-
while p:
11-
q = p.next
12-
p.next = pre
13-
pre = p
14-
p = q
15-
return pre
7+
def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
8+
def reverse(head: Optional[ListNode]) -> Optional[ListNode]:
9+
dummy = ListNode()
10+
cur = head
11+
while cur:
12+
nxt = cur.next
13+
cur.next = dummy.next
14+
dummy.next = cur
15+
cur = nxt
16+
return dummy.next
1617

17-
dummy = ListNode(next=head)
18-
pre=cur=dummy
19-
whilecur.next:
18+
dummy = pre=ListNode(next=head)
19+
whilepre:
20+
cur=pre
2021
for _ in range(k):
2122
cur = cur.next
2223
if cur is None:
2324
return dummy.next
24-
t = cur.next
25+
node = pre.next
26+
nxt = cur.next
2527
cur.next = None
26-
start = pre.next
27-
pre.next = reverseList(start)
28-
start.next = t
29-
pre = start
30-
cur = pre
28+
pre.next = reverse(node)
29+
node.next = nxt
30+
pre = node
3131
return dummy.next

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /