pop序列可行性的判别算法

Question

最近在学习数据结构，在浙江大学的公开课《数据结构》上有道题要求判断在给定栈大小的情况下pop序列是否可行，然后我的代码如下：

#include <stdio.h>
#include <stdlib.h>

#define OVERFLOW -1
#define TRUE    1
#define FALSE   0

typedef struct stack{
    int *data;
    int top;
    int len;
}stk, *stk_ptr;

stk_ptr new_stk(int len);
int push(stk_ptr p, int elem);
int pop(stk_ptr p);
int **get_data(int *stk_len, int *seq_len, int *seq_num);
int check(stk_ptr stk, int* list, int len);
void set_empty(stk_ptr p);
void output(int* result, int len);

int main(){
    int stk_len, seq_len, seq_num, i;
    int *result;
    int **data;
    stk_ptr stack;
    data = get_data(&stk_len, &seq_len, &seq_num);
    stack = new_stk(stk_len);
    result = (int*)malloc(sizeof(int)*seq_num);

    for(i = 0; i < seq_num; i++){
        result[i] = check(stack, data[i], seq_len);
    }

    output(result, seq_num);

    return 0;
}

int push(stk_ptr p, int elem){
    if(p->top+1 == p->len){
        return OVERFLOW;
    } else {
        p->top += 1;
        p->data[p->top] = elem;
    }
}

int pop(stk_ptr p){
    if(p->top == -1){
        return OVERFLOW;
    } else {
        p->top -= 1;
    }
    return p->data[p->top+1];
}

stk_ptr new_stk(int len){
    stk_ptr new_stk;
    int *data;
    data = (int*)malloc(len*sizeof(int));
    new_stk = (stk_ptr)malloc(sizeof(stk));
    new_stk->data = data;
    new_stk->top = -1;
    new_stk->len = len;
    return new_stk;
}

int **get_data(int *stk_len, int *seq_len, int *seq_num){
    int i, j;
    int **data;
    scanf("%d %d %d", stk_len, seq_len, seq_num);
    data = (int**)malloc(*seq_num * sizeof(int*));
    for(i = 0; i < *seq_num; i++){
        data[i] = (int*)malloc(*seq_len*sizeof(int));
    }
    for(i = 0; i < *seq_num; i++){
        for(j = 0; j < *seq_len; j++){
            scanf("%d", data[i]+j);
        }
    }
    return data;
}

void set_empty(stk_ptr p){
    p->top = -1;
}

int check(stk_ptr stk, int* list, int len){
    int i, max, temp;
    set_empty(stk);
    max = 0;
    for(i = 0; i < len; i++){
        if(list[i] > max){
            while(list[i] > max){
                max++;
                if(OVERFLOW == push(stk, max)){
                    return FALSE;
                }
            }
            pop(stk);
        } else {
            if(list[i] != pop(stk)){
                return FALSE;
            }
        }
    }
    return TRUE;
}

void output(int* result, int len){
    int i;
    for(i = 0; i < len; i++){
        if(result[i]){
            printf("YES");
        } else {
            printf("NO");
        }
        if(i < len-1){
            printf("\n");
        }
    }
}

核心算法在check里,check函数的算法大概是这样的：

先取一个M大小的空栈

用max记录所有进过栈的数中最大的那个

对于给定的pop sequence，逐个扫描，如果它比max大那么：

     从1开始进栈，直到和当前扫描到的数一样大停止，然后把这个数pop，如果栈溢出则返回false

否则：

    从栈里pop一个数，看它是不是当前扫描到的数，不是则返回false

当前扫描的序列可行，继续扫描下一个数，知道全扫完返回true

我用题目给的sample测试结果是正确的，自己换过栈大小写了几个序列测试也能正确出结果，但是提交后系统说我全错。。。。。。
我实在查不出问题出在哪儿了