基础实验3-2.4 出栈序列的合法性

给定一个最大容量为 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>

#define MAXN 1000

typedef enum{ false, true } bool;
typedef int ElementType;

/*-----堆栈的定义 -----*/ 
typedef int Position;
typedef struct SNode *PtrToSNode;
struct SNode {
	ElementType *Data;
	Position Top;
	int MaxSize;
};
typedef PtrToSNode Stack;

Stack CreateStack( int MaxSize );
bool IsEmpty( Stack S );
bool IsFull( Stack S );
bool Push( Stack S, ElementType X );
bool Pop( Stack S );
ElementType Peek( Stack S );
void Clear( Stack S );
/*-----堆栈的定义结束 -----*/ 

int main()
{

    int m, n, k, i, j;
    Stack s;
    int a[MAXN];
    scanf("%d%d%d\n",&m,&n,&k);
    s = CreateStack(m);
    
    for(i=0;i<k;i++){
    	Clear(s);
    	bool flag=true;//栈未满标志 
    	for(j=0;j<n;j++)
    		scanf("%d",&a[j]);
    	//5 6 4 3 7 2 1
    	//针对数组第一项，先将小于等于其数值的数压栈 
    	int tmp=1;
		while(tmp<=a[0])
			Push(s,tmp++);
			
    	for(j=0;j<n;j++){//循环判断数组中每个元素 
    		
    		while(1){
    			if(Peek(s)==a[j]){
    				Pop(s);
    				break;
				}else{
					//不相等就继续压栈下一位数据，再对比直到栈满 
					flag=Push(s,tmp++);
				}
				if(flag==false)//如果栈满，证明该数列匹配不成功，可以退出了 
					break;	
			}
			if(flag==false)
				break;
    		
		}
		if(!flag||!IsEmpty(s)) 
    		printf("NO\n");
    	else
    		printf("YES\n");
	}
    
    return 0;
}
Stack CreateStack( int MaxSize )
{
	Stack S = (Stack)malloc(sizeof(struct SNode));
	S->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
	S->Top = -1;
	S->MaxSize = MaxSize;
	return S;
}

bool IsEmpty( Stack S )
{
	return (S->Top == -1);
}

bool IsFull( Stack S )
{
	return (S->Top == (S->MaxSize-1));
}

bool Push( Stack S, ElementType X )
{
	if ( IsFull(S) ) return false;
	else  {
		S->Data[++(S->Top)] = X;
		return true;
	}
}

bool Pop( Stack S )
{
	if ( IsEmpty(S) ) return false;
	else {
		(S->Top)--;
		return true;
	}
}
ElementType Peek( Stack S )
{
	return ( S->Data[S->Top] );
}
void Clear( Stack S )
{
	while ( !IsEmpty(S) ) Pop(S);
}