Reversing Linked line

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.\n";
        return;
    }
    else
    {
        x->array[++x->top] = a;
    }
}
int pop(stack*& x)
{
    if (Is_empty(x))
    {
        cout << "The stack is empty.\n";
        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
——————————————————————————————

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

#include<iostream>
#include<stdio.h>
#include<cstring>
using namespace std;
struct node
{
	char add[10];
	int data;
	char nextadd[10];
	node* next;
};
struct stack
{
	node* array;
	int size;
	int top;
};
void creat_stack(stack*& x, int n)
{
	x->array = new node[n];
	memset(x->array, 0, sizeof(node) * 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, node*& a)
{
	if (Is_full(x))
	{
		cout << "The stack is full.\n";
		return;
	}
	else
	{
		strcpy_s(x->array[++x->top].add, 10, a->add);
		x->array[x->top].data = a->data;
		strcpy_s(x->array[x->top].nextadd, 10, a->nextadd);
	}
}
void pop(stack*& x, node*& a)
{
	if (Is_empty(x))
	{
		cout << "The stack is empty.\n";
		exit(0);
	}
	else
	{
		strcpy_s(a->add,10,x->array[x->top].add);
		a->data = x->array[x->top].data;
		strcpy_s(a->nextadd, 10, x->array[x->top--].nextadd);
	}
}
void creat_node(node*& head, int n)
{
	node* s = new node;
	node* p = NULL;
	cin >> s->add >> s->data >> s->nextadd;
	for (int i = 0; i < n; i++)
	{
		if (!head)
		{
			head = s;
			p = s;
		}
		else
		{
			s = new node;
			cin >> s->add >> s->data >> s->nextadd;
			p->next = s;
			p = p->next;
		}
	}
	p->next = NULL;
}
void swap_node(node*& p, node*& q)
{
	node* temp = new node;
	strcpy_s(temp->add, 10, q->add);
	temp->data = q->data;
	strcpy_s(temp->nextadd, 10, q->nextadd);

	strcpy_s(q->add, 10, p->add);
	q->data = p->data;
	strcpy_s(q->nextadd, 10, p->nextadd);

	strcpy_s(p->add, 10, temp->add);
	p->data = temp->data;
	strcpy_s(p->nextadd, 10, temp->nextadd);
}
void sort_node(node*& head, char* add)
{
	node* p = head;
	node* q = head;
	while (strcmp(add, "-1"))
	{
		while (strcmp(p->add , add))
		{
			p = p->next;
		}
		strcpy_s(add,10,p->nextadd);
		swap_node(p, q);
		q = q->next;
		p = head;
	}
}
void reverse_node(node*& head, int n, int k)
{
	stack* s = new stack;
	creat_stack(s, k);
	node* p = head;
	node* q = head;
	node* x = new node;
	int count = 0;
	while (k * ++count <= n )
	{
		for (int i = 0; i < k; i++)
		{
			push(s,p);
			p = p->next;
		}

		pop(s, x);
		strcpy_s(q->nextadd, 10, x->add);
		if (q != head)q = q->next;;
		for (int i = 1; i < k; i++)
		{
			strcpy_s(q->add, 10, x->add);
			q->data = x->data;
			pop(s, x);
			strcpy_s(q->nextadd, 10, x->add);
			q = q->next;
		}
		strcpy_s(q->add, 10, x->add);
		q->data = x->data;
		
	}
}
void read_node(node* head)
{
	while (head)
	{
		cout << head->add << ' ' << head->data << ' ' << head->nextadd << endl;
		head = head->next;
	}
}
int main()
{
	char* head_add = new char[10];
	int n = 0, k = 0;
	cin >> head_add >> n >> k;
	node* head = NULL;
	creat_node(head, n);
	sort_node(head, head_add); 
	reverse_node(head, n, k);
	read_node(head);
}

　　补坑了补坑了，好像写得有点儿乱哎，不知道有没有错。