2021-03-27: Vous donnez le nœud principal d'une liste liée, faites pivoter la liste liée et déplacez chaque nœud de la liste liée k positions vers la droite. Entrée: tête = 1 → 2 → 3 → 4 → 5, k = 2, sortie: 4 → 5 → 1 → 2 → 3.
Réponse de Fu Da 2020-03-27:
1. Trouvez le nœud de queue et comptez le nombre de nœuds dans la liste liée.
2. Si k est supérieur au nombre de nœuds dans la liste à liens égaux, il doit être modulo, et k doit être compris dans la plage de [0, nombre de nœuds). Si k = 0, retournez directement au nœud principal.
3. Trouvez le nœud de l'inverse k + 1.
4. Mettez en cache le kième nœud et depuis le bas.
5. Le nœud de queue est connecté au nœud de tête.
6. Le pointeur Next du nœud réciproque k + 1 est vide.
7. Revenez à ans.
Le code est écrit en golang, le code est le suivant:
package main
import "fmt"
func main() {
head := &ListNode{Val: 1}
head.Next = &ListNode{Val: 2}
head.Next.Next = &ListNode{Val: 3}
head.Next.Next.Next = &ListNode{Val: 4}
printlnLinkNodeList(head)
k := 6
fmt.Println("k =", k)
fmt.Println("----------------")
ret := rotateRight(head, k)
printlnLinkNodeList(ret)
}
type ListNode struct {
Val int
Next *ListNode
}
func rotateRight(head *ListNode, k int) *ListNode {
if head == nil {
return head
}
//找尾节点并且计数
cnt := 1
tail := head
for tail.Next != nil {
cnt++
tail = tail.Next
}
k = k % cnt
if k == 0 { //刚好是头节点，就不用操作了。
return head
}
//找倒数第k+1节点
fast := head
slow := head
k++
for k > 0 {
fast = fast.Next
k--
}
for fast != nil {
fast = fast.Next
slow = slow.Next
}
//缓存结果
ans := slow.Next
//尾节点连头节点
tail.Next = head
//倒数k+1节点无Next指针
slow.Next = nil
return ans
}
//链表打印
func printlnLinkNodeList(head *ListNode) {
cur := head
for cur != nil {
fmt.Print(cur.Val, "\t")
cur = cur.Next
}
fmt.Println()
}Les résultats de l'exécution sont les suivants: