逆波蘭式的產生與計算

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

生成逆波蘭式流程圖：

生成逆波蘭式流程圖

逆波蘭式的計算流程圖：

逆波蘭式的計算流程圖

要求：

可以區分小數點、乘方、正負號

程式碼：

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<algorithm>
#include<cctype>
#include<cstring>
using namespace std;

char str[50];   //用於存放原來的表示式
int top;    //棧頂指標
char stack[50];     //定義棧，用於計算逆波蘭式 

char ex[50];    //存放字尾表示式
double _stack[50]; //定義棧，用於計算逆波蘭式子
int flag[50];   //用於區分+、-號的含義，0表示運算子，1表示正負號

//生成逆波蘭式
void NiBolan()
{
    memset(flag,0,sizeof(flag));    //flag初始值設為0
    char ch=str[0];
    int i=1,t=0;
    top=0;

    while(ch!='#')
    {
        switch(ch)
        {
        case '(':
            top++;
            stack 
[top]=ch;
            break;
        case ')':
            while(stack[top]!='(')
            {
                ex[t]=stack[top];
                top--;
                t++;
            }
            top--;
            break;
        case '^':
            while(stack[top]=='^')  //設定^運算子優先順序為最高
            {
                ex[t]=stack 
[top];
                top--;
                t++;
            }
            top++;
            stack[top]=ch;
            break;
        case '+':
        case '-':
            //當ch為+、-號是，若前面相鄰字元不是')'或數字且後面相鄰字元是數字時表示正負號
            if(isdigit(str[i])  &&  !isdigit(str[i-2]) &&  str[i-2]!=')')
            {
                flag[t]=1;  //標記符號為正負號
                ex[t++]=ch;
                ch=str[i++];
                while((ch>='0'&&ch<='9')||ch=='.')  //判別小數點
                {
                    ex[t]=ch;
                    t++;
                    ch=str[i];
                    i++;
                }
                i--;
                ex[t]='&';
                t++;
            }
            else
            {
                while(top!=0&&stack[top]!='(')
                {
                    ex[t]=stack[top];
                    top--;
                    t++;
                }
                top++;
                stack[top]=ch;
            }
            break;
        case '*':
        case '/':
            while(stack[top]=='*'||stack[top]=='/'||stack[top]=='^')    //運算子^優先順序高於*和/
            {
                ex[t]=stack[top];
                top--;
                t++;
            }
            top++;
            stack[top]=ch;
            break;
        case ' ':
            break;
        default:
            while((ch>='0'&&ch<='9')||ch=='.')  //判別小數點
            {
                ex[t]=ch;
                t++;
                ch=str[i];
                i++;
            }
            i--;
            ex[t]='&';
            t++;
        }
        ch=str[i];
        i++;
    }
    while(top!=0)
        if(stack[top]!='(')
        {
            ex[t]=stack[top];
            t++;
            top--;
        }
        else
        {
            printf("error");
            top--;
            exit(0);
        }
    ex[t]='#';
    ex[t+1]='\0';
    printf("字尾表示式：%s\n",ex);

}

//計算逆波蘭式
void Calculate()
{
    char ch=ex[0];
    int t=0;
    top=-1;

    while(ch!='#')
    {
        if(ch=='&'){
            ch=ex[++t];
            continue;
        }
        switch(ch)
        {
        case '+':
            if(flag[t]) //'+'表示正號
            {
                ch=ex[++t];
                double d=0;
                while(ch>='0'&&ch<='9')
                {
                    d=10.0*d+double(ch-'0');
                    ch=ex[++t];
                }
                if(ch=='.')     //判斷是否為小數
                {
                    ch=ex[++t];
                    double k=1.0;
                    while(ch>='0'&&ch<='9')
                    {
                        d=d+double(ch-'0')/(10.0*k);
                        k=k+1.0;
                        ch=ex[++t];
                    }
                }
                top++;
                _stack[top]=d;
            }
            else
            {
                _stack[top-1]=_stack[top-1]+_stack[top];
                top--;
                t++;
            }
            break;
        case '-':
            if(flag[t]) //'-'表示負號
            {
                ch=ex[++t];
                double d=0;
                while(ch>='0'&&ch<='9')
                {
                    d=10.0*d+double(ch-'0');
                    ch=ex[++t];
                }
                if(ch=='.')
                {
                    ch=ex[++t];
                    double k=1.0;
                    while(ch>='0'&&ch<='9')
                    {
                        d=d+double(ch-'0')/(10.0*k);
                        k=k+1.0;
                        ch=ex[++t];
                    }
                }
                top++;
                _stack[top]=-d;
            }
            else
            {
                _stack[top-1]=_stack[top-1]-_stack[top];
                top--;
                t++;
            }
            break;
        case '^':   //運算子為'^'
            if(_stack[top]==0)
            {
                _stack[top-1]=1;
            }
            else
            {
                int temp;
                temp=_stack[top-1];
                while(--_stack[top])
                {
                    _stack[top-1]*=temp;
                }
            }
            top--;
            t++;
            break;
        case '*':
            _stack[top-1]=_stack[top-1]*_stack[top];
            top--;
            t++;
            break;
        case '/':
            if(_stack[top]!=0)
                _stack[top-1]=_stack[top-1]/_stack[top];
            else
            {
                printf("\n\tchu0error!\n");
                exit(0);
            }
            top--;
            t++;
            break;
        default:
            double d=0;
            while(ch>='0'&&ch<='9')
            {
                d=10.0*d+double(ch-'0');
                ch=ex[++t];
            }
            if(ch=='.') //判斷是否為小數
            {
                ch=ex[++t];
                double k=1.0;
                while(ch>='0'&&ch<='9')
                {
                    d=d+double(ch-'0')/(10.0*k);
                    k=k+1.0;
                    ch=ex[++t];
                }
            }
            top++;
            _stack[top]=d;
        }
        ch=ex[t];
    }
    cout<<"計算結果："<<_stack[top]<<endl;
    //printf("計算結果：%lf\n",_stack[top]);
}

int main()
{
    printf("請輸入中綴表示式：");
    scanf("%s",&str);   //輸入原表示式
    printf("原來表示式：%s\n",str);
    NiBolan();  //生成逆波蘭式
    Calculate();    //計算逆波蘭式
    return 0;
}

//  測試樣例               結果
//  21+((42-2)*15+6)-18#    609
//  1+(-5)+-3*-1#           -1
//  1+2^3*2#                17
//  1+-2^3*2#               -15
//  1+(1-3)^3#              -7
//  1*2^0#                  1

執行結果：
這裡寫圖片描述

逆波蘭式的產生與計算

生成逆波蘭式流程圖：逆波蘭式的計算流程圖：要求：可以區分小數點、乘方、正負號程式碼： #include<iostream> #include<stdio.h> #include<stdlib.h>

逆波蘭式的轉換與計算(簡單)

我們平常書寫的表示式:--如2+3*4+4 又稱為中綴表示式,我們可以將它轉換為字尾表示式 213*+4+ 輸入有兩行,第一行為逆波蘭式的結果,第二行為輸入表示式的正確計算結果。逆波蘭式中相鄰的數字或運算子之間不用輸出空格保證表示式計算的合理性,不需判斷除零等情況

逆波蘭式的計算（含有數學函式和浮點數）

#include<stdio.h> #include<stdlib.h> #include<string.h> #include<math.h> #define MAX 100 #define MARK 65535 typed

計算表示式的值c++逆波蘭式實現方法

#include<stack>//棧容器的標頭檔案 #include<iostream> #include<math.h> //數學標頭檔案次方函式 using namespace std; int Precedence(char

HDU1237 簡單計算器【棧】+【逆波蘭式】

a + b gree rac 簡單計算器 data- 3.0 center 一個空格 har 簡單計算器 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Othe

JavaScript中綴表達式轉為逆波蘭式（四則運算）

。。刪除並且 asc 情況暫存運算符 pan true 實現過程： 1.首先創建兩個空數組，result用來存放結果，temp用來存放符號；再創建一個符號集ops存放+-*/符號 2.轉表達式字符為數組，開始遍歷數組 3.如果遇到運算符，直接推入結果數組 4.遇到括

數據結構——逆波蘭式

算法指定 spa code eva eve != AD case 很久沒有關註算法和數據結構，大部分知識都已經忘記了；是時間好好回爐一下了，說實話幹讀數據機構這本書還是挺枯燥而且這本書原理性比較多，有一定的難度。這不剛看到逆波蘭式廢了好大勁才搞懂，老了。。。逆波蘭式

排序、堆疊、佇列、連結串列、遞迴、波蘭式和逆波蘭式

氣泡排序選擇排序：https://segmentfault.com/a/1190000009366805 插入排序希爾排序：https://segmentfault.com/a/1190000009461832 歸併排序快速排序：https://segment

java 實現中序表示式轉後序表示式（逆波蘭式）以及後序表示式求值

第一次寫部落格，還是個學生，沒有什麼經驗，只是單純的記錄下自己實現一個問題的方法與思想，如有錯誤之處，請各路大神批評指出。大概思想：跟參考部落格的思想差不多，單程式碼完全自己思考，實現過程有較多的if..else語句看起來可能會有點暈。各處都有註釋有不懂的可以私信我

逆波蘭式（字尾式）

逆波蘭式式波蘭邏輯學家盧卡西維奇發明的一種表示表示式的方法。這種表示方法把運算子寫在運算物件的後，例如把a+ba+ba+b寫成 ab+ab+ab+，所以也稱為字尾式。這種表示法的有嗲你是根據運算物件和運算子的出現次序進行計算，不需要使用括號，也便於用棧來求值。

逆波蘭式（字尾表示式）的表達求值

逆波蘭表示式求值 [編輯]虛擬碼 while有輸入符號讀入下一個符號IF是一個運算元入棧ELSE IF是一個操作符有一個先驗的表格給出該操作符需要n個引數IF堆疊中少於n個運算元（錯誤）使用者沒有輸入足夠的運算元Else，n個操作數出棧計算操作符。將計算所得的

【資料結構】中綴表示式轉換字尾表示式（逆波蘭式）

我的第一篇博文就是關於逆波蘭式的，現在回頭看感覺當時的程式碼太過混亂（不忍直視），在這裡對當時的程式碼進行一次重構。 #include <stdio.h> #include <s

表示式求值(逆波蘭式)

表示式求值時間限制：3000 ms | 記憶體限制：65535 KB 難度：4 描述ACM隊的mdd想做一個計算器，但是，他要做的不僅僅是一計算一個A+B的計算器，他想實現隨便輸入一個表示式都能求出它的值的計算器，現在請你幫助他來實現這個計算器吧。比如輸入

用逆波蘭表示式實現表示式計算

表示式求值計算，如計算1+((2+3)*4)-5的值。我的思路是先把表示式轉換為逆波蘭表示式，因為逆波蘭表示式更加符合計算機的處理邏輯，把表示式轉換為逆波蘭表示式的演算法如下：初始化兩個棧：運算子棧s2和儲存中間結果的棧s1；從左至右掃描中綴表示式；遇到運算元時，將

字首表示式（波蘭式）的計算

字首表示式的計算也是可以用遞迴來做可以把表示式的結構拆分為三個：運算子字首表示式字首表示式也就是說，數字也可以作為字首表示式，而表示式的值就是數字本身，所以當讀取完一個運算子之後，就可以按照

將中綴表示式轉化為逆波蘭式（c++實現）

<pre name="code" class="cpp">/************************************************************************* > File Name: ReversePol

C程式設計語言逆波蘭式計算器學習心得

#include<stdio.h> #include<stdlib.h> #define MAXOP 100 //這個是最大一次輸入的長度 #define NUMBER '0' //一個標誌，意味著接收到的是數字，換成其他也無妨 int getop(char[]);//宣告函式，

表示式求值運算（逆波蘭式）

逆波蘭式：中綴表示式，字尾表示式等內容可百度檢視。運算表示式 2+3*(1+2)-6/3開兩個棧，一個存數字，一個存符號。當遇到這種情況1：需要先計算後面的內容，再回來計算前面的運算讓符號進棧暫時儲

LeetCode | Evaluate Reverse Polish Notation（逆波蘭式求值）

Evaluate the value of an arithmetic expression in Reverse Polish Notation. Valid operators are +, -, *, /. Each operand may be an int

C語言利用棧實現將中綴表示式轉換為字尾表示式（即逆波蘭式）

輸入計算表示式如：（1-3）*4+10/5 輸出的逆波蘭式：1 3 - 4 * 10 5 / + 碼程式碼時臉上洋溢著的神祕的微笑 #include <stdio.h> #include <stdlib.h> #include

逆波蘭式的產生與計算

相關推薦