基础实验3-2.4 出栈序列的合法性(栈和队列的运用c语言)

题目:

给定一个最大容量为 m 的堆栈，将 n 个数字按 1, 2, 3, ..., n 的顺序入栈，允许按任何顺序出栈，则哪些数字序列是不可能得到的？例如给定 m=5、n=7，则我们有可能得到{ 1, 2, 3, 4, 5, 6, 7 }，但不可能得到{ 3, 2, 1, 7, 5, 6, 4 }。

输入格式：

输入第一行给出 3 个不超过 1000 的正整数：m（堆栈最大容量）、n（入栈元素个数）、k（待检查的出栈序列个数）。最后 k 行，每行给出 n 个数字的出栈序列。所有同行数字以空格间隔。

输出格式：

对每一行出栈序列，如果其的确是有可能得到的合法序列，就在一行中输出YES，否则输出NO。

输入样例：

5 7 5
1 2 3 4 5 6 7
3 2 1 7 5 6 4
7 6 5 4 3 2 1
5 6 4 3 7 2 1
1 7 6 5 4 3 2

输出样例：

YES
NO
NO
YES
NO

 注:本人为数据结构的初学者；这道题我费了好几个小时写出来了一种解决方法，感觉很有成就感，所以想记录一下；我也是第一次写博客，如果有什么改进的地方希望大佬们可以指点一下.

代码:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
int m, n;
//声明队列
typedef struct {
    int Data[1000];
    int front, rear;
    int size;
}queue;
//声明栈
typedef struct {
    int data[1000];
    int top;
}stack;
//初始化队列
void Initqueue(queue* q) {
    q->front = 0;
    q->rear = 0;
    q->size = 0;
}
//判断队列是否为空队列
bool qIsempty(queue q) {
    if (q.size == 0)
        return true;
    return false;
}
//入队
void qpush(queue* q, int x) {
    q->Data[q->rear] = x;
    q->rear = (q->rear + 1) % n;
    q->size++;
}
//出队
void qpop(queue* q) {
    q->front = (q->front + 1) % n;
    q->size--;
}
//获取队头元素
int qgettop(queue q) {
    int n = q.Data[q.front];
    return n;
}
//初始化栈
void Initstack(stack* s) {
    s->top = -1;
}
//判断栈是否为空
bool sIsempty(stack s) {
    if (s.top == -1)
        return true;
    return false;
}
//入栈
void spush(stack* s, int x) {
    s->data[++s->top] = x;
}
//出栈
void spop(stack* s) {
    s->top--;
}
//获取栈顶元素
int sgettop(stack s) {
    int x = s.data[s.top];
    return x;
}
int main()
{
    int  k,i, j,x;
    scanf("%d %d %d", &m, &n, &k);
    stack s;
    queue q;
    for (i = 0; i < k; i++)
    {
        int count = 1;
        int flag = 0;//表示状态
        Initstack(&s);//初始化栈
        Initqueue(&q);//初始化队列
        for (j = 0; j < n; j++)
        {
            scanf("%d", &x);
            qpush(&q, x);
        }
        while (1)
        {
            if (s.top == m - 1)//栈满,说明该出栈序列不合法
            {
                flag = 1;
                break;
            }
            spush(&s, count++);
            //如果栈和队列的头元素相同，让其分别出栈和出队
            while (!sIsempty(s) && !qIsempty(q) && sgettop(s) == qgettop(q))
            {
                spop(&s);
                qpop(&q);
            }
            if (sIsempty(s) && qIsempty(q))//1,栈空，队列也空,说明是合法的出栈序列
            {
                break;
            }
            else if (sIsempty(s) && !qIsempty(q))//2,栈空，队列不空就继续循环
                continue;
            //3,栈和队列都不空，比较头元素
            else if (sgettop(s) > qgettop(q))//如果栈的头元素大于队列的头元素，那这个出栈顺序一定不合法
            {
                flag = 1;
                break;
            }
            //如果栈的头元素小于队列的头元素，就继续循环
        }
        if (flag)
            printf("NO\n");
        else
            printf("YES\n");
    }
    return 0;
}

这个题解有一部分的灵感是来源于基础实验3-2.4 出栈序列的合法性（stack和queue的妙用~~~）_出栈序列的合理性的实验报告-CSDN博客