1
2
3
4
5

输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL

1
2
3
4
5
6
7

输入: 0->1->2->NULL, k = 4
输出: 2->0->1->NULL
解释:
向右旋转 1 步: 2->0->1->NULL
向右旋转 2 步: 1->2->0->NULL
向右旋转 3 步: 0->1->2->NULL
向右旋转 4 步: 2->0->1->NULL

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

impl Solution {
    pub fn rotate_right(head: Option<Box<ListNode>>, k: i32) -> Option<Box<ListNode>> {
        //
        if head.is_none() || k <= 0 { return head }  

        //遍历获取总节点数
        let mut ptr: Option<&Box<ListNode>> = head.as_ref();
        let mut node_count: i32 = 0;
        //遍历获取总结点数
        while let Some(node) = ptr {
            node_count += 1;
            ptr = node.next.as_ref();
        }

        //获取截断结点数
        let cut_nodes = node_count - k % node_count;
        if cut_nodes == node_count {
            return head;
        }

        //获取截断点上一个结点可变借用
        /*
                        ptr      
                        |     
        head: 1 -> 2 -> 3 -> 4 -> 5 -> NULL
        */
        let mut head = head;
        let mut ptr: &mut Box<ListNode> = head.as_mut().unwrap();
        for _ in 0..cut_nodes-1 {
            ptr = ptr.next.as_mut().unwrap(); 
        }

        //通过上一个节点释放并重新获取截断结点所有权
        /*
                        ptr      
                        |     
        head: 1 -> 2 -> 3    
        new_head: 4 -> 5 -> NULL
        */
        let mut new_head: Option<Box<ListNode>> = ptr.next.take();


        /*
        head: 1 -> 2 -> 3    
                  ptr
                  |
        new_head: 4 -> 5 -> NULL
        */
        //
        let mut ptr: Option<&mut Box<ListNode>>  = new_head.as_mut();  
        /*
        head: 1 -> 2 -> 3    
                       ptr
                       | 
        new_head: 4 -> 5 -> NULL
        */
        //
        while let Some(node) = ptr {  
            if node.next.is_none() { 
                ptr = Some(node); 
                break; 
            }  
            ptr = node.next.as_mut();  
        }  

        /*
                       ptr
                       |
        new_head: 4 -> 5 -> 1 -> 2 ->
        */
        //new_head最后节点的next获得head所有权
        ptr.unwrap().next = head;   

        new_head  
    }
}