Reversing Linked line

Posted 2020-12-12 waiting-nobody

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.
小白白先写一小段代码：

#include<iostream>
using namespace std;
struct node
{
    int data;
    node* next;
};
struct stack
{
    int* array;
    int size;
    int top;
};
void creat_stack(stack*& x, int n)
{
    x->array = new int[n];
    memset(x->array, 0, sizeof(int) * n);
    x->size = n;
    x->top = -1;
}
bool Is_empty(stack*& x)
{
    return (x->top == -1);
}
bool Is_full(stack*& x)
{
    return (x->top == x->size - 1);
}
void push(stack*& x, int a)
{
    if (Is_full(x))
    {
        cout << "The stack is full.
";
        return;
    }
    else
    {
        x->array[++x->top] = a;
    }
}
int pop(stack*& x)
{
    if (Is_empty(x))
    {
        cout << "The stack is empty.
";
        exit(0);
    }
    else
    {
        return x->array[x->top--];
    }
}
void creat_node(node*& head, int n)
{
    node* s = new node;
    node* p = new node;
    cin >> s->data;
    for (int i = 0; i < n; i++)
    {
        if (!head)
        {
            head = s;
            p = s;
        }
        else
        {
            s = new node;
            cin >> s->data;
            p->next = s;
            p = p->next;
        }
    }
    p->next = NULL;
}
void reverse(node*& head, int n, int k)
{
    stack* s = new stack;
    creat_stack(s, k);
    node* p = head;
    node* q = head;
    int count = 0;
    while (k * ++count <= n && p && q)
    {
        for (int i = 0; i < k; i++)
        {
            push(s, p->data);
            p = p->next;
        }
        for (int i = 0; i < k; i++)
        {
            q->data = pop(s);
            q = q->next;
        }
    }
}
void read_node(node* head)
{
    while (head)
    {
        cout << head->data;
        head = head->next;
        if (head)cout << "->";
    }
    cout << endl;
}
int main()
{
    int n = 0, k = 0;
    cin >> n >> k;
    node* head = NULL;
    creat_node(head,n);
    reverse(head, n, k);
    read_node(head);
}

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.

Sample Input:

00100 6 4

00000 4 99999

00100 1 12309

68237 6 -1

33218 3 00000

99999 5 68237

12309 2 33218

Sample Output:

00000 4 33218

33218 3 12309

12309 2 00100

00100 1 99999

99999 5 68237

68237 6 -1
——————————————————————————————

被卡住了嘤嘤嘤，有空再来补坑