（六）栈的规则及应用
目标
1） 描述ADT栈的操作
2） 使用栈来判定代数表达式中分隔符是否正确配对
3） 使用栈将中缀表达式转变为后缀表达式
4） 使用栈计算后缀表达式的值
5） 使用栈计算中缀表达式的值
6） 使用程序中的栈
7） 描述Java运行时环境如何使用栈来跟踪方法的执行过程
5.1 ADT栈的规格说明
栈顶（top），栈顶项（top entry），入栈（push），出栈（pop），查看栈顶项（peek），一般地，不能在栈中查找某个具体的项。
|
抽象数据类型：栈 |
|
+push(newEntry : T) : void +pop() : T +peek() : T +isEmpty() : boolean +clear() : void |
设计决策：当栈空时pop和peek应该做什么？
- 假定ADT不空。即增加一个能保证这个假设的前置条件（pop,peek是public，不能信任客户遵从这些方法所需的任何前置条件）
- 返回null（具有二义性：ADT空 or 元素是null，需要客户调用第二个方法来解释另一个方法的动作）
- 抛出一个异常（此情况下，认为返回null是有效数据）
设计决策：当栈为空时，pop和peek应该抛出哪类异常：受检异常还是运行时异常？
如果方法的客户能在执行时从异常中合理地恢复，它就应该抛出受检异常。这种情况下，客户可以直接处理异常，或者将它传播到另一个方法中。如果将异常看作对你方法的不正常使用（即使用你方法的程序员的错误），则方法应该抛出运行时异常。运行时异常不需要（但可以）在throws子句中说明，而且也不需要（但可以）被客户捕获。
这里将栈为空时调用pop和peek方法看作客户的错误，所以抛出运行时异常。
安全说明：信任
你能信任一段代码吗？不能，除非能证明它的动作是正确且安全的，这种情形下它成为可信代码（trusted code）。能信任客户以确定的方式使用你的软件，所以遵从任何及所有的前置条件，并能正确解释返回码吗？不能。但是类内的私有方法确实能保证或信任，其前置条件要被遵从，它的返回值可被正确对待。
安全说明：设计原则
- 使用前置条件和后置条件来记录假设
- 不要信任客户能正确使用共有方法
- 避免返回值的二义性
- 宁愿抛出异常，也不要用返回值来表示一个问题
5.2 使用栈来处理代数表达式
将二元运算符放在其操作数中间，如a+b，为中缀表达式；放在操作数前，如+ab，为前缀表达式（有时称波兰表示法（Polish notation），由波兰数学家Jan Lukasiewicz于19世纪20年代提出）；放在操作数后，如ab+，为后缀表达式（有时称逆波兰表示法（reverse Polish notation））。
5.2.1 问题求解：检查中缀表达式中平衡的分隔符（括号配对）
平衡表达式（balanced expression）包含配对正确的或平衡的（balanced）分隔符。
public class BalanceChecker { public static void main(String[] args) { String expression = "a {b [c (d + e)/2 - f] + 1}"; boolean isBalanced = BalanceChecker.checkBalance(expression); if (isBalanced) { System.out.println(expression + " is balanced"); } else { System.out.println(expression + " is not balanced"); } // end if } // end main /** * Decides whether the parentheses, brackets, and braces * in a string occur in left/right pairs. * @param expression: A string to be checked. * @return: True if the delimiters are paired correctly. */ public static boolean checkBalance(String expression) { StackInterface<Character> openDelimiterStack = new OurStsck<>(); int characterCount = expression.length(); boolean isBalanced = true; int index = 0; char nextCharacter = ' '; while (isBalanced && (index < characterCount)) { nextCharacter = expression.charAt(index); switch (nextCharacter){ case '{': case '[': case '(': openDelimiterStack.push(nextCharacter); break; case '}': case ']': case ')': if (openDelimiterStack.isEmpty()) { isBalanced = false; } else { char openCharacter = openDelimiterStack.pop(); isBalanced = isPaired(openCharacter, nextCharacter); } // end if break; default: break; // Ignore unexpected characters } // end switch index++; } // end while if (!openDelimiterStack.isEmpty()) { isBalanced = false; } // end if return isBalanced; } // end checkBalance // Returns true if the given characters, open and close, form a pair // of parentheses, brackets, or braces. private static boolean isPaired(char open, char close) { return (open == '(' && close == ')') || (open == '[' && close == ']') || (open == '{' && close == '}'); } // end isPaired } // end BalanceChecker
5.2.2 问题求解：将中缀代数表达式转换为后缀表达式
|
最终目标是如何计算中缀表达式，但后缀表达式更容易求职值，所以先看一个中缀表达式如何表示为后缀表达式的形式。 |
中缀表达式对应后缀表达式的例子：
|
中缀 |
后缀 |
|
a + b |
a b + |
|
(a + b) * c |
a b + c * |
|
a + b * c |
a b c * + |
1） 手算策略
将中缀表达式根据优先级添加括号，再转为后缀表达式。
2） 转换算法的基础
从左到右扫描中缀表达式，到遇到操作数时，将它放到正创建的新表达式的末尾。在中缀表达式中，操作数的顺序和其对应的后缀表达式中是一样的。当遇到运算符时，必须先保存它，直到能判定它在所属的输出表达式的位置为止。将运算符保存到栈中。一般地，至少要等到将它与下一个运算符的优先级进行比较时。如转换a+b*c，将+保存到栈中，当遇到b，不能将+拿出来，要看下一个运算符，下一个运算符为*，优先级高于+，所以保存*，输入c，拿*，再拿+，abc*+。
3） 具有相同优先级的连续运算符
如果两个相连的运算符有相同的优先级，需要区分满足从左至右结合律的运算符（即+、-、*、/）及求幂，后者满足从右到左结合律。如a-b+c，遇到+时，栈中含有-，且部分后缀表达式是ab，减号运算符属于操作数a和b，所以-出栈，有ab-，+进栈，最后出栈，有ab-c+。表达式a^b^c：遇到第二个求幂运算符时，栈中含有^，目前有ab，当前运算符与栈顶有相同的优先级，但因为a^b^c的含义是a^(b^c)，所以将第二个^入栈，abc^^。
4） 圆括号
圆括号改变了运算符优先级规则，将开圆括号入栈，一旦它出现在栈中，将开圆括号看作有最低优先级的运算符。即，后面的任何运算符都将入栈。当遇到闭圆括号时，将运算符出栈，且加到已有的后缀表达式的后面，直到弹出一个开圆括号时为止。算法继续，但不将圆括号加到后缀表达式。
5） 中缀—后缀的转换
Algorithm convertToPostfix(infix) // 将中缀表达式转换为等价的后缀表达式
operatorStack = 一个新的空栈 postfix = 一个新的空字符串 while (infix还有待解析的字符){ nextCharacter = infix的下一个非空字符 switch (nextCharacter){ case 变量： 将nextCharacter添加到postfix的后面 break case '^': operatorStack.push(nextCharacter) break case '+': case '-': case '*': case '/': while (!operatorStack.isEmpty() && nextCharater的优先级 <= operatorStack.peek()的优先级){ 将operatorStack.peek()添加到postfix的后面 operatorStack.pop() } operatorStack.push(nextCharacter) break case '(': operatorStack.push(nextCharater) break case ')': // 如果中缀表达式合法，则栈非空 topOperator = operatorStack.pop() while (topOperator != '('){ 将topOperator添加到postfix的后面 topOperator = operatorStack.pop() } break default: break; // 忽略预期之外的字符 } } while (!operatorStack.isEmpty()){ topOperator = operatorStack.pop() 将topOperator添加到postfix的后面 } return postfix
5.2.3 问题求解：计算后缀表达式的值
遍历后缀表达式，遇见值入栈，遇见操作符，出栈两次，计算后结果入栈，直到栈中只有一个数值即表达式结果。
Algorithm evaluatePostfix(postfix) // 计算后缀表达式 valueStack = 一个新的空栈 while (postfix还有待解析的字符){ nextCharacter = postfix的下一个非空字符 switch (nextCharacter){ case 变量： valueStack.push(变量nextCharacter的值) break case '+': case '-': case '*': case '/': operandTwo = valueStack.pop() operandOne = valueStack.pop() result = nextCharacter中的操作作用于其操作数operandOne和operandTwo valueStack.push(result) break default: break // 忽略预期之外的字符 } } return valueStack.pop()
5.2.4 问题求解：计算中缀表达式的值
将前两个算法合为一个算法，使用两个栈直接计算中缀表达式的值。合并算法根据中缀表达式转换为后缀形式的算法，维护一个运算符栈。但该算法不将操作数添加到表达式的末尾，而是根据计算后缀表达式的算法，将操作数的值压入第二个栈中。
Algorithm evaluateInfix(infix) // 计算中缀表达式 operatorStack = 一个新的空栈 valueStack = 一个新的空栈 while (infix还有待解析的字符){ nextCharacter = infix的下一个非空字符 switch (nextCharacter){ case 变量: valueStack.push(变量nextCharacter的值) break case '^': operatorStack.push(nextCharacter) break case '+': case '-': case '*': case '/': while (!operatorStack.isEmpty() && nextCharater的优先级 <= operatorStack.peek()的优先级){ // 执行operatorStack栈顶的操作 topOperator = operatorStack.pop() operandTwo = valueStack.pop() operandOne = valueStack.pop() result = nextCharacter中的操作作用于其操作数operandOne和operandTwo valueStack.push(result) } operatorStack.push(nextCharacter) break case '(': operatorStack.push(nextCharater) break case ')': // 如果中缀表达式合法，则栈非空 topOperator = operatorStack.pop() while (topOperator != '('){ operandTwo = valueStack.pop() operandOne = valueStack.pop() result = nextCharacter中的操作作用于其操作数operandOne和operandTwo valueStack.push(result) topOperator = operatorStack.pop() } break default: break; // 忽略预期之外的字符 } } while (!operatorStack.isEmpty()){ topOperator = operatorStack.pop() operandTwo = valueStack.pop() operandOne = valueStack.pop() result = nextCharacter中的操作作用于其操作数operandOne和operandTwo valueStack.push(result) } return valueStack.peek()
5.3 Java类库：类Stack
java类库含有类Stack，它实现了java.util包中的ADT栈。与我们定义的方法的不同之处已做标记。
|
public T push(T item); public T pop(); public T peek(); public boolean empty(); |
5.4 小结
- ADT栈按后进先出的原则组织项。栈顶的项是最新添加进来的
- 栈的主要操作（push, pop和peek）都仅处理栈顶。方法push将项添加到栈顶；pop删除并返回栈顶，而peak只是返回栈顶
- 普通的代数表达式称为中缀表达式，因为每个二元运算符出现在它的两个操作数的中间。中缀表达式需要运算符优先级规则，且可使用圆括号来改变这些规则。
- 可以使用值栈来计算后缀表达式的值
- 可以使用两个栈（一个用于运算符，一个用于值）来计算中缀表达式的值
- 像peek和pop这样的方法，当栈为空时必须有合理的动作。例如，它们可以返回null或者抛出一个异常
