栈操作及其应用

栈可以是顺序栈，也可以是链栈。

顺序栈：

const int maxSize = 100;
// 顺序栈
struct SqStack{
    int data[maxSize];
    int top;
}

void initStack(SqStack &s)
{
    s.top=-1;
}

int isEmpty(SqStack s)
{
    if(s.top == -1)
        return 1;
    else
        return 0;
}

int push(SqStack &s,int x)
{
    if(s.top == maxSize-1)
        return 0;
    ++(s.top);
    s.data[s.top]=x;
    return 1
}

int pop(SqStack &s,int &x)
{
    if(s.top==-1)
        return 0;
    x = s.data[s.top];
    --(s.top);
    return 1;
}

顺序栈还可以更简化，使用数组来创建：

//简化版顺序栈
int stack[maxSize];   
int top = -1;             //  初始化栈
stack[++top] = x;   //  进栈
x = stack[top--];     //  出栈

链栈：

// 链栈
struct LNode{
    int data;
    LNode *next;
}

void InitStack(LNode *&lst)
{
    lst = new LNode;
    lst->next = NULL;
}

int isEmpty(LNode *lst)
{
    if(lst->next == NULL)
        return 1;
    else
        return 0;
}

void push(LNode *lst,int x)
{
    LNode *p;
    p = new LNode;

    p->data = x;
    p->next = lst->next;
    lst->next = p;
}

int pop(LNode *lst,int &x)
{
    LNode *p;
    if(lst->next == NULL)
        return 0;
    p = lst->next;
    x = p->data;
    lst->next = p->next;
    free(p);
    return 1;
}

栈的应用：

1. 编写算法，判断一个算术表达式中的括号是否配对。表达式已经存入字符数组中，元素从下标1开始存储，表达式中的字符个数为n

思路：遍历这个表达式，当遇到第一个 '(' 时，入栈，继续遍历，如果遇到 ')' ，则将 '(' 出栈，划掉这两个括号，继续处理下一组括号。如果前面所有括号都被划掉，而下一个括号却是 ')' ，

则括号不匹配，因为前面已经没有与之匹配的 '(' 了。如果下一个括号还是 '(' ，则先处理这个括号，处理完再处理前面的 '(' 。

int match(char exp[],int n)
{
    char stack[maxSize];
    int top = -1;
 
    int i;
    for(i=1;i<=n;++i){
        if(exp[i]=='(')
            stack[++top]='(';
        if(exp[i]==')'){
            if(top==-1)
                return 0;
            else
                --top;
        }
    }
    if(top==-1)   // 所有括号都被处理掉了，返回1
        return 1;   
    else              // 否则返回0
        return 0;
}

2.编写一个函数，求后缀表达式的值。（即逆波兰表达式的值）   表达式被存于一个字符数组中，以''结尾，并假设后缀表达式中的数字都只有一位。

先定义一个运算函数：

int op(int a,char op, int b)
{
    if(op=='+') return a+b;
    if(op==''-) return a-b;
    if(op==''*) return a*b;
    if(op=='/'){
        if(b==0){
            cout<<"Error"<<endl;
            return 0;
        }else
            return a/b;
    }
}

后缀表达式计算函数：

int com(char exp[])
{
    int a,b,c;   //   a、b为操作数，c存储计算结果
    int stack[maxSize];
    int top = -1;

    char op;
    for(i=0;exp[i]!='';i++){
        if(exp[i]>='0'&&exp[i]<='9')
            stack[++top]=exp[i]-'0';
        else{
            op = exp[i];
            a=stack[top--];
            b=stack[top--];
      //  注意，根据后缀表达式的计算方式，应该用后出栈的数op先出栈的数
            c=op(b,op,a);   
            stack[++top]=c;
        }   
    }
    return stack[top];
}