c語言實現表達式求值的方法

這期內容當中小編將會給大家帶來有關c語言實現表達式求值的方法，以專業的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

一.不包括括號運算

#include<iostream>  
#include<stdio.h>  
#include<stdlib.h>  
#include<string>  
#include<math.h>  
#define STACK_INIT_SIZE 100  
using namespace std;  
typedef struct  
{  
    char date[STACK_INIT_SIZE];  
    int top;  
}OptrStack;     //操作符結構體    
  
typedef struct  
{  
    double date[STACK_INIT_SIZE];  
    int top;  
}OpndStack;     //操作數結構體    
  
//操作符相關操作  
OptrStack *Init_OptrStack();    //置棧空  
int Empty_OptrStack(OptrStack *s);//判空棧  
int Push_OptrStack(OptrStack *s, char x);//入棧(注意：判斷棧是否已滿)  
char Pop_OptrStack(OptrStack *s, char x);//出棧(注意：判斷棧是否已空)  
char GetTop_OptrStack(OptrStack *s, char x);//取棧頂元素，先判空  
  
//操作數相關操作  
OpndStack *Init_OpndStack();//置棧空  
int Empty_OpndStack(OpndStack *t);//判空棧  
int  Push_OpndStack(OpndStack *t, double y);//入棧(注意：判斷棧是否已滿)  
double Pop_OpndStack(OpndStack *t, double y);//出棧(注意：判斷棧是否已空)  
double GetTop_OpndStack(OpndStack *t, double y);//取棧頂元素  
  
//表達式求值函數  
void Error(char *s);                  //錯誤處理函數  
int Judge_optr(char ch);              //用于判斷字符ch是否是運算符  
int Operate(int a, int b, char top);  //用于計算當前的值，并將該值返回  
void Jsbds_operate(char str[]);        //讀入一個簡單算術表達式的值  
  
//操作符函數實現部分  
OptrStack *Init_OptrStack()  
{  
    OptrStack *s;  
    s = (OptrStack *)malloc(sizeof(OptrStack));  
    s->top = -1;  
    return s;  
}  
int Empty_OptrStack(OptrStack *s)//判空棧  
{  
    if (s->top != -1)  
        return 1;  
    else  
        return 0;  
}  
int  Push_OptrStack(OptrStack *s, char x)//入棧(注意：判斷棧是否已滿)  
{  
    if (s->top == (STACK_INIT_SIZE - 1))  
    {  
        return 0;  
    }  
    else  
        s->date[++s->top] = x;  
    return 1;  
  
}  
char Pop_OptrStack(OptrStack *s, char x)//出棧(注意：判斷棧是否已空)  
{  
    if (!Empty_OptrStack(s))  
    {  
        return 0;  
    }  
    else  
    x = s->date[s->top];  
    s->top--;  
    return x;  
}  
char GetTop_OptrStack(OptrStack *s, char x)//取棧頂元素，先判空  
{  
    if (!Empty_OptrStack(s))  
    {  
        return 0;  
    }  
    else  
        x = s->date[s->top];  
    return x;  
}  
//操作數函數實現部分  
OpndStack *Init_OpndStack()//置棧空  
{  
    OpndStack *t;  
    t = (OpndStack*)malloc(sizeof(OpndStack));  
    t->top = -1;  
    return t;  
}  
int Empty_OpndStack(OpndStack *t)//判空棧  
{  
    if (t->top != -1)  
        return 1;  
    else  
        return 0;  
}  
int  Push_OpndStack(OpndStack *t, double y)//入棧(注意：判斷棧是否已滿)  
{  
    if (t->top == (STACK_INIT_SIZE - 1))  
    {  
        return 0;  
    }  
    else  
        t->date[++t->top] = y;  
    return 1;  
}  
double Pop_OpndStack(OpndStack *t, double y)//出棧(注意：判斷棧是否已空)  
{  
    if (!Empty_OpndStack(t))  
    {  
        return 0;  
    }  
    else   
    y = t->date[t->top];  
    t->top--;  
    return y;  
}  
double GetTop_OpndStack(OpndStack *t, double y)//取棧頂元素  
{  
    if (!Empty_OpndStack(t))  
    {  
        return 0;  
    }  
    y = t->date[t->top];  
    return y;  
}  
  
//表達式求值函數實現  
void Error(char *s)   //錯誤處理函數  
{  
    std::cout << s << endl;  
    exit(1);  
}  
int Judge_optr(char top)//用于判斷字符ch是否是運算符  
{  
    int x;  
    //cout << top << "test" << endl;  
    switch (top)  
    {  
    case '+':  
    case '-':  
        x = 1; break;  
    case '*':  
    case '/':  
        x = 2; break;  
    }  
    return x;  
}  
double Operate(double b, double a, char top)  //用于計算當前的值，并將該值返回  
{  
    double c = 0;  
    switch (top)  
    {  
    case '+':  
        c = b + a;  
        break;  
    case '-':  
        c = b - a;  
        break;  
    case '*':  
        c = b * a;  
        break;  
    case '/':  
        if (a == 0)  
        {  
            printf("分母為零!\n");  
            return 0;  
        }  
        else  
            c = b / a;  
        break;  
    default:  
        printf("輸入的字符非法!\n");  
        break;  
    }  
    return c;  
}  
void Jsbds_operate(char str[])             //讀入一個簡單算術表達式,并將計算結果返回到主函數  
{  
    OptrStack *optr = Init_OptrStack();     //初始化操作符棧    
    OpndStack *opnd = Init_OpndStack();     //初始化操作數棧    
    int i, j;                               //i,j為循環變量，a,b接收從操作數棧中出棧的元素    
    double f;                               //接收將字符數轉換為浮點數的值    
    double a = 0;  
    double b = 0;  
    double c = 0;  
    char d[100];                           //儲存字符串中連續的‘數’    
    char top = 0;                          //接收從操作符棧中出棧的元素   
    for (i = 0; str[i]; i++)               //將字符串中的元素按順序入到棧中  
    {  
        switch (str[i])  
        {  
        case '+':  
        case '-':  
            /*先判斷當前運算符與操作符棧棧頂元素的優先級，如果高于棧頂元素，則入棧； 
            小于棧頂元素，則從操作數棧中依次出兩個數，并將操作符棧中棧頂元素出棧， 
            再將從操作數棧中出的兩個數，按從操作符棧棧中出的運算符運算， 
            并將結果壓入操作數棧中，再將當前的操作符壓入操作符棧中。*/  
            if (!Empty_OptrStack(optr))  //當操作符棧為空的時候壓棧保存  
            {  
                Push_OptrStack(optr, str[i]);  
            }  
            else  
            {  
                a = Pop_OpndStack(opnd, a); //接收從操作數棧中出棧的元素    
                b = Pop_OpndStack(opnd, b); //接收從操作數棧中出棧的元素    
                top = Pop_OptrStack(optr, top);//接收從操作符棧中出棧的元素    
                c = Operate(b, a, top);  
                Push_OpndStack(opnd, c);  
                //將計算后的值壓入操作數棧中    
                Push_OptrStack(optr, str[i]);  
            }  
            break;  
        case '*':  
        case '/':  
            if ((!Empty_OptrStack(optr))||(Judge_optr(str[i]) > Judge_optr(GetTop_OptrStack(optr, top))))  
            { //當操作符棧為空或者該操作符的優先級大于棧頂元素的優先級是入棧保存  
                Push_OptrStack(optr, str[i]);  
            }  
            else  
            {  
                a = Pop_OpndStack(opnd, a);//接收從操作數棧中出棧的元素    
                b = Pop_OpndStack(opnd, b);//接收從操作數棧中出棧的元素    
                top = Pop_OptrStack(optr, top);//接收從操作符棧中出棧的元素   
                c = Operate(b, a, top);  
                Push_OpndStack(opnd, c);  
                //將計算后的值壓入操作數棧中    
                Push_OptrStack(optr, str[i]);  
            }  
        case '\0':  
            break;  
        default:  
            j = 0;  
            do  
            {  
                d[j++] = str[i];  
                i++;  
            } while (str[i] >= '0' && str[i] <= '9');  //可存入一個或多個數字字符    
            d[j] = '\0';                  //將輸入的連續多個數字字符拼成了字符串    
            i--;  
            f = atof(d);                //調用庫函數atoi()將字符數轉換為浮點數    
            Push_OpndStack(opnd, f);    //將轉換后的數壓入操作數棧中    
            break;  
        }  
    }  
    while (Empty_OptrStack(optr))  //當操作符棧不為空的時候執行  
    {  
        a = Pop_OpndStack(opnd, a);//接收從操作數棧中出棧的元素   
        b = Pop_OpndStack(opnd, b);//接收從操作數棧中出棧的元素    
        top = Pop_OptrStack(optr, top);//接收從操作符棧中出棧的元素    
        c = Operate(b, a, top);  
        Push_OpndStack(opnd, c);  
        //將計算后的值壓入操作數棧中       
    }  
    cout << "該表達式的計算結果為：";  
    std::cout << GetTop_OpndStack(opnd, c) << endl;//將操作數棧中的元素(即表達式的最終結果)打印出來    
}  
  
int main()  
{  
    char str[100];  
    std::cout << "請輸入算術表達式(功能：+，-，*，/)" << endl;  
    cin >> str;  
    Jsbds_operate(str);  
    return 0;  
}

二.包括括號運算（粘貼修改部分）

int Judge_optr(char top)//用于判斷字符ch是否是運算符
{
int x;
//cout << top << "test" << endl;
switch (top)
{
case '(':
x = 0; break;
case '+':
case '-':
x = 1; break;
case '*':
case '/':
x = 2; break;
case ')':
x = 3; break;
}
return x;
}
double Operate(double b, double a, char top)  //用于計算當前的值，并將該值返回
{
double c = 0;
switch (top)
{
case '+':
c = b + a;
break;
case '-':
c = b - a;
break;
case '*':
c = b * a;
break;
case '/':
if (a == 0)
{
printf("分母為零!\n");
return 0;
}
else
c = b / a;
break;
default:
printf("輸入的字符非法!\n");
break;
}
return c;
}
void Jsbds_operate(char str[])             //讀入一個簡單算術表達式,并將計算結果返回到主函數
{
OptrStack *optr = Init_OptrStack();     //初始化操作符棧  
OpndStack *opnd = Init_OpndStack();     //初始化操作數棧  
int i, j;                               //i,j為循環變量，a,b接收從操作數棧中出棧的元素  
double f;                               //接收將字符數轉換為浮點數的值  
double a = 0;
double b = 0;
double c = 0;
char d[100];                           //儲存字符串中連續的‘數’  
char top = 0;                          //接收從操作符棧中出棧的元素 
for (i = 0; str[i]; i++)               //將字符串中的元素按順序入到棧中
{
switch (str[i])
{
case '(':
case '+':
case '-':
/*先判斷當前運算符與操作符棧棧頂元素的優先級，如果高于棧頂元素，則入棧；
小于棧頂元素，則從操作數棧中依次出兩個數，并將操作符棧中棧頂元素出棧，
再將從操作數棧中出的兩個數，按從操作符棧棧中出的運算符運算，
并將結果壓入操作數棧中，再將當前的操作符壓入操作符棧中。*/
if ((!Empty_OptrStack(optr)) || (Judge_optr(str[i]) > Judge_optr(GetTop_OptrStack(optr, top)))||(str[i]=='('))  //當操作符棧為空的時候壓棧保存
{
Push_OptrStack(optr, str[i]);
}
else
{
a = Pop_OpndStack(opnd, a); //接收從操作數棧中出棧的元素  
b = Pop_OpndStack(opnd, b); //接收從操作數棧中出棧的元素  
top = Pop_OptrStack(optr, top);//接收從操作符棧中出棧的元素  
c = Operate(b, a, top);
Push_OpndStack(opnd, c);
//將計算后的值壓入操作數棧中  
Push_OptrStack(optr, str[i]);
}
break;
case '*':
case '/':
if ((!Empty_OptrStack(optr)) || (Judge_optr(str[i]) > Judge_optr(GetTop_OptrStack(optr, top))) || (str[i] == '('))
{ //當操作符棧為空或者該操作符的優先級大于棧頂元素的優先級是入棧保存
Push_OptrStack(optr, str[i]);
}
else
{
a = Pop_OpndStack(opnd, a);//接收從操作數棧中出棧的元素  
b = Pop_OpndStack(opnd, b);//接收從操作數棧中出棧的元素  
top = Pop_OptrStack(optr, top);//接收從操作符棧中出棧的元素 
c = Operate(b, a, top);
Push_OpndStack(opnd, c);
//將計算后的值壓入操作數棧中  
Push_OptrStack(optr, str[i]);
}
break;
case ')':
Push_OptrStack(optr, str[i]);
break;
case '\0':
break;
default:
j = 0;
do
{
d[j++] = str[i];
i++;
} while (str[i] >= '0' && str[i] <= '9');  //可存入一個或多個數字字符  
d[j] = '\0';                  //將輸入的連續多個數字字符拼成了字符串  
i--;
f = atof(d);                //調用庫函數atoi()將字符數轉換為浮點數  
Push_OpndStack(opnd, f);    //將轉換后的數壓入操作數棧中  
break;
}
}
while (Empty_OptrStack(optr))  //當操作符棧不為空的時候執行
{
if ((GetTop_OptrStack(optr, top) == ')') || (GetTop_OptrStack(optr, top) == '('))
{
top=Pop_OptrStack(optr, top);
}
else
{
a = Pop_OpndStack(opnd, a);//接收從操作數棧中出棧的元素 
b = Pop_OpndStack(opnd, b);//接收從操作數棧中出棧的元素  
top = Pop_OptrStack(optr, top);//接收從操作符棧中出棧的元素  
c = Operate(b, a, top);
Push_OpndStack(opnd, c);
//將計算后的值壓入操作數棧中  
}
}
cout << "該表達式的計算結果為：";
std::cout << GetTop_OpndStack(opnd, c) << endl;//將操作數棧中的元素(即表達式的最終結果)打印出來  
}

上述就是小編為大家分享的c語言實現表達式求值的方法了，如果您也有類似的疑惑，不妨參照上述方法進行嘗試。如果想了解更多相關內容，請關注億速云行業資訊。