2. 程式人生 > >順序棧應用-字首、中綴、字尾表示式

順序棧應用-字首、中綴、字尾表示式

阿新 • • 發佈：2019-01-05

轉載自 http://blog.csdn.net/antineutrino/article/details/6763722/

關鍵字：概念, 字首表示式, 字首記法, 中綴表示式, 中綴記法, 波蘭式, 字尾表示式, 字尾記法, 逆波蘭式


它們都是對錶達式的記法，因此也被稱為字首記法、中綴記法和字尾記法。它們之間的區別在於運算子相對與運算元的位置不同：字首表示式的運算子位於與其相關的運算元之前；中綴和字尾同理。

舉例：
(3 + 4) × 5 - 6 就是中綴表示式
- × + 3 4 5 6 字首表示式
3 4 + 5 × 6 - 字尾表示式

中綴表示式（中綴記法）
中綴表示式是一種通用的算術或邏輯公式表示方法，操作符以中綴形式處於運算元的中間。中綴表示式是人們常用的算術表示方法。
雖然人的大腦很容易理解與分析中綴表示式，但對計算機來說中綴表示式卻是很複雜的，因此計算表示式的值時，通常需要先將中綴表示式轉換為字首或字尾表示式，然後再進行求值。對計算機來說，計算字首或字尾表示式的值非常簡單。

字首表示式（字首記法、波蘭式）
字首表示式的運算子位於運算元之前。

字首表示式的計算機求值：
從右至左掃描表示式，遇到數字時，將數字壓入堆疊，遇到運算子時，彈出棧頂的兩個數，用運算子對它們做相應的計算（棧頂元素 op 次頂元素），並將結果入棧；重複上述過程直到表示式最左端，最後運算得出的值即為表示式的結果。
例如字首表示式“- × + 3 4 5 6”：
(1) 從右至左掃描，將6、5、4、3壓入堆疊；
(2) 遇到+運算子，因此彈出3和4（3為棧頂元素，4為次頂元素，注意與字尾表示式做比較），計算出3+4的值，得7，再將7入棧；
(3) 接下來是×運算子，因此彈出7和5，計算出7×5=35，將35入棧；
(4) 最後是-運算子，計算出35-6的值，即29，由此得出最終結果。
可以看出，用計算機計算字首表示式的值是很容易的。

將中綴表示式轉換為字首表示式：

遵循以下步驟：
(1) 初始化兩個棧：運算子棧S1和儲存中間結果的棧S2；
(2) 從右至左掃描中綴表示式；
(3) 遇到運算元時，將其壓入S2；
(4) 遇到運算子時，比較其與S1棧頂運算子的優先順序：
(4-1) 如果S1為空，或棧頂運算子為右括號“)”，則直接將此運算子入棧；
(4-2) 否則，若優先順序比棧頂運算子的較高或相等，也將運算子壓入S1；
(4-3) 否則，將S1棧頂的運算子彈出並壓入到S2中，再次轉到(4-1)與S1中新的棧頂運算子相比較；
(5) 遇到括號時：
(5-1) 如果是右括號“)”，則直接壓入S1；
(5-2) 如果是左括號“(”，則依次彈出S1棧頂的運算子，並壓入S2，直到遇到右括號為止，此時將這一對括號丟棄；
(6) 重複步驟(2)至(5)，直到表示式的最左邊；
(7) 將S1中剩餘的運算子依次彈出並壓入S2；
(8) 依次彈出S2中的元素並輸出，結果即為中綴表示式對應的字首表示式。
例如，將中綴表示式“1+((2+3)×4)-5”轉換為字首表示式的過程如下：
掃描到的元素 S2(棧底->棧頂) S1 (棧底->棧頂) 說明
5 5 空 數字，直接入棧
- 5 - S1為空，運算子直接入棧
) 5 - ) 右括號直接入棧
4 5 4 - ) 數字直接入棧
× 5 4 - ) × S1棧頂是右括號，直接入棧
) 5 4 - ) × ) 右括號直接入棧
3 5 4 3 - ) × ) 數字
+ 5 4 3 - ) × ) + S1棧頂是右括號，直接入棧
2 5 4 3 2 - ) × ) + 數字
( 5 4 3 2 + - ) × 左括號，彈出運算子直至遇到右括號
( 5 4 3 2 + × - 同上
+ 5 4 3 2 + × - + 優先順序與-相同，入棧
1 5 4 3 2 + × 1 - + 數字
到達最左端 5 4 3 2 + × 1 + - 空 S1中剩餘的運算子
因此結果為“- + 1 × + 2 3 4 5”。

字尾表示式（字尾記法、逆波蘭式）
字尾表示式與字首表示式類似，只是運算子位於運算元之後。

字尾表示式的計算機求值：
與字首表示式類似，只是順序是從左至右：
從左至右掃描表示式，遇到數字時，將數字壓入堆疊，遇到運算子時，彈出棧頂的兩個數，用運算子對它們做相應的計算（次頂元素 op 棧頂元素），並將結果入棧；重複上述過程直到表示式最右端，最後運算得出的值即為表示式的結果。
例如字尾表示式“3 4 + 5 × 6 -”：
(1) 從左至右掃描，將3和4壓入堆疊；
(2) 遇到+運算子，因此彈出4和3（4為棧頂元素，3為次頂元素，注意與字首表示式做比較），計算出3+4的值，得7，再將7入棧；
(3) 將5入棧；
(4) 接下來是×運算子，因此彈出5和7，計算出7×5=35，將35入棧；
(5) 將6入棧；
(6) 最後是-運算子，計算出35-6的值，即29，由此得出最終結果。

將中綴表示式轉換為字尾表示式：
與轉換為字首表示式相似，遵循以下步驟：
(1) 初始化兩個棧：運算子棧S1和儲存中間結果的棧S2；
(2) 從左至右掃描中綴表示式；
(3) 遇到運算元時，將其壓入S2；
(4) 遇到運算子時，比較其與S1棧頂運算子的優先順序：
(4-1) 如果S1為空，或棧頂運算子為左括號“(”，則直接將此運算子入棧；
(4-2) 否則，若優先順序比棧頂運算子的高，也將運算子壓入S1（注意轉換為字首表示式時是優先順序較高或相同，而這裡則不包括相同的情況）；
(4-3) 否則，將S1棧頂的運算子彈出並壓入到S2中，再次轉到(4-1)與S1中新的棧頂運算子相比較；
(5) 遇到括號時：
(5-1) 如果是左括號“(”，則直接壓入S1；
(5-2) 如果是右括號“)”，則依次彈出S1棧頂的運算子，並壓入S2，直到遇到左括號為止，此時將這一對括號丟棄；
(6) 重複步驟(2)至(5)，直到表示式的最右邊；
(7) 將S1中剩餘的運算子依次彈出並壓入S2；
(8) 依次彈出S2中的元素並輸出，結果的逆序即為中綴表示式對應的字尾表示式（轉換為字首表示式時不用逆序）。
例如，將中綴表示式“1+((2+3)×4)-5”轉換為字尾表示式的過程如下：
掃描到的元素 S2(棧底->棧頂) S1 (棧底->棧頂) 說明
1 1 空 數字，直接入棧
+ 1 + S1為空，運算子直接入棧
( 1 + ( 左括號，直接入棧
( 1 + ( ( 同上
2 1 2 + ( ( 數字
+ 1 2 + ( ( + S1棧頂為左括號，運算子直接入棧
3 1 2 3 + ( ( + 數字
) 1 2 3 + + ( 右括號，彈出運算子直至遇到左括號
× 1 2 3 + + ( × S1棧頂為左括號，運算子直接入棧
4 1 2 3 + 4 + ( × 數字
) 1 2 3 + 4 × + 右括號，彈出運算子直至遇到左括號
- 1 2 3 + 4 × + - -與+優先順序相同，因此彈出+，再壓入-
5 1 2 3 + 4 × + 5 - 數字
到達最右端 1 2 3 + 4 × + 5 - 空 S1中剩餘的運算子

因此結果為“1 2 3 + 4 × + 5 -”（注意需要逆序輸出）。

編寫Java程式將一箇中綴表示式轉換為字首表示式和字尾表示式，並計算表示式的值。其中的toPolishNotation()方法將中綴表示式轉換為字首表示式（波蘭式）、toReversePolishNotation()方法則用於將中綴表示式轉換為字尾表示式（逆波蘭式）：

注：
(1) 程式很長且註釋比較少，但如果將上面的理論內容弄懂之後再將程式編譯並執行起來，還是比較容易理解的。有耐心的話可以研究一下。(2) 此程式是筆者為了說明上述概念而編寫，僅做了簡單的測試，不保證其中沒有Bug，因此不要將其用於除研究之外的其他場合。


 [java] view plain copy
  1. package qmk.simple_test;  
  2. import java.util.Scanner;  
  3. import java.util.Stack;  
  4. /** 
  5.  * Example of converting an infix-expression to 
  6.  * Polish Notation (PN) or Reverse Polish Notation (RPN). 
  7.  * Written in 2011-8-25 
  8.  * @author QiaoMingkui 
  9.  */  
  10. public class Calculator {  
  11.       public static final String USAGE = "== usage ==\n"  
  12.             + "input the expressions, and then the program "  
  13.             + "will calculate them and show the result.\n"  
  14.             + "input 'bye' to exit.\n";  
  15.       /** 
  16.        * @param args 
  17.        */  
  18.       public static void main(String[] args) {  
  19.             System.out.println(USAGE);  
  20.             Scanner scanner = new Scanner(System.in);  
  21.             String input = "";  
  22.             final String CLOSE_MARK = "bye";  
  23.             System.out.println("input an expression:");  
  24.             input = scanner.nextLine();  
  25.             while (input.length() != 0  
  26.                   && !CLOSE_MARK.equals((input))) {  
  27.                   System.out.print("Polish Notation (PN):");  
  28.                   try {  
  29.                         toPolishNotation(input);  
  30.                   } catch (NumberFormatException e) {  
  31.                         System.out.println("\ninput error, not a number.");  
  32.                   } catch (IllegalArgumentException e) {  
  33.                         System.out.println("\ninput error:" + e.getMessage());  
  34.                   } catch (Exception e) {  
  35.                         System.out.println("\ninput error, invalid expression.");  
  36.                   }  
  37.                   System.out.print("Reverse Polish Notation (RPN):");  
  38.                   try {  
  39.                         toReversePolishNotation(input);  
  40.                   } catch (NumberFormatException e) {  
  41.                         System.out.println("\ninput error, not a number.");  
  42.                   } catch (IllegalArgumentException e) {  
  43.                         System.out.println("\ninput error:" + e.getMessage());  
  44.                   } catch (Exception e) {  
  45.                         System.out.println("\ninput error, invalid expression.");  
  46.                   }  
  47.                   System.out.println("input a new expression:");  
  48.                   input = scanner.nextLine();  
  49.             }  
  50.             System.out.println("program exits");  
  51.       }  
  52.       /** 
  53.        * parse the expression , and calculate it. 
  54.        * @param input 
  55.        * @throws IllegalArgumentException 
  56.        * @throws NumberFormatException 
  57.        */  
  58.       private static void toPolishNotation(String input)  
  59.                   throws IllegalArgumentException, NumberFormatException {  
  60.             int len = input.length();  
  61.             char c, tempChar;  
  62.             Stack<Character> s1 = new Stack<Character>();  
  63.             Stack<Double> s2 = new Stack<Double>();  
  64.             Stack<Object> expression = new Stack<Object>();  
  65.             double number;  
  66.             int lastIndex = -1;  
  67.             for (int i=len-1; i>=0; --i) {  
  68.                   c = input.charAt(i);  
  69.                   if (Character.isDigit(c)) {  
  70.                         lastIndex = readDoubleReverse(input, i);  
  71.                         number = Double.parseDouble(input.substring(lastIndex, i+1));  
  72.                         s2.push(number);  
  73.                         i = lastIndex;  
  74.                         if ((int) number == number)  
  75.                               expression.push((int) number);  
  76.                         else  
  77.                               expression.push(number);  
  78.                   } else if (isOperator(c)) {  
  79.                         while (!s1.isEmpty()  
  80.                                     && s1.peek() != ')'  
  81.                                     && priorityCompare(c, s1.peek()) < 0) {  
  82.                               expression.push(s1.peek());  
  83.                               s2.push(calc(s2.pop(), s2.pop(), s1.pop()));  
  84.                         }  
  85.                         s1.push(c);  
  86.                   } else if (c == ')') {  
  87.                         s1.push(c);  
  88.                   } else if (c == '(') {  
  89.                         while ((tempChar=s1.pop()) != ')') {  
  90.                               expression.push(tempChar);  
  91.                               s2.push(calc(s2.pop(), s2.pop(), tempChar));  
  92.                               if (s1.isEmpty()) {  
  93.                                     throw new IllegalArgumentException(  
  94.                                           "bracket dosen't match, missing right bracket ')'.");  
  95.                               }  
  96.                         }  
  97.                   } else if (c == ' ') {  
  98.                         // ignore  
  99.                   } else {  
  100.                         throw new IllegalArgumentException(  
  101.                                     "wrong character '" + c + "'");  
  102.                   }  
  103.             }  
  104.             while (!s1.isEmpty()) {  
  105.                   tempChar = s1.pop();  
  106.                   expression.push(tempChar);  
  107.                   s2.push(calc(s2.pop(), s2.pop(), tempChar));  
  108.             }  
  109.             while (!expression.isEmpty()) {  
  110.                   System.out.print(expression.pop() + " ");  
  111.             }  
  112.             double result = s2.pop();  
  113.             if (!s2.isEmpty())  
  114.                   throw new IllegalArgumentException("input is a wrong expression.");  
  115.             System.out.println();  
  116.             if ((int) result == result)  
  117.                   System.out.println("the result is " + (int) result);  
  118.             else  
  119.                   System.out.println("the result is " + result);  
  120.       }  
  121.       /** 
  122.        * parse the expression, and calculate it. 
  123.        * @param input 
  124.        * @throws IllegalArgumentException 
  125.        * @throws NumberFormatException 
  126.        */  
  127.       private static void toReversePolishNotation(String input)  
  128.                   throws IllegalArgumentException, NumberFormatException {  
  129.             int len = input.length();  
  130.             char c, tempChar;  
  131.             Stack<Character> s1 = new Stack<Character>();  
  132.             Stack<Double> s2 = new Stack<Double>();  
  133.             double number;  
  134.             int lastIndex = -1;  
  135.             for (int i=0; i<len; ++i) {  
  136.                   c = input.charAt(i);  
  137.                   if (Character.isDigit(c) || c == '.') {  
  138.                         lastIndex = readDouble(input, i);  
  139.                         number = Double.parseDouble(input.substring(i, lastIndex));  
  140.                         s2.push(number);  
  141.                         i = lastIndex - 1;  
  142.                         if ((int) number == number)  
  143.                               System.out.print((int) number + " ");  
  144.                         else  
  145.                               System.out.print(number + " ");  
  146.                   } else if (isOperator(c)) {  
  147.                         while (!s1.isEmpty()  
  148.                                     && s1.peek() != '('  
  149.                                     && priorityCompare(c, s1.peek()) <= 0) {  
  150.                               System.out.print(s1.peek() + " ");  
  151.                               double num1 = s2.pop();  
  152.                               double num2 = s2.pop();  
  153.                               s2.push(calc(num2, num1, s1.pop()));  
  154.                         }  
  155.                         s1.push(c);  
  156.                   } else if (c == '(') {  
  157.                         s1.push(c);  
  158.                   } else if (c == ')') {  
  159.                         while ((tempChar=s1.pop()) != '(') {  
  160.                               System.out.print(tempChar + " ");  
  161.                               double num1 = s2.pop();  
  162.                               double num2 = s2.pop();  
  163.                               s2.push(calc(num2, num1, tempChar));  
  164.                               if (s1.isEmpty()) {  
  165.                                     throw new IllegalArgumentException(  
  166.                                           "bracket dosen't match, missing left bracket '('.");  
  167.                               }  
  168.                         }  
  169.                   } else if (c == ' ') {  
  170.                         // ignore  
  171.                   } else {  
  172.                         throw new IllegalArgumentException(  
  173.                                     "wrong character '" + c + "'");  
  174.                   }  
  175.             }  
  176.             while (!s1.isEmpty()) {  
  177.                   tempChar = s1.pop();  
  178.                   System.out.print(tempChar + " ");  
  179.                   double num1 = s2.pop();  
  180.                   double num2 = s2.pop();  
  181.                   s2.push(calc(num2, num1, tempChar));  
  182.             }  
  183.             double result = s2.pop();  
  184.             if (!s2.isEmpty())  
  185.                   throw new IllegalArgumentException("input is a wrong expression.");  
  186.             System.out.println();  
  187.             if ((int) result == result)  
  188.                   System.out.println("the result is " + (int) result);  
  189.             else  
  190.                   System.out.println("the result is " + result);  
  191.       }  
  192.       /** 
  193.        * calculate the two number with the operation. 
  194.        * @param num1 
  195.        * @param num2 
  196.        * @param op 
  197.        * @return 
  198.        * @throws IllegalArgumentException 
  199.        */  
  200.       private static double calc(double num1, double num2, char op)  
  201.                   throws IllegalArgumentException {  
  202.             switch (op) {  
  203.             case '+':  
  204.                   return num1 + num2;  
  205.             case '-':  
  206.                   return num1 - num2;  
  207.             case '*':  
  208.                   return num1 * num2;  
  209.             case '/':  
  210.                   if (num2 == 0) throw new IllegalArgumentException("divisor can't be 0.");  
  211.                   return num1 / num2;  
  212.             default:  
  213.                   return 0; // will never catch up here  
  214.             }  
  215.       }  
  216.       /** 
  217.        * compare the two operations' priority. 
  218.        * @param c 
  219.        * @param peek 
  220.        * @return 
  221.        */  
  222.       private static int priorityCompare(char&

相關推薦

順序棧應用-字首、中綴、字尾表示式

轉載自 http://blog.csdn.net/antineutrino/article/details/6763722/ 關鍵字：概念, 字首表示式, 字首記法, 中綴表示式, 中綴記法, 波蘭式, 字尾表示式, 字尾記法, 逆波蘭式 它們都是對錶達式的記法，因此也被稱為字首記法、中綴記

棧的應用-四則運算（中綴與字尾表示式轉換--Java原始碼）

參考連結 結合原文章，做了一定修改，增加Java原始碼實現 1. 概述 對於四則運算表示式的計算，是輸入資料結構中棧的應用，即重點是中綴表示式轉換為字尾表示式 2. 字尾表示式計算 為了解釋字尾表示式的好處，我們先來

字首，中綴，字尾表示式及其求值和轉換

一.四則運算表示式 我們最常見的運算表示式是 ： 12 * (3 + 4) - 6 + 8 / 2 這種型別，這就被稱為是中綴表示式。 我們要用計算機來計算這一串表示式，然而表示式中涉及運算子的優先順序順序還有括號的干擾等，我們必須轉化為一種易於計算的形式，於是這裡就出現

順序棧應用2（利用順序棧將中綴式轉換成前、字尾式並求值）

/* 中綴轉字首參考演算法: 1）求輸入串的逆序。（中綴轉字首是從右向左訪問表示式） 2）檢查輸入的下一元素。 3）假如是運算元，把它新增到輸出串中。 4）假如是閉括號，將它壓棧。 5）假如是運算子， i)假如棧空，此運算子入棧。 ii)假如棧頂是閉括號，此運算子入棧。 i

字首、中綴、字尾表示式轉換詳解

字首、中綴、字尾表示式轉換詳解 昨天參加了ebay實習生筆試題，其中一道題目給定了字首表示式，讓我們求轉換成中綴表示式時輔助棧的做多情況下容乃幾個元素以及中綴表示式的值。當時沒有做出來，會後後網上查了些資料，發現很少有文章將字首、中綴和字尾表示式之間的轉化覆蓋了，所以寫

基礎演算法與資料結構（二）字首、中綴、字尾表示式

目錄 簡介 字首表示式計算 字尾表示式計算 簡介 中綴表示式（正常的表示式） \[ (1+2)*3-4 \] 字首表示式（運算子位於運算元之前） \[ -*+1234 \] 字尾表示式（運算子位於運算元之後） \[ 12+3*4- \] 字首表示式計算 從右向左遍歷，

【轉載】字首、中綴、字尾表示式(逆波蘭表示式)

在這裡首先感謝部落格園的chensongxian這位大佬貢獻了這篇部落格，當時看了這篇部落格，我茅塞頓開，在此轉載，如有冒犯，聯絡我，我會立刻刪除。 介紹 字首表示式、中綴表示式、字尾表示式都是四則運算的表達方式,用以四則運算表示式求值 ,即數學表示式的求職 中綴表

字首、中綴、字尾表示式相互轉換

這裡只提供了使用棧的方法，還可以利用樹的遍歷實現。 中綴表示式轉換為字首表示式。  首先建立算術符棧OPTR和表示式棧RESULT並置空，然後依次逆序檢查中綴表示式每個字元，不同字元按不同情況處理： (1).若是空格直接跳過。 (2).若是運算元直接壓入RESULT棧。 (3).若是‘

【軟考】字首、中綴、字尾表示式

關鍵字：概念, 字首表示式, 字首記法, 中綴表示式, 中綴記法, 波蘭式, 字尾表示式, 字尾記法, 逆波蘭式 它們都是對錶達式的記法，因此也被稱為字首記法、中綴記法和字尾記法。它們之間的區別在於運算子相對與運算元的位置不同：字首表示式的運算子位於

波蘭表示法與逆波蘭表示法（字首、中綴、字尾表示式）

1、為什麼要把中綴表示式轉化為字尾，字首？ 計算機沒法計算帶有括號，以及區分優先順序的表示式，或者說很難計算。使用字尾，字首，消除了括號和優先順序。 2、計算機如何計算字尾，字首表示式？ 計算字尾：從左到右遍歷字尾表示式，遇到運算元，放進棧，遇到操作符，棧頂兩個數出

棧應用2（中綴表示式轉換成字尾表示式）-筆記

問題：如何使用棧來實現將中綴轉換為字尾表示式的演算法？ 解答：在討論演算法前，首先介紹中綴、字首和字尾表示式的定義 中綴：中綴表示式由一個單一字元或運算子，連線前後兩個中綴字串共同組成。 A A+B （A+B）+（C+D） 字首：字首表示式由一個單一字元或運算子，隨後是兩個字首字串共同組成。

基礎算法與數據結構（二）前綴、中綴、後綴表達式

splay pla 中綴 text 出棧 前綴 操作數 兩個 The 目錄 簡介 前綴表達式計算 後綴表達式計算 簡介 中綴表達式（正常的表達式） \[ (1+2)*3-4 \] 前綴表達式（運算符位於操作數之前） \[ -*+1234 \] 後綴表達式（運算符位於操

棧的表示式之計算中綴、字首和字尾表示式

1.計算中綴表示式 //判斷運算子優先順序 int getPriority(char op) { if(op=='+'||op=='-') return 0; else return 1; } //計算表示式 int calsub(float opnd1,char op,fl

中綴、字首、字尾表示式相互相互轉換與求值

轉載至：https://www.cnblogs.com/nzbbody/p/3335226.html 表示式轉化（中綴，字尾，字首） 1、為什麼要把中綴表示式轉化為字尾，字首？ 計算機沒法計算帶有括號，以及區分優先順序的表示式，或者說很難計算。使用字尾，字首，消除了括號和優先順序

字首表示式、中綴表示式、字尾表示式及其轉換

中綴式到其他式子的轉換方法 一箇中綴表示式如： a+bc-(d+e) 第一步：按照運算子的優先順序對所有的運算單位加括號~ 式子變成拉：((a+(bc))-(d+e)) 第二步：轉換字首與字尾表示式 字首：把運算子號移動到對應的括號前面 則變成拉：-( +(a

棧應用---元素出棧、入棧順序的合法性判斷

利用棧來判斷元素出入棧順序的合法性 例如：入棧的序列(1,2,3,4,5)，出棧序列為 (4,5,3,2,1) 解決思路如下： 我們設定一箇中間棧：tempStack，記錄一個出棧順序下標index 1、按入棧順序，存入一個元素到tempStack中 2、比較

字首表示式、中綴表示式、字尾表示式。

表示式 表示式：就是式子。是由數字、算符、數字分組符號、自由量和約束量組成的。人們一般習慣寫出來的式子，叫做中綴表示式。 因為在計算機中，不方便表達 數字分組符號。所以 波蘭人發明了一種把去符號化的表示式。字首表示式 字首表示式 字首表示式：沒有括號，算符在前 數字在後。波

字首表示式、字尾表示式和中綴表示式的計算（double型）

有關中綴表示式的計算以及中綴表示式與字首表示式、字尾表示式之間的轉換   後續文章會繼續給出 這裡只講字首表示式與字尾表示式計算的實現方法 字首表示式 計算方法：   將得到的字串處理為

棧---定義、應用（遞迴、字尾表示式實現數學表示式求值）

一、定義 棧是限定僅在表尾進行插入和刪除操作的線性表。因此，棧的表尾端稱為棧頂；表頭端稱為棧底。不含任何資料元素的棧稱為空棧。棧又稱為後進先出(Last In First Out)的線性表，簡稱LIF0結構。 理解棧的定義需要注意：首先它是一個線性表，也即棧

字首表示式、中綴表示式、字尾表示式總結

一、字首表示式 （1）定義 字首表示式是一種沒有括號的算術表示式，其將運算子寫在前面，運算元寫在後面。例如表示式1-(2+3)的字首表示式是- 1 + 2 3。 （2）求值方法 對字首表示式求值，要