21 - Reverse Nodes in k-Group

最新推荐文章于 2019-11-06 10:21:50 发布

原创最新推荐文章于 2019-11-06 10:21:50 发布 · 458 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode Interview Questions 同时被 2 个专栏收录

45 篇文章

订阅专栏

C++

45 篇文章

订阅专栏

本文介绍了一种算法问题的解决方案：给定一个链表，按每K个节点一组进行翻转，并返回修改后的链表。讨论了两种方法：使用栈来翻转节点和通过迭代重新链接节点。

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：方法一，用栈保存k个node，如果不够k个则判断是否包含头结点；将满k个结点的栈依次弹出然后就是reverse的结果；循环执行直到结束。

方法二，依次遍历list，将当前node放置在head处即可，用此方法还可以解翻转整个linklist的题。（leetcode论坛上看到的，相当简洁）

方法一，有run time error...死活没找到...lol...感觉逻辑部分没问题，但是其它问题也没找到...纠结了...先pull上来...以后再修改

/**
 * 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) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(k <= 1 || head ==NULL)
            return head;
         
        ListNode *node = head;
        ListNode *newHead = NULL;
        ListNode *pre = NULL;
        vector<ListNode *>rev(k);
        
        while( node != NULL )
        {
            int len = k;
            while(len > 0)
            {
                if(node == NULL)
                {
                    if(newHead == NULL)
                        return head;
                    return newHead;
                }
                rev.push_back( node );
                node = node -> next;
                len --;
            }
            
            while( !rev.empty() )
            {
                if(newHead == NULL)
                {
                    newHead = rev.back();
                    rev.pop_back();
                    pre = newHead;
                }
                else
                {
                    pre -> next = rev.back();
                    pre = pre -> next;
                    rev.pop_back();
                }
            }
            pre -> next = node;
        }
        
        return newHead;
    }
};

方法二：终于通过了

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *reverse(ListNode *pre, ListNode *next)
    {
        ListNode *last = pre -> next;
        ListNode *cur = last -> next;
        
        while( cur != next )
        {
            last -> next = cur -> next;
            cur -> next = pre -> next;
            pre -> next = cur;
            cur = last -> next;
        }
        
        return last;
    }

    ListNode *reverseKGroup(ListNode *head, int k) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if( k <= 1 || head == NULL)
            return head;
        
        ListNode *newHead = new ListNode(0);
        newHead -> next = head;
        
        ListNode *node = head;
        ListNode *pre = newHead;
        
        
        int i = 0;
        while( node != NULL )
        {
            i++;
            if( i == k )
            {
                pre = reverse(pre, node->next);
                node = pre -> next;
                i = 0;
            }
            else
            {
                node = node -> next;
            }
                
        }
        
        return newHead -> next;
    }
};