LeetCode每日一题(Reverse Nodes in k-Group)

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.

You may not alter the values in the list's nodes, only nodes themselves may be changed.

Example 1:

Input: head = [1,2,3,4,5], k = 2
Output: [2,1,4,3,5]

Example 2:

Input: head = [1,2,3,4,5], k = 3
Output: [3,2,1,4,5]

Example 3:

Input: head = [1,2,3,4,5], k = 1
Output: [1,2,3,4,5]

Example 4:

Input: head = [1], k = 1
Output: [1]

Constraints:

• The number of nodes in the list is in the range sz.
• 1 <= sz <= 5000
• 0 <= Node.val <= 1000
• 1 <= k <= sz

Follow-up: Can you solve the problem in O(1) extra memory space?

这个方法空间复杂度O(1)是达到了，但是遍历的次数也增多了， 算不出时间复杂度，有懂的大神麻烦给算一下。这个方法其实就是递归中嵌套遍历， 然后加上末尾条件判断，如果末尾够不成一组，则将已经反向的剥离出来的链表再反向就可以了。实在是不知道不用unsafe该怎么写， 有更好办法可以留言给我，大家共同学习。

impl Solution {
    fn reverse(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
        if head.is_none() {
            return None;
        }
        let remain = head.as_mut().unwrap().next.take();
        let next = Solution::reverse(remain);
        Solution::append(next, head)
    }

    fn append(mut head: Option<Box<ListNode>>, node: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
        if head.is_none() {
            return node;
        }
        unsafe {
            let mut p: *mut Option<Box<ListNode>> = &mut head;
            while (*p).as_mut().unwrap().next.is_some() {
                p = &mut (*p).as_mut().unwrap().next;
            }
            (*p).as_mut().unwrap().next = node;
        }
        head
    }

    fn rc(mut head: Option<Box<ListNode>>, k: i32, mut prev: Option<Box<ListNode>>, curr: i32) -> Option<Box<ListNode>> {
        if head.is_none() {
            return Solution::reverse(prev);
        } else {
            let remain = head.as_mut().unwrap().next.take();
            prev = Solution::append(head, prev);
            if curr == k {
                let next = Solution::rc(remain, k, None, 1);
                return Solution::append(prev, next);
            } else {
                return Solution::rc(remain, k, prev, curr + 1);
            }
        }
    }
    pub fn reverse_k_group(head: Option<Box<ListNode>>, k: i32) -> Option<Box<ListNode>> {
        Solution::rc(head, k, None, 1)
    }
}