栈原理详解及其应用实现

什么是栈

栈是一种特殊的表。我们可以把栈形象地想象成一个木桶：你可以往木桶里存放物品，也可以从木桶里拿取物品。但是每次你只能对木桶顶部的物品进行操作，而无法直接操作木桶底部的物品，除非你把位于其上的所有物品全部取出。

栈的作用

栈的用处很大，下面列举几个主要的应用场合：
1.保存函数调用的参数值；
2.符号匹配（[ ], { }, ( )）；
3.后缀、中缀表达式的解析。
总之，栈在底层的编译器设计中扮演着及其重要的角色。

栈的实现

一般来说，栈有两种实现方式：链表和数组。链表的优势在于可以动态分配内存；数组的优势则在于速度快，但是需要实现分配固定大小的一块内存。由于一般情况下栈的大小不会太大，而且基本上可以预测出一个最大上限，所以用数组来实现更为常见。笔者实现了一个栈基于数组的栈模板类，支持了绝大部分栈操作。
栈的定义：

template<class T>class Stack{public:    Stack();    ~Stack();    bool isEmpty();    bool isFull();    int size();    void create(int maxSize);    void clear();    void destroy();    void push(T val);    void pop();    T peek();    T peekAndPop();private:    T *array;//用于保存数据的数组    int capacity;//栈当前保存数据的个数    int top;//栈的顶部索引};

下面是具体的栈操作实现：
1.判断栈是否为空

template<class T>bool Stack<T>::isEmpty(){    return top == -1;}

2.判断栈是否已满

template<class T>bool Stack<T>::isFull(){    return top == capacity - 1;}

3.获取当前栈的大小

template<class T>int Stack<T>::size(){    return top + 1;}

4.创建栈

template<class T>void Stack<T>::create(int maxSize){    capacity = maxSize;    array = new T[maxSize];}

5.清空栈

template<class T>void Stack<T>::clear(){    top = -1;}

6.删除栈

template<class T>void Stack<T>::destroy(){    delete [] array;    top = -1;}

7.压栈

template<class T>void Stack<T>::push(T val){    if (!isFull())    {        array[++top] = val;    }}

8.出栈

template<class T>void Stack<T>::pop(){    if (!isEmpty())    {        top--;    }}

9.获取栈顶的数据

template<class T>T Stack<T>::peek(){    if (!isEmpty())    {        return array[top];    }    return NULL;}

10.获取栈顶的数据并将其出栈

template<class T>T Stack<T>::peekAndPop(){    if (!isEmpty())    {        return array[top--];    }    return NULL;}

栈的应用实例：中缀表达式的计算

中缀表达式指的是形如“100 + 37 - 22 * （7 -4） / 4”结构的表达式。表达式包含数字和操作符两中字符，中间用空格隔开。这种表达式比较符合人的阅读模式，但是程序却很难直接理解其中的逻辑。因此，我们需要对中缀表达式进行一些处理，具体步骤如下：
1.符号匹配检测。符号匹配检测指的是对[ ], { }, ( )等相对出现的符号进行匹配检测，这里检测的是（ 和 ）的匹配；
2.将中缀表达式转换成后缀表达式。后缀表达式也叫“逆波兰”（reverse Polish）记法。举个例子，后缀表达式“3 4 * 5 +”转化成中缀表达式为“3 * 4 + 5”，这里要做的正好是该转换的逆过程；
3. 计算后缀表达式的值。
值得一提的是，这三个步骤都用到了栈，可见栈用处之广泛。
1.符号匹配检测

char leftSymbols[] = {'(', '{', '[', '\'', '\"'};char rightSymbols[] = {')', '}', ']', '\'', '\"'};//sentence为需要被检测的表达式，leftSymbols和rightSymbols分别为左右匹配的字符，symbolNum为匹配字符的个数bool SymbolMatcher::matchTest(const char *sentence, const char leftSymbols[], const char rightSymbols[], int symbolNum)//匹配{    int len = strlen(sentence);    stack->create(len);    for (int i=0; i<len; i++)    {        char c = sentence[i];        if (find(leftSymbols, leftSymbols + symbolNum, c) != leftSymbols + symbolNum)//如果该字符是一个左匹配字符，直接压栈        {            stack->push(c);        }        else if (find(rightSymbols, rightSymbols + symbolNum, c) != rightSymbols + symbolNum)//如果该字符是一个右匹配字符        {            if (stack->isEmpty())//如果为空栈，说明匹配失败            {                return false;            }            else//否则，判断栈顶的字符是不是和该右匹配字符匹配的左匹配字符            {                char topc = stack->peekAndPop();                if (find(leftSymbols, leftSymbols + symbolNum, topc) - leftSymbols != find(rightSymbols, rightSymbols + symbolNum, c) - rightSymbols)                {                    return false;                }            }        }    }    return true;}

2.将中缀表达式转换成后缀表达式
首先实现一个c++ string的split函数

void split(string s, string delim, vector<string> &ret){    size_t last = 0;      size_t index = s.find_first_of(delim, last);      while (index != string::npos)      {          ret.push_back(s.substr(last, index - last));          last = index+1;          index = s.find_first_of(delim, last);      }      if (index - last > 0)      {          ret.push_back(s.substr(last, index - last));      }  }

然后将中缀表达式转换成后缀表达式

void InfixCalculator::infixToPostfix(const char *sentence, string &str){    vector<string> splits;    split(sentence, " ", splits);//分割字符串    int num = splits.size();    stack->create(num);//创建栈    for (size_t i=0; i<num; i++)//遍历分割的字符串序列    {        string s = splits[i];        string tops;        if (s == "+" || s == "-")        {            while(!stack->isEmpty())            {                tops = stack->peek();                if(tops == "+" || tops == "-" || tops == "*" || tops == "/")                {                    stack->pop();                    str.append(tops + " ");                }                else                {                    break;                }            }            stack->push(s);        }        else if (s == "*" || s == "/")        {            while(!stack->isEmpty())            {                tops = stack->peek();                if(tops == "*" || tops == "/")                {                    stack->pop();                    str.append(tops + " ");                }                else                {                    break;                }            }            stack->push(s);        }        else if (s == "(")        {            stack->push(s);        }        else if (s == ")")        {            while(!stack->isEmpty())            {                tops = stack->peek();                if (tops != "(")                {                    stack->pop();                    str.append(tops + " ");                }                else                {                    break;                }            }            stack->pop();        }        else        {            str.append(s + " ");        }    }    while(!stack->isEmpty())    {        str.append(stack->peekAndPop() + " ");    }    str = str.substr(0, str.size() - 1);}

3.计算后缀表达式的值

bool PostfixCalculator::calc(const char *sentence, double &ret){    vector<string> splits;    split(sentence, " ", splits);//分割字符串    int num = splits.size();    stack->create(num);//创建栈    for (int i=0; i<num; i++)//遍历分割的字符串序列    {        //具体规则是：1.如果遇到数字就压栈 2.如果遇到操作符就把栈顶的两个元素出栈并进行运算，然后将运算结果压栈        string s = splits[i];        if (s == "+")        {            if (stack->size() < 2)            {                return false;            }            double b = stack->peekAndPop();            double a = stack->peekAndPop();            double sum = a + b;            stack->push(sum);        }        else if (s == "-")        {            if (stack->size() < 2)            {                return false;            }            double b = stack->peekAndPop();            double a = stack->peekAndPop();            double difference = a - b;            stack->push(difference);        }        else if (s == "*")        {            if (stack->size() < 2)            {                return false;            }            double b = stack->peekAndPop();            double a = stack->peekAndPop();            double product = a * b;            stack->push(product);        }        else if (s == "/")        {            if (stack->size() < 2)            {                return false;            }            double b = stack->peekAndPop();            double a = stack->peekAndPop();            if (b == 0.0)            {                return false;            }            double quotient = a / b;            stack->push(quotient);        }        else        {            double d = atof(s.c_str());            stack->push(d);        }    }    if (stack->size() != 1)    {        return false;    }    ret = stack->peekAndPop();    return true;}

结果展示

测试程序

#include "infixcalculator.h"using namespace std;int main(){    InfixCalculator infixCalculator;    double ret;    if(!infixCalculator.calc("10 / 6 * 8 + ( 3 * 4 - 7 ) / 5", ret))    {        cout << "Expression is invalid!" << endl;    }    else    {        cout << ret << endl;    }    if(!infixCalculator.calc("10 / 6 * 8 + ( ( 3 * 4 - 7 ) / 5", ret))    {        cout << "Expression is invalid!" << endl;    }    else    {        cout << ret << endl;    }    return 0;}

运行结果