将单链表的每K个节点之间逆序

【说明】：

　　本文是左程云老师所著的《程序员面试代码指南》第二章中“将单链表的每K个节点之间逆序”这一题目的C++复现。

　　本文只包含问题描述、C++代码的实现以及简单的思路，不包含解析说明，具体的问题解析请参考原书。

　　感谢左程云老师的支持。

【题目】：

　　给定一个单链表的头节点 head，实现一个调整单链表的函数，使得每K个节点之间逆序，如果最后不够K个节点一组，则不调整最后几个节点。

　　例如：

　　链表：1->2->3->4->5->6->7->8->NULL，K = 3.

　　调整后为：3->2->1->6->5->4->7->8->NULL。其中7、8不调整，因为不够一组。

 【思路】：

　　解法一：使用栈，每K个清空栈来进行逆序。

　　解法二：需要保存即将逆序的K个节点的前一个节点pre和后一个节点next

【编译环境】：

　　CentOS6.7（x86_64）

　　gcc 4.4.7

 【实现】：

　　实现及测试代码：

/*
 *文件名：list_reverse.cpp
 *作者：
 *摘要：将单链表的每K个节点之间逆序
 */

#include <iostream> 
#include <stack>

using namespace std;

class Node
{
public:
    Node(int data)
    {
        value = data;
        next = NULL;
    }
public:
    int value;
    Node *next;
};

Node* resign1(stack<Node*> &s,Node *left,Node *right)
{
    Node *cur = s.top();
    s.pop();
    if(NULL != left)
        left->next = cur;
    Node *next = NULL;
    while(!s.empty())
    {
        next = s.top();
        s.pop();
        cur->next = next;    //反转
        cur = next;
    }
    cur->next = right;
    return cur;
}

Node* reverseKNodes1(Node *head,int K)
{
    if(K < 2)
        return head;
    stack<Node*> s;
    Node *newHead(head),*cur(head),*pre(NULL),*next(NULL);
    while(NULL != cur)
    {
        next = cur->next;
        s.push(cur);
        if(s.size() == K)
        {
            pre = resign1(s,pre,next);
            newHead = newHead == head ? cur : newHead;
        }
        cur = next;
    }
    return newHead;
}

void resign2(Node *left,Node *start,Node *end,Node* right)
{
    Node *pre = start;
    Node *cur = start->next;
    Node *next = NULL;
    while(cur != right)
    {
        next = cur->next;
        cur->next = pre;
        pre = cur;
        cur = next;
    }
    if(NULL != left)
        left->next = end;
    start->next = right;
}

Node* reverseKNodes2(Node *head,int K)
{
    if(2 > K)
        return head;
    Node *cur(head),*start(NULL),*pre(NULL),*next(NULL);
    int count = 1;
    while(NULL != cur)
    {
        next = cur->next;
        if(count == K)
        {
            start = pre == NULL ? head : pre->next;
            head = pre == NULL ? cur : head;    //第一次发生变化的时候确定head
            resign2(pre,start,cur,next);
            pre = start;
            count = 0;
        }
        count++;
        cur = next;
    }
    return head;
} 

void printList(Node *head)
{
    while(NULL != head)
    {
        cout << head->value << " ";
        head = head->next;
    }
    cout << endl;
}

int main()
{
    Node *head = NULL;
    Node *ptr = NULL;
    
    for(int i =1;i<9;i++)//构造链表
    {
        if(NULL == head)
        {    
            head = new Node(i);
            ptr = head;
            continue;
        }
        ptr->next = new Node(i);
        ptr = ptr->next;
    }
    cout << "Before reverse:" << endl;
    printList(head);
    cout << "First reverse:" << endl;
    head = reverseKNodes1(head,3);
    printList(head);
    cout << "Second reverse:" << endl;
    head = reverseKNodes2(head,3);
    printList(head);
    return 0;
}

注：

　　转载请注明出处；

　　转载请注明源思路来自于左程云老师的《程序员代码面试指南》。