02-线性结构3 Reversing Linked List

Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 1→2→3→4→5→6, if K=3, then you must output 3→2→1→6→5→4; if K=4, you must output 4→3→2→1→5→6.

Input Specification:

Each input file contains one test case. For each case, the first line contains the address of the first node, a positive N (≤10​5​​) which is the total number of nodes, and a positive K (≤N) which is the length of the sublist to be reversed. The address of a node is a 5-digit nonnegative integer, and NULL is represented by -1.

Then N lines follow, each describes a node in the format:

Address Data Next

where Address is the position of the node, Data is an integer, and Next is the position of the next node.

Output Specification:

For each case, output the resulting ordered linked list. Each node occupies a line, and is printed in the same format as in the input.

#include <iostream>
#include <map>
#include <cstdio>
#include <stack>

class Node{
public:
    int next;   //下一个的地址
    int data;   //数据
    int self;   //自己的地址
};

using namespace std;

void print(Node node, int &count){   //count 用于判断是不是到了第一个节点
    if(++count != 1) printf(" %05d\n", node.self);
    printf("%05d %d", node.self, node.data);
}

int main()
{   
    //处理输入信息
    map<int, Node> node;       //第一个为地址，第二个为节点
    int N, K, Address;
    cin >> Address >> N >> K;
    int total = N;
    while(total--){
        Node tmp;
        cin >> tmp.self >> tmp.data >> tmp.next;
        node[tmp.self] = tmp;
    }
    //剩余的节点数小于k时不反转，直接输出
    //用栈放入K个节点，反转输出后，重复操作
    stack<Node> stk;
    int addr = Address;
    int count = 0;
    while(addr != -1){    
        int interval = K;
        while(interval-- && addr != -1){
            if(node.find(addr) != node.end()){
                stk.push(node[addr]);
                addr = node[addr].next;
            }
        }
        //两种情况：stk.size() == K 和 stk.size() != K
        if(stk.size() == static_cast<unsigned int>(K)){
            while(!stk.empty()){
                Node tmp = stk.top();
                print(tmp, count);
                stk.pop();
            }
        }else{
            //在反转stk
            stack<Node> tmpStk;
            while(!stk.empty()){
                tmpStk.push(stk.top());
                stk.pop();
            }
            while(!tmpStk.empty()){
                Node tmp = tmpStk.top();
                print(tmp, count);
                tmpStk.pop();
            }
        }
        
    }
     //最后一个输出-1
     printf(" -1");

    return 0;
}