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.
go語言代碼：
package main
import "fmt"
type ListNode struct {
Val int
Next *ListNode
}
// 一段一段反轉，然後連接
func reverseKGroup(head *ListNode, k int) *ListNode {
if head == nil {// 判斷輸入參數
return nil
}
if k == 1 {
return head
}
nodes := make([]ListNode, k)
headCopy := head
for i := 0; i < k; i++ {
if head != nil {
nodes[i] = *head
head = head.Next
} else {
return headCopy
}
}
headNew := reverseListNode(nodes, k) //反轉一段
tailHeadNew := tailOfList(headNew)
tailHeadNew.Next = reverseKGroup(head, k)// 連接後一段
return headNew
}
func reverseListNode(nodes []ListNode, len int) *ListNode {
if len == 1 {
return &nodes[0]
}
for i := len - 2; i >= -1; i-- {
if i >= 0 {
nodes[i+1].Next = &nodes[i]
} else {
nodes[i+1].Next = nil
}
}
return &nodes[len - 1]
}
func tailOfList(head *ListNode) *ListNode {
for {
if head.Next == nil {
break;
}
head = head.Next
}
return head
}
func main() {
node1 := ListNode{1,nil}
node2 := ListNode{2,nil}
node3 := ListNode{3,nil}
node4 := ListNode{4,nil}
node5 := ListNode{5,nil}
node1.Next = &node2
node2.Next = &node3
node3.Next = &node4
node4.Next = &node5
nodeNew := reverseKGroup(&node1, 2)
fmt.Println(*nodeNew)
}