栈及其栈应用

栈

typedef struct node
{
    int data;
    struct node*pnext;
}NODE,*PNODE;
typedef struct stack
{
    PNODE ptop;
    PNODE pbottom;
}STACK,*PSTACK;
void init(PSTACK);
void push(PSTACK ps,int val);
void show(PSTACK ps);
bool is_empty(PSTACK ps);
bool pop(PSTACK ps,int *pval);
int main()
{
    STACK S;int val;
    init(&S);
    push(&S,1);
    push(&S,2);
    push(&S,3);
    push(&S,4);
    push(&S,5);
    push(&S,6);
    pop(&S,&val);

        printf("出栈成功，出栈的元素是%d\n",val);
    show(&S);
}

void init(PSTACK ps)
{
    ps->ptop=(PNODE)malloc(sizeof(NODE));
    ps->pbottom=ps->ptop;
    ps->ptop->pnext=NULL;
}
void push(PSTACK ps,int val)//与链表类似，只不过头指针为bottom依旧为空，而尾指针为top只想最后一个节点，所有节点是向下指向头指针的
{
    PNODE p=(PNODE)malloc(sizeof(NODE));
    p->data=val;
    p->pnext=ps->ptop;
    ps->ptop=p;
}
void show(PSTACK ps)//可以遍历，但必须是从上向下的遍历，因此在创建该链表时指针都是指向bottom的
{

    while(ps->ptop!=ps->pbottom)
    {
        printf("%d",ps->ptop->data);
        ps->ptop=ps->ptop->pnext;
    }
    printf("\n");
}
bool is_empty(PSTACK ps)
{
    if(ps->ptop==ps->pbottom)
        return true;
    else
        return false;
}
bool pop(PSTACK ps,int *pval)
{
    if(is_empty(ps))
    {
        return false;
    }
    else{
        PNODE r=ps->ptop;
        *pval=r->data;
        ps->ptop=r->pnext;
        free(r);
        r=NULL;
        return true;
    }
}
bool clear(PSTACK ps)
{
    if(is_empty(ps))
    {
        return false;
    }
    else{
        PNODE p=ps->ptop;
        PNODE q=NULL;
        while(q!=ps->pbottom)
        {
            q=p->pnext;//q用来记录p的下一个结点的
            free(p);
            p=q;
        }
        ps->ptop=ps->pbottom;
    }
}

总结

• 链式栈的结构与链表差不多，只不过相当于用尾插法创建，再用尾插法删除，bottom相当于头指针，依旧为空

栈应用之字符匹配

• 将左括号等全部放入栈中，如果碰到右括号就取出栈顶元素看是否匹配，当将字符串读完时还要保证栈中元素为空，才能确保了全部匹配成功

int main()
{
    STACK s;
    init(&s);
    char *str="[([(][])]";
    bool num=judge(&s,str);
}
bool judge(STACK*s,char*str)
{
    char val;
    while(*str!='\0')
    {
        if(*str=='['||*str=='(')
        {
            push(s,*str);
        }
        else if(*str==']')
        {
            val=getpop(s);
            if(val!='[')
            {
                return false;
            }
            else{pop(s);}
        }
        else if(*str==')')
        {
            val=getpop(s);
            if(val!='(')
            {
                return false;
            }
            else{pop(s);}
        }
        str++;
    }
    if(is_empty(s))return true;
}

栈应用之中缀表达式的运算

1.中缀表达式的运算需要先将中缀表达式转为后缀表达式

• 将表达式从左到右依次读取字符，如果读到算是符号，就放入栈中，数字用数组记录下来
• 但是根据运算的优先级，因为栈顶的元素需要率先被拿出来，所以在栈上面的元素一定优先级大于站下面的元素，因此将算术符号放入栈中时如果碰到）,就将(及其上面的元素全部取出，如果碰到优先级小的算符，就将优先级比他大运算符全部取出。

2.通过后缀表达式进行计算

• 将新的数组中的数字一一放入栈中，如果碰到运算符 ，就拿出两个数取出两个数进行运算，是栈中的第二个数组+运算符+栈中的第一个元素
• 运算完的数组重新放入栈中，继续进行计算或者继续即将数字放入栈中
• 最后数组遍历完成后栈中的元素就是最终的结果