栈的压入、弹出序列

 int top=0;
int a[100000];
void push (int x);
void pop(int x);
int Check(int k);
bool IsPopOrder(int* pushV, int pushVLen, int* popV, int popVLen ) {
    int i,k=0;
    for(i=0;i<pushVLen;i++)
    {
        push(pushV[i]);
        if (pushV[i]==popV[k])
        {
            pop (pushV[i]);
            k++;
            while (1)
            {
                if (Check(popV[k])==0)
                    break;
                k++;
            }
        }
    }
    printf("%d",k);
    if (k==popVLen)
        return true;
    else return false;
}
void push (int x)
{
    top++;
    a[top]=x;
}
void pop(int x)
{
    top--;
}
int Check(int k)
{
    if (top<1)
        return 0;
    else {
        if (a[top]==k)
        {
            top--;
            return 1;
        }
        else return 0;

    }
    
}

typedef struct lnode {
    int data;
    struct lnode* next;
} node, *stack;

void Push(stack* top, int x) {
    stack cur = (stack)malloc(sizeof(node));
    cur->data = x;
    cur->next = *top;
    *top = cur;
}

void Pop(stack* top) {
    if (*top == NULL) {
        return; // Handle underflow if needed
    }
    *top = (*top)->next;
}

bool IsPopOrder(int* pushV, int pushVLen, int* popV, int popVLen) {
    stack s=NULL;
    int j = 0;
    for (int i = 0; i < pushVLen; i++) {
        Push(&s, pushV[i]);
        while (s != NULL && s->data == popV[j] && j < popVLen) {
            Pop(&s);
            j++;
        }
    }
    return (s == NULL && j == popVLen);
}

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param pushV int整型一维数组 
 * @param pushVLen int pushV数组长度
 * @param popV int整型一维数组 
 * @param popVLen int popV数组长度
 * @return bool布尔型
 */
bool IsPopOrder(int* pushV, int pushVLen, int* popV, int popVLen ) {
    // write code here
    int temp[pushVLen],top = 0;
    int i = 0,j = 0;
    while(i<pushVLen)
    {
        temp[top++] = pushV[i++];
        while(top>0&&j<popVLen&&temp[top-1]==popV[j])
        {
            j++;
            top--;
        }
    }
    return top==0;
}

bool IsPopOrder(int* pushV, int pushVLen, int* popV, int popVLen ) {
    // write code here
    int stack[1000], top = 0, *p1 = pushV, *p2 = popV;
    while (p1 < pushV + pushVLen) {
        while(*p1 != *p2) {
            stack[top++] = *p1;
            p1++;
        }
        if (*p1 == *p2)
            p2++, p1++;
        while(top > 0 && stack[top - 1] == *p2) {
            top--, p2++;
        }
    }
    if (top < 1)
        return true;
    else
        return false;
}

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 *
 * @param pushV int整型一维数组
 * @param pushVLen int pushV数组长度
 * @param popV int整型一维数组
 * @param popVLen int popV数组长度
 * @return bool布尔型
 */

typedef struct {
    int* data;
    int top;
    int maxlen;
} stack, *stackp;
stackp stack_create(int len);
int stack_push(stackp s, int data);
int stack_pop(stackp s);
int stack_top(stackp s);

bool IsPopOrder(int* pushV, int pushVLen, int* popV, int popVLen ) {
    int i, j = 0;
    stackp s;
    s = stack_create(pushVLen);

    for (i = 0; i < pushVLen; i++) {
        stack_push(s, pushV[i]);    //压栈
        while (stack_top(s) == popV[j] && j < popVLen && s->top != -1) { //当栈定元素和出栈表j指向元素相等时，循环多次判断出栈
            stack_pop(s);
            j++;
        }
    }
    if (j == popVLen)   //最后，如果出栈表出完，则出栈表可行
        return true;
    else
        return false;
}


stackp stack_create(int len) {
    stackp s;
    if ((s = (stackp)malloc(sizeof(stack))) == NULL) {
        puts("malloc failed !");
        return NULL;
    }
    if ((s->data = (int*)malloc(len * sizeof(int))) == NULL) {
        puts("malloc failed !");
        return NULL;
    }
    s->maxlen = len;
    s->top = -1;
    return s;
}

int stack_push(stackp s, int data) {
    if (s->top == s->maxlen - 1) {
        puts("stack is full");
        return -1;
    }
    s->top++;
    s->data[s->top] = data;
    return 1;
}

int stack_pop(stackp s) {
    if (s->top == -1) {
        puts("stack is empty");
        return 0;
    }
    int tmp;
    tmp = s->data[s->top];
    s->top--;
    return tmp;
}

int stack_top(stackp s) {
    if (s->top == -1) {
        puts("stack is empty");
        return 0;
    }
    return s->data[s->top];
}

bool IsPopOrder(int* pushV, int pushVLen, int* popV, int popVLen ) 
{
    int stack[1001]={1001};
    int base=0,top=1;
    int i=0,j=0,m=0;
    for(i=0;i<pushVLen;i++)//初始化成1001
        stack[i]=1001;
    for(i=0;i<popVLen;i++)
    {
        if(stack[top-1]==popV[i])//和栈顶相不相等，相等出栈
        {
            top--;
            stack[top]=1001;
        }
        else//不相等，去压入栈找
        {
            if(m<pushVLen)//压入栈还没有找完
            {
                for(j=m;j<pushVLen;j++)
                {
                    if(pushV[j]==popV[i])//相等，停止
                        break;
                    else
                        stack[top++]=pushV[j];//不等，入栈
                }
            }
            else//压入栈已经找完了
                return false;
            
            if(j==pushVLen)//压入栈从m开始找到最后一个都没有找到和popV[i]相等的，返回false
                return false;
            else//在压入栈里找到了和popV[i]相等的
                m=j+1;
        }
    }
    return true;
    // write code here
}