Leetcode（25）- k个一组翻转链表

给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么将最后剩余节点保持原有顺序。

示例 :

给定这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

说明 :

• 你的算法只能使用常数的额外空间。
• 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

思路：前面有个题目是两两交换链表中的节点，那个我就不写了，因为只涉及到链表节点交换的指针指向问题，需要注意的点是头结点的处理，还有交换完之后变换指向的问题。现在这个问题是要交换k个节点，不满k个节点的不处理。既然要把k个节点反向，很容易想到栈的结构，但是如果不满k个的时候，又还要正向，所以我又加了队列这个结构。实现起来麻烦了点，但是所幸实现了，注意的点依然是头结点的处理。

ListNode* reverseKGroup(ListNode* head, int k)
    {
        if(!head) return NULL;
        ListNode* newhead,*newcur;
    newhead=NULL;
        stack<ListNode*> temp;
    queue<ListNode*> q;
        ListNode* cur;
        cur=head;
    while(cur)
        {
            if(temp.size()!=k)
        {
                temp.push(cur);
        q.push(cur);
        }
            else
            {
                while(!temp.empty())
                {
                    if(!newhead)
                    {
            newhead=new ListNode(temp.top()->val);
                        newcur=newhead;
                    }
                    else
                    {
                        newcur->next=new ListNode(temp.top()->val);
            newcur=newcur->next;
                    }
                    temp.pop();
            q.pop();
                }
        continue;
            }
            cur=cur->next;
        }
    if(temp.size()==k)
    {
        while(!temp.empty())
                {
                    if(!newhead)
                    {
            newhead=new ListNode(temp.top()->val);
                        newcur=newhead;
                    }
                    else
                    {
                        newcur->next=new ListNode(temp.top()->val);
            newcur=newcur->next;
                    }
                    temp.pop();
                }
    }
    else
    {
        while(!q.empty())
        {
            if(!newhead)
                    {
            newhead=new ListNode(q.front()->val);
                        newcur=newhead;
                    }
                    else
                    {
                        newcur->next=new ListNode(q.front()->val);
            newcur=newcur->next;
                    }
                    q.pop();
                }
    }
        return newhead;
    }

我看着都爆炸，因为我忽略了，既然同时涉及正向与反向的问题，我反而不如直接用vector结构，更加省事。满k个的时候，反向遍历添加节点，个数不足k的时候，正向遍历添加节点。

 ListNode* reverseKGroup(ListNode* head, int k)
{
        ListNode* newHead = NULL, *cur = NULL;
        while (head)
        {
            vector<ListNode*> nodes;
            while (nodes.size() < k && head)
            {
                nodes.push_back(head);
                head = head->next;
            }
            if (nodes.size() == k)
            {
                for (int i = k - 1;i >= 0;--i)
                {
                    if (i > 0)
                    {
                        nodes[i]->next = nodes[i-1];
                    }
                    else
                    {
                        nodes[i]->next = head;
                    }
                }
                if (newHead == NULL)
                {
                    newHead = nodes[k-1];
                }
                if (cur)
                {
                    cur->next = nodes[k-1];
                }
                cur = nodes[0];
            }
            else
            {
                if (newHead == NULL)
                {
                    newHead = nodes[0];
                }
                if (cur)
                {
                    cur->next = nodes[0];
                }
                cur = nodes.back();
            }
        }
        return newHead;
    }