精华内容
下载资源
问答
  • 基于栈的中缀算式表达式求值问题:要求:运行软件调试引用函数将字符串转换成浮点数atof函数:strtod函数:memset函数判断符号优先级表代码实现: 问题: 输入一个中缀算术表达式,求解表达式的值。运算符包括+、-、...

    问题:

    输入一个中缀算术表达式,求解表达式的值。运算符包括+、-、*、/、(、)、=,参加运算的数为double类型且为正数。(要求:直接针对中缀算术表达式进行计算,不能转换为后缀或前缀表达式再进行计算,只考虑二元运算即可。)

    要求:

    (1)创建名为kcsj12.cpp的文件,并编写程序实现指定功能;
    (2)输入:多组数据,每组数据一行,对应一个算术表达式,每个表达式均以“=”结尾。当表达式只有一个“=”时,输入结束。参加运算的数为double类型;
    (3)输出:对于每组数据输出一行,为表达式的运算结果。输出保留两位小数。
    输入样例和输出样例:

    输入:
    2+2=
    20*(4.5-3)=
    =
    输出:
    4.00
    30.00

    运行软件

    CLion

    调试

    debug

    引用函数

    将字符串转换成浮点数

    atof函数:

    atof()是C 语言标准库中的一个字符串处理函数,功能是把字符串转换成浮点数,所使用的头文件为<stdlib.h>。

    示例代码:

    #include<stdlib.h>
    #include<stdio.h>
    int main()
    {
    double d;
    char str[] = "123.456";
    d=atof(str);
    printf("string=%sdouble=%lf\n",str,d);
    return 0;
    }
    

    strtod函数:

    strtod是C语言及C++中的重要函数,功能是将字符串转换成浮点数,表头文件是#include <stdlib.h>,相关函数有atoi,atol,strtod,strtol。

    示例代码:

    #include<stdlib.h>
    #include<stdio.h>
    void main()
    {
        char *endptr;
        char a[] = "12345.6789";
        char b[] = "1234.567qwer";
        char c[] = "-232.23e4";
        printf( "a=%lf\n", strtod(a,NULL) );
        printf( "b=%lf\n", strtod(b,&endptr) );
        printf( "endptr=%s\n", endptr );
        printf( "c=%lf\n", strtod(c,NULL) );
    }
    

    memset函数

    memset是计算机中C/C++语言初始化函数。作用是将某一块内存中的内容全部设置为指定的值, 这个函数通常为新申请的内存做初始化工作。

    char chs[20];
    memset(chs,'#', sizeof(char)*20);
    

    判断符号优先级表

    (1)先乘除,后加减;
    (2)从左算到右;
    (3)先括号内,后括号外

    在这里插入图片描述

    • 由规则(1), 先进行乘除运算,后进行加减运算,所以有 “+” < “"; “+” < “!”; "” >。
    • 由规则(2), 运算遵循左结合性,当两个运算符相同时,先出现的运算符优先级高,所以有

    “+” > “+”;
    “-” > “-”;
    " * " > " * ";
    “/” > “/”。

    • 由规则(3), 括号内的优先级高,+、-、*和I为81 时的优先性均低千 (" “但高于 " )”。表中的 “(” = “)” 表示当左右括号相遇时,括号内的运算已经完成。为了便千实现,假设每个表达式均以"#“开始,以”#" 结束。所以"#" = “#” 表示整个表达式求值完毕。")“与 “(”、"#”与”)" 以及"(“与”#" 之间无优先关系,这是因为表达式中不允许它们相继出现,一旦遇到这种情况,则可以认为出现了语法错误。在 下面的讨论中,我们暂假定所输人的表达
      式不会出现语法错误。

    代码实现:

    #include <iostream>
    #include <stdlib.h>
    #include <cstring>
    #define MAXSIZE 100//初始分配的存储空间
    #define OK 0
    #define  OVERFLOW 1
    #define ERROR 1
    typedef char SElemType;
    typedef int Status;
    using namespace std;
    
    //定义字符栈
    typedef struct {
        SElemType *base;//栈底指针,始终指向栈底元素,构造之前和销毁之后base的值为NULL
        SElemType *top;//栈顶指针,始终指向栈顶元素的下一个位置
        int stackSize;//当前分配的存储容量,以元素为单位
    } SqStackOPTR;
    
    //定义数字栈
    typedef struct {
        double *base;//栈底指针,始终指向栈底元素,构造之前和销毁之后base的值为NULL
        double *top;//栈顶指针,始终指向栈顶元素的下一个位置
        int stackSize;//当前分配的存储容量,以元素为单位
    } SqStackOPND;
    
    //字符栈的初始化
    Status InitStack(SqStackOPTR &S) {
        S.base = new SElemType[MAXSIZE]; //分配空间
        if (!S.base) exit(OVERFLOW);//分配失败,异常退出
        S.top = S.base;
        S.stackSize = MAXSIZE;
        return OK;
    }
    
    //数字栈的初始化
    Status InitStack(SqStackOPND &S) {
        S.base = new double[MAXSIZE]; //分配空间
        if (!S.base) exit(OVERFLOW);//分配失败,异常退出
        S.top = S.base;
        S.stackSize = MAXSIZE;
        return OK;
    }
    
    //字符栈入栈操作
    Status Push(SqStackOPTR &S, SElemType e) {
        if (S.top - S.base == MAXSIZE) //说明栈满
            return ERROR;
        *S.top++ = e;//元素e进栈
        return OK;
    }
    
    //数字栈入栈操作
    Status Push(SqStackOPND &S, double e) {
        if (S.top - S.base == MAXSIZE) //说明栈满
            return ERROR;
        *S.top++ = e;//元素e进栈
        return OK;
    }
    
    //字符栈出栈操作
    SElemType Pop(SqStackOPTR &S) {
        char e;
        if (S.top == S.base) return ERROR; //栈空
        e = *--S.top;//这里其实是将栈顶的指针向下移了以为,没有真正的删除元素   用e返回其值
        return e;
    }
    
    //数字栈出栈操作
    double Pop(SqStackOPND &S) {
        double e;
        if (S.top == S.base) return ERROR; //栈空
        e = *--S.top;//这里其实是将栈顶的指针向下移了以为,没有真正的删除元素   用e返回其值
        return e;
    }
    
    //取字符栈栈顶元素
    SElemType GetTop(SqStackOPTR S) {
        char e;
        if (S.top == S.base) return ERROR;//栈空
        e = *(S.top - 1);//返回
        return e;
    }
    
    //取数字栈栈顶元素
    double GetTop(SqStackOPND S) {
        double e;
        if (S.top == S.base) return ERROR;//栈空
        e = *(S.top - 1);//返回
        return e;
    }
    
    //判断字符的方法,判断输入的字符是数字还是运算符
    //如果是数字,那么返回0,如果是运算符,返回1
    Status In(SElemType e) {
        int isNumber;
        switch (e) {
            case '+':
            case '-':
            case '*':
            case '/':
            case '(':
            case ')':
            case '=':
                isNumber = 1;
                break;
            default:
                isNumber = 0;
                break;
        }
        return isNumber;
    
    }
    
    //定义一个判定运算符栈的栈顶元素与读入的运算符之间优先关系的函数
    char Precede(SElemType top, char ch) {
    /*
     * 算数四则运算遵循以下3条规则
     * (1)先乘除,后加减
     * (2)从左算到右
     * (3)先括号内,后括号外
     */
        char symbol;//定义一个字符串来接收> = <
    
    
    
        switch (top) {
            case '+':
            case '-':
                switch (ch) {
                    case '+':
                    case '-':
                    case ')':
                    case '=':
                        symbol = '>';
                        break;
                    case '*':
                    case '/':
                    case '(':
                        symbol = '<';
                        break;
                }
                break;
            case '*':
            case '/':
                switch (ch) {
                    case '+':
                    case '-':
                    case '*':
                    case '/':
                    case ')':
                    case '=':
                        symbol = '>';
                        break;
                    case '(':
                        symbol = '<';
                        break;
                }
                break;
            case '(':
                switch (ch) {
                    case '+':
                    case '-':
                    case '*':
                    case '/':
                    case '(':
                        symbol = '<';
                        break;
                    case ')':
                        symbol = '=';
                        break;
                }
                break;
            case ')':
                switch (ch) {
                    case '+':
                    case '-':
                    case '*':
                    case '/':
                    case ')':
                    case '=':
                        symbol = '>';
                        break;
                }
                break;
            case '=':
                switch (ch) {
                    case '+':
                    case '-':
                    case '*':
                    case '/':
                    case '(':
                        symbol = '<';
                        break;
                    case '=':
                        symbol = '=';
                        break;
                }
                break;
        }
        return symbol;
    }
    
    //定义一个二元运算的方法,来进行+ - * /
    double Operate(double a, SElemType top, double b) {
        double sum = 0;
        switch (top) {
            case '+':
                sum = a + b;
                break;
            case '-':
                sum = a - b;
                break;
            case '*':
                sum = a * b;
                break;
            case '/':
                if (b != 0) sum = a / b;//如果是0怎么办
                break;
        }
        return sum;
    }//20*(4.5-3)=
    
    double EvaluateExpression(char ch) {
        //定义两个栈,分别为OPTR栈(放运算符)OPND栈(放数字)
        SqStackOPTR OPTR;//定义字符栈
        SqStackOPND OPND;//定义数字栈
        InitStack(OPTR);//初始化OPTR栈
        InitStack(OPND);//初始化OPND栈
        Push(OPTR, '=');//将表达式起始符’#‘压入OPTR栈
        char chs[20];//定义一个字符数组,来实现数字转换为字符串
      memset(chs,'#', sizeof(char)*20);//将字符数组的元素设置为‘#’
    
        while (ch != '=' || GetTop(OPTR) != '=') {//表达式没有扫描完毕或OPTR的栈顶元素不为“=”
            if (!In(ch)) {
                //这里应该将字符串转换为数字
                for (int i = 0; i <strlen(chs) ; i++) {
                    if (chs[i]=='#' && !In(ch)){//如果数组的第i个元素不为‘#’或不为符号
                        chs[i]=ch;
                        cin>>ch;
                    } else{
                        break;
                    }
                }
                double d=atof(chs);//把字符串转换成浮点数 double
    //            double d1=strtod(chs,NULL);//将字符串转换成浮点数
                Push(OPND,d);
                memset(chs,'#', sizeof(char)*20);//将字符数组的元素设置为‘#’
            } else {
                switch (Precede(GetTop(OPTR), ch)) {
                    case '<':
                        Push(OPTR, ch);cin>>ch;
                        break;
                    case '>':
                        char theta;
                        double b;
                        double a;
                        theta = Pop(OPTR);
                        b = Pop(OPND);
                        a = Pop(OPND);
                        double sum;
                        sum = Operate(a, theta, b);
                        Push(OPND,  sum);
                        break;
                    case '=':
                        Pop(OPTR);
                        cin>>ch;
                        break;
                }
            }
        }
        return GetTop(OPND);
    }
    
    int main() {
    
        while (1) {
            char ch;
            cin >> ch;
            if (ch == '=')break;
            double res = EvaluateExpression(ch);
           printf("%.2lf",res);
        }
        return 0;
    }
    
    

    在这里插入图片描述

    展开全文
  • 中缀算式转后缀算式

    千次阅读 2014-10-30 11:15:17
    #include #include #include #ifndef _Stack_h struct StackRecord; typedef struct StackRecord *Stack; int IsEmpty(Stack s); int IsFull(Stack s);...Stack CreateStack(int MaxElements);...void DisposeStack(St
    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    #ifndef _Stack_h
    
    struct StackRecord;
    typedef struct StackRecord *Stack;
    
    int IsEmpty(Stack s);
    int IsFull(Stack s);
    Stack CreateStack(int MaxElements);
    void DisposeStack(Stack s);
    void MakeEmpty(Stack s);
    void Push(int x,Stack s);
    int Top(Stack s);
    void Pop(Stack s);
    int TopAndPop(Stack s);
    #endif 
    //head is dummy
    
    #define EmptyTOS -1
    #define MinStackSize 5
    
    struct StackRecord{
    	int capacity;
    	int topofstack;
    	int *a;
    }; 
    
    int IsEmpty(Stack s){
    	return s->topofstack == EmptyTOS;
    }
    
    int IsFull(Stack s){
    	return s->topofstack == s->capacity -1;
    }
    
    Stack CreateStack(int MaxElements){
    Stack s;/*
    if(MaxElements<MinStackSize){
    	printf("Stack size is too small\n");
    	return 0;
    }	
    */
    s = (Stack)malloc(sizeof(struct StackRecord));
    if(s == NULL){
    	printf("Out of Space!\n");
    	return 0;
    }
    s->a = (int *)malloc(sizeof(int)*MaxElements);
    if(s->a == NULL){
    	printf("Out of Space\n");
    	return 0;
    }
    s->capacity = MaxElements;
    MakeEmpty(s);
    return s;
    }
    
    void DisposeStack(Stack s){
    	if(s!= NULL){
    		free(s->a);
    		free(s);
    	}
    }
    
    void MakeEmpty(Stack s){
    	s->topofstack = EmptyTOS;
    }
    
    void Push(int x,Stack s){
    	if(IsFull(s))
    		printf("Stack is Full\n");
    	s->a[++s->topofstack] = x;
    }
    
    int Top(Stack s){
    	if(!IsEmpty(s))
    		return s->a[s->topofstack];
    	printf("Stack is Empty\n");
    	return 0;
    }
    
    void Pop(Stack s){
    	if(IsEmpty(s))
    		printf("Stack is Empty\n");
    	else s->topofstack--;
    }
    
    int TopAndPop(Stack s){
    	if(!IsEmpty(s))
    		return s->a[s->topofstack--];
    	printf("Stack is Empty\n");
    	return 0;
    }
    int compare(char a,char b){
    	if((a == '+'||a == '-')&&(b == '*'||b == '/'))
    		return -1;
    	else if((a == '*'||a == '/')&&(b == '+'||b == '-'))
    		return 1;
    	else if((a == '*'||a == '/')&&(b == '*'||b == '/'))
    		return 0;
    	else if((a == '+'||a == '-')&&(b == '+'||b == '-'))
    		return 0;
    	else if(b == ')'&&a !='(')
    		return 1;
    	else if(a == '(')
    		return -1;
    }
    char *InfixToPostfix(char *express){
    	int len,i,j;
    	char postfix[50],ch;
    	Stack s;
    	len = strlen(express);
    	s = CreateStack(len);
    	for(i = 0,j;i<len;i++){
    		if(express[i]>='0'&&express[i]<='9'||express[i] == '.'){
    			postfix[j++] = express[i];
    			if((express[i+1]<'0' ||express[i+1]>'9')&&express[i+1]!='.')
    			postfix[j++] = ' ';
    		}
    		else {
    			if(express[i] == '+'&&express[i-1]!=')'&&(i == 0||express[i-1]<'0'||express[i-1]>'9'))
    			continue;
    			if(express[i] == '-'&&express[i-1]!=')'&&(i == 0||express[i-1]<'0'||express[i-1]>'9')){
    			postfix[j++] = express[i];
    		    continue;
    			}
    			if(express[i] == '('||IsEmpty(s))
    				Push(express[i],s);
    			/* else if(express[i] == ')'){
    				while(!IsEmpty(s)&&ch = top(s)&&ch!='('){
    					postfix[j++] = ch;
    					postfix[j++] = ' ';
    					pop(s);
    				}
    				pop(s);
    			}*/
    			else 
    			{
    				while(!IsEmpty(s)&&(ch =Top(s))!='\0'&&compare(ch,express[i])>=0){
    					Pop(s);
    					postfix[j++] = ch;
    					postfix[j++] = ' ';
    				}
    				if(ch == '('&&express[i] == ')')
    					Pop(s);
    				else
    					Push(express[i],s);
    			}
    		}
    	}
    	while(!IsEmpty(s)){
    		ch = Top(s);
    		postfix[j++] = ch;
    		postfix[j++] = ' ';
    		Pop(s);
    	}
    	if(postfix[j-1] == ' ')
    		postfix[j-1] = '\0';
    	else postfix[j] = '\0';
    	return postfix;
    }
    int main(){
    	char express[21];
    	char *postfix;
    	int i,j,n;
    	scanf("%s",express);
    	postfix = InfixToPostfix(express);
    	printf("%s",postfix);
    	return 0;
    }

    展开全文
  • 问题描述:输入一个中缀表达式,求解表达式的值。参加运算的数为double类型且为正数。 输入:对于一个算术表达式,每一个表达式均以“=”结尾。当表达式只有一个“=”时,输入结束。当表达式只有一个“=”时,输入...

    问题描述:输入一个中缀表达式,求解表达式的值。参加运算的数为double类型且为正数。

    输入:对于一个算术表达式,每一个表达式均以“=”结尾。当表达式只有一个“=”时,输入结束。当表达式只有一个“=”时,输入结束。参加运算的数位double类型。

    输出要求:对于每组数据输出一行,为表达式运算结果。输出保留两位小数。

    输入样例

    2+2=

    20*(4.5-3)=

    =

    输出样例:

    4.00

    30.00

    atof的用法:

    atof():double atof(const char *str );

    功 能: 把字符串转换成浮点数

    str:要转换的字符串。

    返回值:每个函数返回 double 值,此值由将输入字符作为数字解析而生成。 如果该输入无法转换为该类型的值,则返回值为 0.0。

    函数说明 :atof()会扫描参数str字符串,跳过前面的空格字符直到遇上数字或正负符号才开始做转换而再遇到非数字或字符串结束时('\0')才结束转换,并将结果返回,str字符串可包含正负号、小数点或E(e)来表示指数部分。

    #include<iostream>
    #include<cstdio>
    #include<cstdlib>
    #include<cstring>
    #include<cctype>
    #include<stack>
    using namespace std;
    int cmp(char c)
    {
    	if(c=='=')         return 0;
    	if(c=='-'||c=='+') return 1;
    	if(c=='*'||c=='/') return 2;
    	return 0;
    } 
    void compute(stack<double>&num,stack<char>&op)
    {
    	double b=num.top();
    	num.pop();
    	double a=num.top();
    	num.pop();
    	switch(op.top())
    	{
    		case'+':num.push(a+b);break;
    		case'-':num.push(a-b);break;
    		case'*':num.push(a*b);break;
    		case'/':num.push(a/b);break;
    	}
    	op.pop();
    }
    int main()
    {
    	string c;
    	stack<double> num;
    	stack<char> op;
    	while(cin>>c)
    	{
    		if(c=="=") break;
    	    int len=c.length();
    	    for(int i=0;i<len;i++)
    	    {
    			if(isdigit(c[i]))
    			{
    				double number=atof(&c[i]); 
    				while( i<len && (isdigit(c[i])||c[i]=='.') )  i++;
    				i--;               //一定要回到当前字符 
    				num.push(number);
    			}
    			else 
    			{
    				if(c[i]=='(')       //左括号直接入栈 
    				{       
    					op.push(c[i]);
    				}
    				else if(c[i]==')')  //右括号 出栈计算直到左括号为止 
    				{   
    					while(op.top()!='(') compute(num,op);
    					op.pop();
    				}
    				else if(op.empty()||cmp(c[i])>cmp(op.top()))  //栈空或者当前字符比栈顶字符优先级要高 ,直接入栈 
    				{
    					op.push(c[i]);
    				}
    				else //当前字符比栈顶字符优先级要低或者级别相同,那就出栈计算
    				{ 
    					while(!op.empty()&&cmp(c[i])<=cmp(op.top())) compute(num,op);
    					op.push(c[i]);
    				}
    			}
    	    }
    	    op.pop();
    	    printf("%.2f\n",num.top());
    	    num.pop();
        } 
    	return 0;
    }

     

    展开全文
  • 堆栈-直接-计算中缀算式表达式

    千次阅读 2012-11-16 12:14:16
    程序要求: 输入一个类似2 + 3 * ( 4 + 5 ) – 6/ 4的数学表达式,前提是输入的表达式是正确的,然后计算输出结果(本程序没考虑括号的匹配问题以及除数为0产生的异常) #include #include ...

    程序要求:

    输入一个类似2 + 3 * ( 4 + 5 ) – 6/ 4的数学表达式,前提是输入的表达式是正确的,然后计算输出结果(本程序没考虑括号的匹配问题以及除数为0产生的异常

    #include <iostream>

    #include <cstring>

    #include <cctype>

    #include <stack>


    using namespace std;


    void evaluate(stack<int>& numbers,stack<char>& operations);
    int input(istream& ins);


    int main()
    {
        cout<<"Input"<<endl;
        int result=0;
        result=input(cin);
        cout<<result<<endl;
        cout<<"End"<<endl;
        return 0;
    }
    int input(istream& ins){


        stack<int> numbers;
        stack<char> operations;
        int number;
        char symbol;


        while(ins && ins.peek()!='\n')
        {
            if(isdigit(ins.peek()))
            {
                ins>>number;
                numbers.push(number);
            }
            else if(strchr("*/(",ins.peek())!=NULL)
            {
                ins>>symbol;
                operations.push(symbol);
            }
            else if(ins.peek()==')')
            {
                ins.ignore();
                while(operations.top()!='('){
                    evaluate(numbers,operations);
                }
                operations.pop();
            }
            else if(strchr("+-",ins.peek())!=NULL)
            {
                while(!operations.empty() && operations.top()!='(')
                {
                    evaluate(numbers,operations);
                }
                ins>>symbol;
                operations.push(symbol);
            }
        }
        while(!operations.empty()){
            evaluate(numbers,operations);
        }
        return numbers.top();
    }
    void evaluate(stack<int>& numbers,stack<char>& operations){
        int operand1,operand2;
        operand2=numbers.top();
        numbers.pop();
        operand1=numbers.top();
        numbers.pop();
        switch(operations.top())
        {
            case '+':
                numbers.push(operand1+operand2);
                break;
            case '-':
                numbers.push(operand1-operand2);
                break;
            case '*':
                numbers.push(operand1*operand2);
                break;
            case '/':
                numbers.push(operand1/operand2);
                break;
        }
        operations.pop();
    }
    展开全文
  • 前缀、中缀和后缀算式

    千次阅读 2015-08-20 16:14:00
    .转换方法 中缀算式(3+4X)-2Y/3对应的后缀算式 34X*+2Y*3/- 乘号也应算进去 转载于:https://www.cnblogs.com/fthjane/p/4745532.html
  • 真真真的觉得数据结构好难,但是秉着...对象区分:对于一个字符串形式的数学算式,如何区分数字(1位数字、多位数字) 栈的创建… 堆栈的特点 Last in first out 两种实现方式(顺序存储): 数组实现 链表实现
  • 后缀算式9 2 3 +- 10 2 / -的值为__________。中缀算式(3+4X)-2Y/3对应的后缀算式 为_______________________________。
  • 最近因为需要了解如何将在Win应用程序控制台输入的算式表达式转化成其后缀表达式的算法,所以在网上搜索了一下,看到许多人的程序都只是对应于运算数在0~9的范围内的整型运算式,所以自己就写了一个可以计算浮点型...
  • } } } // 中缀表达式转换为后缀表达式,将结果存储在栈中返回,逆序显示即后缀表达式 public static void InfixToSuffix(String input) { for (int i = 0; i (); i++) { char ch = input.charAt(i); System.out....
  • 将数字栈和符号栈之间做运算 主程序的流程:读入字符串,判断字符串,将字符串的元素以此输入栈中,如果是符号输入符号栈,是数字输入数字栈,在通过对符号优先级的比较来把中缀式转化为后坠式,进行计算。...
  • 1.中缀计算器

    2018-10-08 22:23:18
    所谓“四则运算中缀表达式”,就是四则混合运算算式,比如9+7*(3-2),3*6-(4+8), 由于运算符号放在运算数值中间,所以被称为中缀表达式。   一、思路: 输入的字符串先用字符数组equ[1000]存放起来。扫描下去...
  • 计算中缀表达式

    万次阅读 多人点赞 2018-05-10 20:57:03
    转载自https://blog.csdn.net/qq_26286193/article/details/80214805“计算中缀表达式”可以称得上是一个特别经典...中缀表达式、后缀表达式等概念在这里就不赘述了,让我们直奔主题。题目:输入一个中缀表达式,计...
  • 中缀表达式计算

    2018-01-24 19:26:27
    从左到右遍历中缀表达式的每个数字和符号, 若是数字则直接输出,若是符号,则判断其与栈顶符号的优先级, 是右括号或者是优先级低于栈顶符号,则栈顶元素依次出栈,直到 遇到左括号或栈空,那个低优先级的符号入栈...
  • 简单的整数计算器 能够进行加、减、乘除运算。 采用中缀输入法 ,一次输入整个算式得出结果 缺点:不识别"( )",不能输入负数 ,有待改进
  • 中缀表达式值

    2017-03-27 20:26:00
    中缀表达式值(Expr.cpp) 【问题描述】 输入一个中缀表达式(由0-9组成的运算数、加+减—乘*除/四种运算符、左右小括号组成。注意“—”也可作为负数的标志,表达式以“@”作为结束符),判断表达式是否合法,...
  • 中缀表达式,即运算符在操作数中间。 计算中缀表达式时,逐个扫描表达式。 扫描时存入两个栈,操作数栈,和运算符栈。 例如 3*2^(4+2*2-1*3)-5  扫描表达式。 操作数栈以 栈$表示,运算符栈以 栈¥表示。 扫描...
  • 中缀表达式问题

    2019-04-09 17:15:02
    首先需要分配2个栈,一个作为临时存储运算符的栈S1(含一个结束符号),一个作为输入逆波兰式的栈S2(空栈),S1栈可先放入优先级最低的运算符#,注意,中缀式应以此最低优先级的运算符结束。可指定其他字符,不一定...
  • 中缀表达式的计算

    2020-04-01 17:33:27
    中缀表达式:就是我们平时用的表达式 形如:(3+54/2+2(1+1)*(2+2)) = 29 计算我们用两个栈来实现, 一个栈存数字, 一个栈存符号 步骤 遍历整个表达式,如果当前的字符是数字, 就存进栈里面,如果是符号,就把栈...
  • 中缀表达式,就是我们日常适用的算式,主要是运算符的优先级和括号会改变优先级。我们人用中缀表达式是很方便的,但是计算机算很不方便,所以就有了后缀表达式。 2.原理与代码 比如这样一个后缀表达式:ABCD-*+ ,...
  • 4.1 简易计算器实现对中缀表达式的计算功能要求思路代码总结 功能       输入一个算式,然后返回算式的计算结果。 要求 算式中只能包含 + - * / 四种运算操作符。 算式中的数据只能...
  • 中缀表达式求值

    千次阅读 2015-12-04 19:20:46
    中缀表达式求值 计算(calc.cpp) 【问题描述】 小明在你的帮助下,破密了Ferrari设的密码门,正要往前走,突然又出现了一个密码门,门上有一个算式,其中只有“(”,“)”,“0-9”,“+”,“-”,“*”,“/”,...
  • 中缀表达式就是我们平时最熟悉的算式表达式,操作符在两个数中间。那么可以想到后缀表达式就是操作符在两个数后面。 例子: 中缀表达式:1 + 2 * 3 后缀表达式:1 2 3 * + 算法过程 栈中存储的是操作符和括号。 从左...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,512
精华内容 604
关键字:

中缀算式