算法-旋转链表(每个节点都向右移动n个位置,再重新返回该链表)

样例:

      [1,2,3,4,5],n = 2  -->[4,5,1,2,3]

思路&代码

获取链表长度表示m,并且使用q指向链表尾部,并让尾节点指向head，形成一个闭环链表,另外由题n的数据是未知数,不知道要移动多少次,但是n可能小于m，也可能大于m(存在整数倍并且取结余数值，就是移动的次数),所以n = n %m。最后从头遍历移动m - n - 1 次，找到新链表头节点的前驱节点,假设定义为p, 代码表示:

  q.next = head

  head = p.next

  p.next = nil

代码:

package main

import "fmt"

type ListNode struct {
	Val  int
	Next *ListNode
}

func rotateRight(head *ListNode, k int) *ListNode {
	if head == nil {
		return nil
	}
	if k == 0 {
		return head
	}
	var p, t *ListNode = nil, nil
	n := 1 // link len
	for p = head; p.Next != nil; p = p.Next {
		n++
	}
	t = p // 指向尾部节点

	k %= n // 需要移动的次数,k可能很大,最终整数倍之后的结余就是移动的次数,故而 k % n
	// 头节点移动n - k - 1个位置,找到新的头节点的前驱节点
	p = head
	for i := 0; i < n-k-1; i++ {
		p = p.Next
	}
	t.Next = head // 形成闭环,链表
	head = p.Next
	p.Next = nil
	return head
}

func (l *ListNode) Display() {
	for h := l; h != nil; h = h.Next {
		fmt.Println(h.Val)
	}
	fmt.Println("----------")
}

func main() {
	root := &ListNode{
		Val: 1, Next: nil,
	}
	var t *ListNode
	t = root
	n := &ListNode{
		Val: 2, Next: nil,
	}
	t.Next = n
	t = t.Next

	n = &ListNode{
		Val: 3, Next: nil,
	}
	t.Next = n
	t = t.Next

	n = &ListNode{
		Val: 4, Next: nil,
	}
	t.Next = n
	t = t.Next

	// n = &ListNode{
	// 	Val: 5, Next: nil,
	// }
	// t.Next = n
	// t = t.Next

	root.Display()

	rotateRight(root, 5).Display()
}