数据结构实验之栈七：出栈序列判定(顺序栈)

Think:
好早前的题， 之前应该也有写过这篇blog，好讨厌写栈和顺序表的题，虽然都有模板套用，但真的好长好长， 方法主要 有两种
①借助 <stack>来水题
②用模拟栈来做

Problem Description

给一个初始的入栈序列，其次序即为元素的入栈次序，栈顶元素可以随时出栈，每个元素只能入栈依次。输入一个入栈序列，后面依次输入多个序列，请判断这些序列是否为所给入栈序列合法的出栈序列。
例如序列1，2，3，4，5是某栈的压入顺序，序列4，5，3，2，1是该压栈序列对应的一个出栈序列，但4，3，5，1，2就不可能是该序列的出栈序列。假设压入栈的所有数字均不相等。
Input

第一行输入整数n(1<=n<=10000)，表示序列的长度。
第二行输入n个整数，表示栈的压入顺序。
第三行输入整数t（1<=t<=10）。
后面依次输入t行，每行n个整数，表示要判断的每一个出栈序列。
Output

对应每个测试案例输出一行，如果由初始入栈序列可以得到该出栈序列，则输出yes，否则输出no。
Example Input

5
1 2 3 4 5
2
4 5 3 2 1
4 3 5 1 2
Example Output

yes
no

#include<bits/stdc++.h>
using namespace std;
#define STACK_INIT_SIZE 1050
#define STACKINCREMENT 50
#define ERROR 0
//#define OK 1
//#define OVERFLOW -1
typedef int Elemtype;
typedef struct
{
    Elemtype *base;
    Elemtype *top;
    int stacksize;
}sqstack;

int a[10086];
int b[10086];

void Initstack(sqstack &L);
void Push(sqstack &L, Elemtype key);
int Pop(sqstack &L);
int Gettop(sqstack &L);
void Clearstack(sqstack &L);
bool Ifempty(sqstack &L);

int main()
{
    int n;
    int i, j, T;
//    int key;
    while(cin >> n)
    {
        memset(a, 0, sizeof(a));
        memset(b, 0, sizeof(b));
        for (i = 0; i <= n - 1; i ++)
        {
            cin >> a[i];
        }
        cin >> T;
        while(T --)
        {
            sqstack L;
            Initstack(L);
            Clearstack(L);  //清空栈
            for (i = 0; i <= n - 1; i ++)
            {
                cin >> b[i];
            }
            i = j = 0;
            while(j < n)
            {
                if (a[i] == b[j])  //元素相同直接判断下一位
                {
                    i ++;
                    j ++;
                }
                else if(!Ifempty(L) && Gettop(L) == b[j]) // 栈顶元素相同出栈
                {
                    Pop(L);
                    j ++;
                }
                else if(i < n)  //元素不同 将元素压入栈中 直至匹配相同
                {
                    Push(L, a[i]);
                    i ++;
                }
                else
                    break;

            }

            if(Ifempty(L))  //若处理到最后 栈为空 则说明合法 反之不合法
                cout << "yes" << endl;
            else
                cout << "no" << endl;
        }
    }
}


void Initstack(sqstack &L)
{
    L.base = (Elemtype *)malloc(STACK_INIT_SIZE * sizeof(Elemtype));
    if (!L.base)
        exit(-1);
    else
        L.top = L.base;
        L.stacksize = STACK_INIT_SIZE;
}

void Push(sqstack &L, Elemtype key)
{
    if(L.top - L.base >= L.stacksize)
    {
        L.base = (Elemtype *)realloc(L.base, (L.stacksize + STACKINCREMENT)*sizeof(Elemtype));
        if(!L.base)
        {
            exit(-1);
        }
        L.top = L.base + L.stacksize;
        L.stacksize += STACKINCREMENT;
    }
    *L.top ++ = key;
}

int Pop(sqstack &L)
{
    if (L.top == L.base)
    {
        return ERROR;
    }
        L.top --;
        return 1;
}

int Gettop(sqstack &L)
{
    if (L.top == L.base)
        return ERROR;

        return *(L.top - 1);

}

void Clearstack(sqstack &L)
{
    L.top = L.base;
}

bool Ifempty(sqstack &L)
{
    if (L.base == L.top)
        return true;
    else
        return false;
}