zoukankan      html  css  js  c++  java
  • Algorithm Gossip: 中序式轉後序式(前序式)

    http://www.bcwhy.com/jdsf/AlgorithmGossip/InFixPostfix.htm


    Algorithm Gossip: 中序式轉後序式(前序式)

    說明

    平常所使用的運算式,主要是將運算元放在運算子的兩旁,例如a+b/d這樣的式子,這稱之為中序(Infix)表示式,對於人類來說,這樣的式子很容易理 解,但由於電腦執行指令時是有順序的,遇到中序表示式時,無法直接進行運算,而必須進一步判斷運算的先後順序,所以必須將中序表示式轉換為另一種表示方 法。

    可以將中序表示式轉換為後序(Postfix)表示式,後序表示式又稱之為逆向波蘭表示式(Reverse polish notation),它是由波蘭的數學家盧卡謝維奇提出,例如(a+b)*(c+d)這個式子,表示為後序表示式時是ab+cd+*。

    解法

    用手算的方式來計算後序式相當的簡單,將運算子兩旁的運算元依先後順序全括號起來,然後將所有的右括號取代為左邊最接近的運算子(從最內層括號開始),最後去掉所有的左括號就可以完成後序表示式,例如:
    a+b*d+c/d   =>    ((a+(b*d))+(c/d)) -> bd*+cd/+

    如果要用程式來進行中序轉後序,則必須使用堆疊,演算法很簡單,直接敘述的話就是使用迴圈,取出中序式的字元,遇運算元直接輸出,堆疊運算子與左括號, ISP>ICP的話直接輸出堆疊中的運算子,遇右括號輸出堆疊中的運算子至左括號。 

    演算法

    以下是虛擬碼的運算法,\0表示中序式讀取完畢: 
    Procedure Postfix(infix) [
        Loop [
            op = infix(i) 
            case [
                :x = '\0': 
                    while (stack not empty) 
                         // output all elements in stack 
                    end 
                    return 
                 :x = '(': 
                     // put it into stack 
                 :x is operator: 
                      while (priority(stack[top]) >= 
                             priority(op)) [
                           // out a element from stack 
                      ]
                      // save op into stack 
                 :x = ')': 
                       while ( stack(top) != '(' ) [
                           // out a element from stack 
                       ]
                       top = top - 1  // not out '( 
                 :else: 
                       // output current op 
            ]
            i++; 
        ]
    ] 
    

    例如(a+b)*(c+d)這個式子,依演算法的輸出過程如下:
    OP STACK OUTPUT
    ( ( -
    a ( a
    + (+ a
    b (+ ab
    ) - ab+
    * * ab+
    ( *( ab+
    c *( ab+c
    + *(+ ab+c
    d *(+ ab+cd
    ) * ab+cd+
    - - ab+cd+*

    如果要將中序式轉為前序式,則在讀取中序式時是由後往前讀取,而左右括號的處理方式相反,其餘不變,但輸出之前必須先置入堆疊,待轉換完成後再將堆疊中的 值由上往下讀出,如此就是前序表示式。 

    實作

    • C
    #include <stdio.h> 
    #include <stdlib.h> 
    
    int postfix(char*); // 中序轉後序 
    int priority(char); // 決定運算子優先順序 
    
    int main(void) { 
        char input[80]; 
    
        printf("輸入中序運算式:"); 
        scanf("%s", input); 
        postfix(input); 
    
        return 0; 
    } 
    
    int postfix(char* infix) { 
        int i = 0, top = 0; 
        char stack[80] = {'\0'}; 
        char op; 
    
        while(1) { 
            op = infix[i]; 
    
            switch(op) { 
                case '\0': 
                    while(top > 0) { 
                        printf("%c", stack[top]); 
                        top--; 
                    } 
                    printf("\n"); 
                    return 0; 
                // 運算子堆疊 
                case '(': 
                    if(top < (sizeof(stack) / sizeof(char))) { 
                        top++; 
                        stack[top] = op; 
                    } 
                    break; 
                case '+': case '-': case '*': case '/': 
                    while(priority(stack[top]) >= priority(op)) { 
                        printf("%c", stack[top]); 
                        top--; 
                    } 
                    // 存入堆疊 
                    if(top < (sizeof(stack) / sizeof(char))) { 
                        top++; 
                        stack[top] = op; 
                    } 
                    break; 
                // 遇 ) 輸出至 ( 
                case ')': 
                    while(stack[top] != '(') { 
                        printf("%c", stack[top]); 
                        top--; 
                    } 
                    top--;  // 不輸出( 
                    break; 
                // 運算元直接輸出 
                default: 
                    printf("%c", op); 
                    break; 
            } 
            i++; 
        } 
    } 
    
    int priority(char op) { 
        int p; 
    
        switch(op) { 
           case '+': case '-': 
                p = 1; 
                break; 
            case '*': case '/': 
                p = 2; 
                break; 
            default: 
                p = 0; 
                break; 
        } 
    
        return p; 
    } 
    

    • Java
    public class InFix {
        private static int priority(char op) {  
            switch(op) { 
               case '+': case '-': 
                    return 1; 
                case '*': case '/': 
                    return 2;
                default: 
                    return 0;
            }  
        }
        
        public static char[] toPosfix(char[] infix) {
            char[] stack = new char[infix.length]; 
            char[] postfix = new char[infix.length];
            char op; 
    
            StringBuffer buffer = new StringBuffer();
    
            int top = 0;
            for(int i = 0; i < infix.length; i++) { 
                op = infix[i]; 
                switch(op) {  
                    // 運算子堆疊 
                    case '(': 
                        if(top < stack.length) { 
                            top++; 
                            stack[top] = op; 
                        } 
                        break; 
                    case '+': case '-': case '*': case '/': 
                        while(priority(stack[top]) >= 
                              priority(op)) { 
                            buffer.append(stack[top]);
                            top--; 
                        } 
                        // 存入堆疊 
                        if(top < stack.length) { 
                            top++; 
                            stack[top] = op; 
                        } 
                        break; 
                    // 遇 ) 輸出至 ( 
                    case ')': 
                        while(stack[top] != '(') { 
                            buffer.append(stack[top]);
                            top--; 
                        } 
                        top--;  // 不輸出( 
                        break; 
                    // 運算元直接輸出 
                    default: 
                        buffer.append(op);
                        break; 
                } 
            } 
            
            while(top > 0) { 
                buffer.append(stack[top]);
                top--; 
            }
            
            return buffer.toString().toCharArray();
        }
        
        public static char[] toPrefix(char[] infix) {
            char[] stack = new char[infix.length];
            char op; 
    
            StringBuffer buffer = new StringBuffer();
            
            int top = 0;
            for(int i = infix.length - 1; i >= 0; i--) { 
                op = infix[i]; 
                switch(op) {  
                    // 運算子堆疊 
                    case ')': 
                        if(top < stack.length) { 
                            top++; 
                            stack[top] = op; 
                        } 
                        break; 
                    case '+': case '-': case '*': case '/': 
                        while(priority(stack[top]) >= 
                              priority(op)) { 
                            buffer.append(stack[top]);
                            top--; 
                        } 
                        // 存入堆疊 
                        if(top < stack.length) { 
                            top++; 
                            stack[top] = op; 
                        } 
                        break; 
                    // 遇 ( 輸出至 ) 
                    case '(': 
                        while(stack[top] != ')') { 
                            buffer.append(stack[top]);
                            top--; 
                        } 
                        top--;  // 不輸出) 
                        break; 
                    // 運算元直接輸出 
                    default: 
                        buffer.append(op); 
                        break; 
                } 
            } 
            
            while(top > 0) { 
                buffer.append(stack[top]);
                top--; 
            } 
            
            return buffer.reverse().toString().toCharArray();
        }
        
        public static void main(String[] args) {
            String infix = "(a+b)*(c+d)";
            
            System.out.println(
                        InFix.toPosfix(infix.toCharArray()));
            System.out.println(
                        InFix.toPrefix(infix.toCharArray()));
        }
    } 

  • 相关阅读:
    POJ 1113 Wall
    POJ 3525 Most Distant Point from the Sea
    POJ 3335 Rotating Scoreboard
    POJ 1228 Grandpa's Estate
    POJ 1873 The Fortified Forest
    POJ 2354 Titanic
    POJ 3130 How I Mathematician Wonder What You Are!
    POJ 1106 Transmitters
    POJ 1474 Video Surveillance
    seajs 的研究一 无题
  • 原文地址:https://www.cnblogs.com/marryZhan/p/2797282.html
Copyright © 2011-2022 走看看