Pop Sequence（C语言版 + 注释 + 栈）

Given a stack which can keep M numbers at most. Push N numbers in the order of 1, 2, 3, ..., N and pop randomly. You are supposed to tell if a given sequence of numbers is a possible pop sequence of the stack. For example, if M is 5 and N is 7, we can obtain 1, 2, 3, 4, 5, 6, 7 from the stack, but not 3, 2, 1, 7, 5, 6, 4.

Input Specification:

Each input file contains one test case. For each case, the first line contains 3 numbers (all no more than 1000): M(the maximum capacity of the stack), N (the length of push sequence), and K (the number of pop sequences to be checked). Then K lines follow, each contains a pop sequence of N numbers. All the numbers in a line are separated by a space.

Output Specification:

For each pop sequence, print in one line "YES" if it is indeed a possible pop sequence of the stack, or "NO" if not.

Sample Input:

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

Sample Output:

YES
NO
NO
YES
NO

这题并不会写，参考了一个博主的。我就按自己的理解写一个注释吧。

关键之处：

• 题目意思：
  • M是指堆栈最多能存放元素的个数，5表示最多能放5个元素；N表示序列元素的个数，7表示我的数列有7个数；K是指做我要判断几组序列。
  • 给定一个大小为N的顺序数列，我们输入它的输出顺序，看看是否符合“先入后出”的规则，正确则“YES”，否则“NO”。
•  

代码： 

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 1000

typedef int Position;
typedef struct SNode *Stack;    //把栈的结构体类型定义成结构体指针。
/*把data[MAXSIZE]分成*data和MaxSize可以在创建栈的时候灵活控制栈的大小*/
struct SNode {
	int *data;    //数据域数组，写成*data形式是为了下面的MaxSize。
	Position top;    //栈顶位置。
	int MaxSize;    //data数组的大小，也可以说是栈的大小。
};

Stack CreateStack( int );
int CompareStack ( int *, int *, int, int );
int IsFull ( Stack S );
int IsEmpty ( Stack S );
void Push( Stack S, int item );
void Push( Stack S, int item );

int main(void) {
	int M, N, K, i;
    /*Original[]是递增的原序列，This[]是我们输入的序列*/
	int Original[MAXSIZE], This[MAXSIZE];
	
	scanf("%d %d %d", &M, &N, &K);
    /*建立一个递增原序列，如：1 2 3 4 5 6 7*/
	for ( i = 0; i < N; i++ )
		Original[i] = i + 1;
    /*检测 K 组序列*/
	while ( K-- ) {
		for ( i = 0; i < N; i++ )    //输入检测序列
			scanf("%d", &This[i]);
		if ( CompareStack(Original, This, M, N) )    //判断序列是否符合堆栈规则。
			printf("YES\n");
		else
			printf("NO\n");
	}
	
	return 0;
}
/*建立堆栈的函数，返回值是Stack*/
Stack CreateStack( int MaxSize ) {
	Stack S;
	S = (Stack)malloc(sizeof(struct SNode));    //构建堆栈空间。
	S->data = (int *)malloc(MaxSize*sizeof(int));    //data[]的大小是MaxSize个int。
	S->top = -1;    //top指针置空。
	S->MaxSize = MaxSize;    //堆栈大小也确定一下。
	return S;
}

int IsFull ( Stack S ) {
	return ( S->top == S->MaxSize-1 );    //如果top指针在数组最后一个位置，返回1.
}

int IsEmpty ( Stack S ) {
	return ( S->top == -1 );    //top指针等于-1，返回1.
}

void Push( Stack S, int item ) {
	if ( IsFull(S) )	printf("Full!!\n");
	else	S->data[++S->top] = item;    //先移top再存入数。
}

int Pop ( Stack S ) {
	if ( IsEmpty(S) )	return 0;
	else	return ( S->data[S->top--] );    //先输出数，再移top.
}
/*对比两个序列的函数*/
int CompareStack ( int *Original, int *This, int M, int N ) {
	int compare, ptr, num;
	Stack S;
	
	compare = 0, ptr = 0;    //compare指针指向待比较数列，ptr指针指向原序列。
	S = CreateStack( M );    //建立一个大小为M的堆栈。
	while ( compare < N ) {
		if ( ptr >= N )	ptr = N-1;
		if ( This[compare] > Original[ptr] ) {    //This的元素大于原序列元素，压入栈中。  
			if ( IsFull(S) )	return 0;
			else	Push( S, Original[ptr++] );
		} else if ( This[compare] == Original[ptr] ) {    //相等，push之后马上pop出来。
			if ( IsFull(S) )	return 0;
			else {
				Push ( S, Original[ptr++] );
				Pop( S );
				compare++;
			}
		} else {    //This小于原序列。
			if ( IsEmpty(S) )	return 0;
			else {
				num = Pop(S);    //把应出栈的数存起来。
				if ( num == This[compare] )	compare++;    //和待检测序列相比，相等则继续比较。
				else return 0;    //不等，说明待检测序列有问题。
			}
		}
	}
	return 1;
}