m0_61335583
2021-09-01 17:22
采纳率: 100%
浏览 20

C++、栈实现四则运算,编译可过结果不对

#include
#include
#define OK 1
#define ERROR 0
#define MAXSIZE 100
#define OVERFLOW -2

const char oper[7]={'+','-','*','/','(',')','#'};

using namespace std;
typedef char SElemType;//定义字符类型
typedef int NElemType;//定义int类型
typedef int Status;

typedef struct//字符型栈的存储结构
{
SElemType *base;
SElemType *top;
int stackSize;
}SqStack_optr;

typedef struct//int型栈的存储结构
{
NElemType *base;
NElemType *top;
int stackSize;
}SqStack_opnd;

Status InitStackS(SqStack_optr &S)//字符型栈的初始化
{
S.base = new SElemType[MAXSIZE];
if(!S.base) return OVERFLOW;
S.top=S.base;
S.stackSize = MAXSIZE;
return OK;
}

Status InitStackN(SqStack_opnd &S)//int型栈的初始化
{
S.base = new NElemType[MAXSIZE];
if(!S.base) return OVERFLOW;
S.top=S.base;
S.stackSize = MAXSIZE;
return OK;
}

Status PushS (SqStack_optr &S,SElemType e)//字符型进栈
{
if(S.top-S.base==S.stackSize) return ERROR;
*S.top++=e;
return OK;
}

Status PushN (SqStack_opnd &S,NElemType e)//int型进栈
{
if(S.top-S.base==S.stackSize) return ERROR;
*S.top++=e;
return OK;
}

Status PopS ( SqStack_optr &S, SElemType &e )//字符型栈顶元素退栈
{ if ( S.top==S.base )
return ERROR; // 栈空
e = * -- S.top; // --S.top; e=*S.top;
return OK;
} //Pop

Status PopN ( SqStack_opnd &S, NElemType &e )//int型栈顶元素退栈
{ if ( S.top==S.base )
return ERROR; // 栈空
e = * -- S.top; // --S.top; e=*S.top;
return OK;
} //Pop

SElemType GetTopS ( SqStack_optr S)//字符型取栈顶
{
SElemType e;
if ( S.top==S.base )
return ERROR; //栈空
e = *(S.top-1);
return e;
}

NElemType GetTopN ( SqStack_opnd S)//int型取栈顶
{
NElemType e;
if ( S.top==S.base )
return ERROR; //栈空
e = *(S.top-1);
return e;
}

bool In(char ch)//判断是否为运算符
{
for(int i=0;i<7;i++)
{
if(ch==oper[i])
return true;
}
return false;
}

char Precede(char theta1, char theta2)
{//判断运算符优先级
if ((theta1 == '(' && theta2 == ')') || (theta1 == '#' && theta2 == '#'))
{
return '=';
}
else if (theta1 == '(' || theta1 == '#' || theta2 == '(' || (theta1
== '+' || theta1 == '-') && (theta2 == '*' || theta2 == '/'))
{
return '<';
}
else
return '>';
}

int Operate(int first, char theta, int second)
{//计算两数运算结果
switch (theta)
{
case '+':
return first + second;
case '-':
return first - second;
case '*':
return first * second;
case '/':
return first / second;
}
return 0;
}

EvaluateExpression()
{
char c,theta,x;//c为输入的字符,theta为运算符
int a,b,num;
SqStack_optr OPTR;
SqStack_opnd OPND;
InitStackS(OPTR);//初始化OPTR栈
PushS (OPTR, '#');//将表达式起始符“#”压入OPTR栈
InitStackN(OPND);//初始化OPND栈
cin>>c;
while ( c!='#' || GetTopS(OPTR)!='#' )
{
if (! In (c)) // In(c, OP)判断c是否为运算符
{
num=c-'0';
PushN(OPND, num);
cin>>c;
} //不是运算符则进栈
else
{
switch (Precede(GetTopS(OPTR),c))//判定OPTR的栈顶运算符1与读入的运算符2间的优先关系
{ case '<': // 新输入的算符c优先级高,c进栈
PushS(OPTR, c);
cin>>c;
break;
case '=': // 脱括号并接收下一字符
PopS(OPTR, x);
cin>>c;
break;
case '>': //新输入的算符c优先级低,即栈顶算符优先权高
//出栈并将运算结果入栈OPND
PopS ( OPTR, theta); //弹出OPTR栈顶的运算符
PopN ( OPND, b);
PopN ( OPND, a); //弹出OPND栈顶的两个运算数
PushN ( OPND, Operate(a, theta, b) ); //进行二元运算ab,将运算结果压入OPND栈
break;
} //switch
}//else
} //while
return(GetTopN(OPND));
} //EvaluateExpression

int main()
{
int result;
result=EvaluateExpression();
cout<<resu<<endl;
system("pause");
return 0;
}

  • 收藏

1条回答 默认 最新

  • Pliosauroidea 2021-09-01 17:40
    已采纳

    具体是什么结果不对,我跑了几次都能正确输出

    img

    #include <iostream>
    // #include
    #define OK 1
    #define ERROR 0
    #define MAXSIZE 100
    #define OVERFLOW -2
    
    const char oper[7] = {'+', '-', '*', '/', '(', ')', '#'};
    
    using namespace std;
    typedef char SElemType; //定义字符类型
    typedef int NElemType;  //定义int类型
    typedef int Status;
    
    typedef struct //字符型栈的存储结构
    {
        SElemType *base;
        SElemType *top;
        int stackSize;
    } SqStack_optr;
    
    typedef struct //int型栈的存储结构
    {
        NElemType *base;
        NElemType *top;
        int stackSize;
    } SqStack_opnd;
    
    Status InitStackS(SqStack_optr &S) //字符型栈的初始化
    {
        S.base = new SElemType[MAXSIZE];
        if (!S.base)
            return OVERFLOW;
        S.top = S.base;
        S.stackSize = MAXSIZE;
        return OK;
    }
    
    Status InitStackN(SqStack_opnd &S) //int型栈的初始化
    {
        S.base = new NElemType[MAXSIZE];
        if (!S.base)
            return OVERFLOW;
        S.top = S.base;
        S.stackSize = MAXSIZE;
        return OK;
    }
    
    Status PushS(SqStack_optr &S, SElemType e) //字符型进栈
    {
        if (S.top - S.base == S.stackSize)
            return ERROR;
        *S.top++ = e;
        return OK;
    }
    
    Status PushN(SqStack_opnd &S, NElemType e) //int型进栈
    {
        if (S.top - S.base == S.stackSize)
            return ERROR;
        *S.top++ = e;
        return OK;
    }
    
    Status PopS(SqStack_optr &S, SElemType &e) //字符型栈顶元素退栈
    {
        if (S.top == S.base)
            return ERROR; // 栈空
        e = *--S.top;     // --S.top; e=*S.top;
        return OK;
    } //Pop
    
    Status PopN(SqStack_opnd &S, NElemType &e) //int型栈顶元素退栈
    {
        if (S.top == S.base)
            return ERROR; // 栈空
        e = *--S.top;     // --S.top; e=*S.top;
        return OK;
    } //Pop
    
    SElemType GetTopS(SqStack_optr S) //字符型取栈顶
    {
        SElemType e;
        if (S.top == S.base)
            return ERROR; //栈空
        e = *(S.top - 1);
        return e;
    }
    
    NElemType GetTopN(SqStack_opnd S) //int型取栈顶
    {
        NElemType e;
        if (S.top == S.base)
            return ERROR; //栈空
        e = *(S.top - 1);
        return e;
    }
    
    bool In(char ch) //判断是否为运算符
    {
        for (int i = 0; i < 7; i++)
        {
            if (ch == oper[i])
                return true;
        }
        return false;
    }
    
    char Precede(char theta1, char theta2)
    { //判断运算符优先级
        if ((theta1 == '(' && theta2 == ')') || (theta1 == '#' && theta2 == '#'))
        {
            return '=';
        }
        else if (theta1 == '(' || theta1 == '#' || theta2 == '(' || (theta1 == '+' || theta1 == '-') && (theta2 == '*' || theta2 == '/'))
        {
            return '<';
        }
        else
            return '>';
    }
    
    int Operate(int first, char theta, int second)
    { //计算两数运算结果
        switch (theta)
        {
        case '+':
            return first + second;
        case '-':
            return first - second;
        case '*':
            return first * second;
        case '/':
            return first / second;
        }
        return 0;
    }
    
    int EvaluateExpression()
    {
        char c, theta, x; //c为输入的字符,theta为运算符
        int a, b, num;
        SqStack_optr OPTR;
        SqStack_opnd OPND;
        InitStackS(OPTR); //初始化OPTR栈
        PushS(OPTR, '#'); //将表达式起始符“#”压入OPTR栈
        InitStackN(OPND); //初始化OPND栈
        cin >> c;
        while (c != '#' || GetTopS(OPTR) != '#')
        {
            if (!In(c)) // In(c, OP)判断c是否为运算符
            {
                num = c - '0';
                PushN(OPND, num);
                cin >> c;
            } //不是运算符则进栈
            else
            {
                switch (Precede(GetTopS(OPTR), c)) //判定OPTR的栈顶运算符1与读入的运算符2间的优先关系
                {
                case '<': // 新输入的算符c优先级高,c进栈
                    PushS(OPTR, c);
                    cin >> c;
                    break;
                case '=': // 脱括号并接收下一字符
                    PopS(OPTR, x);
                    cin >> c;
                    break;
                case '>': //新输入的算符c优先级低,即栈顶算符优先权高
                    //出栈并将运算结果入栈OPND
                    PopS(OPTR, theta); //弹出OPTR栈顶的运算符
                    PopN(OPND, b);
                    PopN(OPND, a);                     //弹出OPND栈顶的两个运算数
                    PushN(OPND, Operate(a, theta, b)); //进行二元运算ab,将运算结果压入OPND栈
                    break;
                } //switch
            }     //else
        }         //while
        return (GetTopN(OPND));
    } //EvaluateExpression
    
    int main()
    {
        int result;
        result = EvaluateExpression();
        cout << result << endl;
        system("pause");
        return 0;
    }
    
    打赏 评论

相关推荐 更多相似问题