Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

Example:

Given this linked list: 1->2->3->4->5

For k = 2, you should return: 2->1->4->3->5

For k = 3, you should return: 3->2->1->4->5

Note:

• Only constant extra memory is allowed.
• You may not alter the values in the list's nodes, only nodes itself may be changed.

給出一個連結串列，每 k 個節點一組進行翻轉，並返回翻轉後的連結串列。

k 是一個正整數，它的值小於或等於連結串列的長度。如果節點總數不是 k 的整數倍，那麼將最後剩餘節點保持原有順序。

示例 :

給定這個連結串列：1->2->3->4->5

當 k = 2 時，應當返回: 2->1->4->3->5

當 k = 3 時，應當返回: 3->2->1->4->5

說明 :

• 你的演算法只能使用常數的額外空間。
• 你不能只是單純的改變節點內部的值，而是需要實際的進行節點交換。

48ms

 1 /**
 2  * Definition for singly-linked list.
 3  * public class ListNode {
 4  *     public var val: Int
 5  *     public var next: ListNode?
 6  *     public init(_ val: Int) {
 7  *         self.val = val
 8  *         self.next = nil
 9  *     }
10  * }
11  */
12 class Solution {
13     func reverseKGroup(_ head: ListNode?, _ k: Int) -> ListNode? {
14         let dummyHead = ListNode(0)
15         dummyHead.next = head
16 
17         var previous: ListNode? = dummyHead
18         var first = head
19         var kthNode: ListNode? = first
20         for _ in 1..<k {
21             kthNode = kthNode?.next
22         }
23 
24         while kthNode != nil {
25 
26             let nextNode = kthNode?.next
27 
28             kthNode?.next = nil
29 
30             previous?.next = reverseList(head: first)
31             first?.next = nextNode
32 
33             previous = first
34             first = previous?.next
35             kthNode = first
36             for _ in 1..<k {
37                 kthNode = kthNode?.next
38             }
39 
40         }
41 
42         return dummyHead.next
43     }
44 
45     func reverseList(head: ListNode?) -> ListNode? {
46         var oldList = head
47         var newList: ListNode? = nil
48 
49         while let node = oldList {
50             let nextNode = node.next
51             node.next = newList
52             newList = node
53 
54             oldList = nextNode
55         }
56         return newList
57     }
58 }

52ms

 1 /**
 2  * Definition for singly-linked list.
 3  * public class ListNode {
 4  *     public var val: Int
 5  *     public var next: ListNode?
 6  *     public init(_ val: Int) {
 7  *         self.val = val
 8  *         self.next = nil
 9  *     }
10  * }
11  */
12 class Solution {
13     func reverseKGroup(_ head: ListNode?, _ k: Int) -> ListNode? {
14         if head?.next == nil {
15             return head
16         }
17         let dummy: ListNode? = ListNode(0)
18         dummy!.next = head
19         var pre = dummy, start = dummy, end = dummy
20         while end != nil {
21             end = pre
22             for _ in 0..<k {
23                 end = end?.next
24                 if end == nil {
25                     return dummy?.next
26                 }
27             }
28             for _ in 1..<k {
29                 start = pre!.next
30                 pre!.next = start!.next
31                 start!.next = end!.next
32                 end!.next = start
33             }
34             for _ in 0..<k {
35                 pre = pre!.next
36             }
37         }
38         return dummy!.next
39     }
40 }

56ms

 1 /**
 2  * Definition for singly-linked list.
 3  * public class ListNode {
 4  *     public var val: Int
 5  *     public var next: ListNode?
 6  *     public init(_ val: Int) {
 7  *         self.val = val
 8  *         self.next = nil
 9  *     }
10  * }
11  */
12 class Solution {
13     func reverseKGroup(_ head: ListNode?, _ k: Int) -> ListNode? {
14         let dummyHead = ListNode(0)
15         dummyHead.next = head
16         var previous = dummyHead
17         var start = dummyHead.next
18         var end = start
19         while end != nil {
20             for _ in 0..<k - 1 {
21                 end = end == nil ? nil : end!.next
22             }
23             if end != nil {
24                 let next = end!.next
25                 var newStart = start
26                 while start!.next !== next {
27                     let nextNext = start!.next!.next
28                     previous.next = start!.next
29                     start!.next!.next = newStart
30                     newStart = previous.next
31                     start!.next = nextNext
32                 }
33                 previous = start!
34                 start = next
35                 end = start
36             }
37         }
38         return dummyHead.next
39     }
40 }

60ms

 1 /**
 2  * Definition for singly-linked list.
 3  * public class ListNode {
 4  *     public var val: Int
 5  *     public var next: ListNode?
 6  *     public init(_ val: Int) {
 7  *         self.val = val
 8  *         self.next = nil
 9  *     }
10  * }
11  */
12 class Solution {
13     func reverseKGroup(_ head: ListNode?, _ k: Int) -> ListNode? {
14         if k == 1 {
15             return head
16         }
17         
18         var nextNode = head
19         var prevTail: ListNode?
20         var res: ListNode?
21         while nextNode != nil {
22             var newHead: ListNode?
23             var newTail: ListNode?
24 
25             (newHead, nextNode, newTail) = reverseK(node: nextNode,parent: nil, k: k-1)
26             if res == nil {
27                 res = newHead
28             }
29             prevTail?.next = newHead
30             prevTail = newTail
31             print(newHead?.val, nextNode?.val)
32         }
33         return res
34         
35     }
36     
37     func reverseK(node: ListNode?, parent: ListNode?, k: Int) -> (ListNode?, ListNode?, ListNode?) {
38         if k <= 0 {
39             let temp = node?.next
40             node?.next = parent
41             return (node, temp, nil)
42         } else if node == nil {
43             return (nil, nil, nil)
44         }
45         
46         let (newHead, nextNode, _) = reverseK(node: node?.next, parent: node, k: k-1)
47         
48         if newHead != nil {
49             var tail: ListNode?
50             if parent == nil {
51                 node?.next = nextNode
52                 tail = node
53             } else {
54                 node?.next = parent
55             }
56             return (newHead, nextNode, tail)
57         } else {
58             if parent == nil {
59                 return (node, nil, nil)
60             } else {
61                 return (nil, nil, nil)
62             }
63         }
64     }
65 }

84ms

 1 /**
 2  * Definition for singly-linked list.
 3  * public class ListNode {
 4  *     public var val: Int
 5  *     public var next: ListNode?
 6  *     public init(_ val: Int) {
 7  *         self.val = val
 8  *         self.next = nil
 9  *     }
10  * }
11  */
12 class Solution {
13     func reverseKGroup(_ head: ListNode?, _ k: Int) -> ListNode? {
14         var head:ListNode? = head
15         var current_node:ListNode?  = head
16         var count:Int = 0
17         while(current_node != nil && count != k)
18         {
19             current_node = current_node!.next
20             count++
21         }
22         if count == k
23         {
24             // 遞迴的解決子問題
25             current_node = reverseKGroup(current_node, k)
26             while (count-- > 0)
27             {
28                 var temp:ListNode? = head!.next
29                 head!.next = current_node
30                 current_node = head
31                 head = temp
32             }
33             //最終，該段的所有節點將會截空，head應指向current_node
34             head = current_node
35         }
36         return head
37     }
38 }
39 
40 /*擴充套件Int類，實現自增++、自減--運算子*/
41 extension Int{
42     //字尾++:先執行表示式後再自增
43     static postfix func ++(num:inout Int) -> Int {
44         //輸入輸出引數num
45         let temp = num
46         //num加1
47         num += 1
48         //返回加1前的數值
49         return temp
50     }
51     //字尾--:先執行表示式後再自減
52     static postfix func --(num:inout Int) -> Int {
53         //輸入輸出引數num
54         let temp = num
55         //num減1
56         num -= 1
57          //返回減1前的數值
58         return temp
59     }
60 }