LeetCode

Reverse Nodes in k-Group

2014.2.26 23:37

Given a linked list, reverse the nodes of a linked list k at a time and return its modified 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 nodes, only nodes itself may be changed.

Only constant memory is allowed.

For 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

Solution:

　　The idea is simple for this problem: find the next k-group, reverse it and put it back.

　　All you have to worry about is careful coding.

　　Total time complexity is O(n). Space complexity is O(1).

Accepted code:

// 1RE, 1AC, good.
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        if (head == nullptr || k < 2) {
            // no change at all
            return head;
        }
        ListNode *bh, *h, *t, *at;
        
        bh = nullptr;
        h = head;
        int i;
        while (true) {
            if (h == nullptr) {
                break;
            }
            t = h;
            for (i = 1; i < k; ++i) {
                t = t->next;
                if (t == nullptr) {
                    break;
                }
            }
            if (i == k) {
                at = t->next;
                t->next = nullptr;
                reverseList(h, t);
                if (bh != nullptr) {
                    // put the segment in place again
                    bh->next = h;
                    t->next = at;
                } else {
                    // the first group will change the head of the list
                    head = h;
                    t->next = at;
                }
                // find the next group
                bh = t;
                h = at;
            } else {
                break;
            }
        }
        
        
        return head;
    }
private:
    void reverseList(ListNode *&h, ListNode *&t) {
        if (h == nullptr || t == nullptr) {
            // impossible
            return;
        }
        if (h == t) {
            // only one node
            return;
        }
        
        ListNode *new_h, *new_t;
        ListNode *ptr, *tmp;
        
        new_h = nullptr;
        ptr = h;
        while (ptr != nullptr) {
            if (new_h == nullptr) {
                new_h = new_t = ptr;
                ptr = ptr->next;
                new_h->next = nullptr;
            } else {
                tmp = ptr->next;
                ptr->next = new_h;
                new_h = ptr;
                ptr = tmp;
            }
        }
        
        h = new_h;
        t = new_t;
    }
};