栈的应用 — 平衡符号

编译器可用此算法来检查括号是否成对出现，算法使用了一个栈。

算法描述：

做一个空栈。读入字符直到文件尾。如果字符是一个开放括号，则将其推入栈中。如果字符是一个封闭符号，则当栈空时报错。否则，将栈元素弹出。如果弹出的符号不是对应的开放符号，则报错。在文件尾，如果栈非空则报错。

根据上面的描述，自己写了一份代码，它只能处理小、中、大三种括号：

#include <stdio.h>
 
typedef char ElementType;
typedef struct StackRecord *Stack;
 
typedef struct StackRecord {
    int Capacity;
    int TopOfStack;
    ElementType *array;
};
 
int IsEmpty(Stack s)
{
    return s->TopOfStack == -1;
}
 
void MakeEmpty(Stack s)
{
    s->TopOfStack = -1;
}
 
void push(Stack s, ElementType x)
{
    // 这里未检测栈是否已满
    s->array[++s->TopOfStack] = x;
}
 
ElementType top(Stack s)
{
    if (!IsEmpty(s))
        return s->array[s->TopOfStack];
    else
        return -65535;
}
 
void pop(Stack s)
{
    if (!IsEmpty(s))
        s->TopOfStack--;// 直接修改游标，不返回元素
    else
        printf("Stack is empty!\n");
}
 
ElementType TopAndPop(Stack s)
{
    if (!IsEmpty(s))
        return s->array[s->TopOfStack--];
    else
        return -65535;
}
 
Stack CreateStack(int size)
{
    Stack s;
 
    s = (Stack)malloc(sizeof(struct StackRecord));
    if (s == NULL)
        return -1;
 
    s->Capacity = size;
    MakeEmpty(s);
    s->array = (ElementType *)malloc(size*sizeof(ElementType));
    if (s == NULL)
    {
        free(s);
        return -1;
    }
 
    return s;
}
 
void DisposeStack(Stack s)
{
    if (s != NULL)
    {
        free(s->array);
        free(s);
    }
}
 
// 用栈实现平衡符号的例子
int main(void)
{
    Stack s;
    char ch;
    char pre;
 
    s = CreateStack(50);
 
    while ((ch = getchar()) != '\n')
    {
        if (ch == '(' || ch == '[' || ch == '{')
            push(s, ch);
        else if (ch == ')' || ch == ']' || ch == '}')
        {
            if (IsEmpty(s))
            {
                printf("Error!\n");
                return -1;
            }
            switch (ch)
            {
                case ')':
                    pre = TopAndPop(s);
                    if (pre != '(')
                    {
                        printf("Error!\n");
                        return -1;
                    }
                    break;
                case ']':
                    pre = TopAndPop(s);
                    if (pre != '[')
                    {
                        printf("Error!\n");
                        return -1;
                    }
                    break;
                case '}':
                    pre = TopAndPop(s);
                    if (pre != '{')
                    {
                        printf("Error!\n");
                        return -1;
                    }
                    break;
            }
        }
    }
 
    if (!IsEmpty(s))
    {
        printf("Error!\n");
        return -1;
    }
 
    printf("OK!\n");
 
    return 0;
}

该算法具有线性时间复杂度，属于在线算法，即算法开始时不需要清楚全部的输入。

参考：

《数据结构于算法分析》 P52.