精华内容
下载资源
问答
  • 中缀表达式求值也就是 1、中缀表达式转后缀表达式 2、后缀表达式求值 合并 */ #include<stdlib.h> #include<stdio.h> #define Maxsize 10 typedef struct node{ char data[Maxsize]; int top; }...
    /*
    	中缀表达式求值也就是
    	1、中缀表达式转后缀表达式
    	2、后缀表达式求值
    	合并 
    */
    #include<stdlib.h>
    #include<stdio.h>
    #define Maxsize 10
    typedef struct node{
    	char data[Maxsize];
    	int top;
    }Stack;
    bool Isempty(Stack &s){
    	if(s.top == -1){
    		return true;
    	}
    	return false;
    }
    bool IsFull(Stack &s){
    	if(s.top+1 == Maxsize){
    		return true;
    	}
    	return false;
    }
    void InitStack(Stack &s){
    	s.top = -1;
    }
    bool PushStack(Stack &s,char data){
    	if(IsFull(s)){
    		return false;
    	}
    	s.data[++s.top] = data;
    	return true;
    }
    bool PopStack(Stack &s,char &data){
    	if(Isempty(s)){
    		return false;
    	}
    	data = s.data[s.top--];
    	return true;
    }
    bool GetTop(Stack &s,char &data){
    	if(Isempty(s)){
    		return false;
    	}
    	data = s.data[s.top];
    	return true;
    }
    int length(char str[]){
    	int length=0;
    	while(str[length] != '\0'){
    		length++;
    	}
    	return length;
    }
    bool IsNumber(char a){
    	if(a >= '0' && a <= '9'){
    		return true;
    	}
    	return false;
    }
    void change(Stack &s,char str[],char last[]){
    	int len = length(str);
    	int flag = -1;
    	char data;
    	for(int i=0;i<len;i++){
    		/*
    			如果是数字,直接拿出来,不做任何处理 
    		*/
    		if(IsNumber(str[i])){
    			flag++;
    			last[flag] = str[i];
    		}
    		/*
    			加减运算符优先级最低,如果栈顶元素为空则直接入栈,否则将栈中存储的运算符全部弹栈,
    			如果遇到左括号则停止,将弹出的左括号从新压栈,因为左括号要和又括号匹配时弹出,
    			这个后面单独讨论。弹出后将优先级低的运算符压入栈中
    		*/
    		else if(str[i] == '+' || str[i] == '-'){
    			if(Isempty(s)){
    				PushStack(s,str[i]);
    			}else{
    				while(!Isempty(s) && s.data[s.top] != '('){
    					PopStack(s,data);
    					flag++;
    					last[flag] = data;	
    				}
    				PushStack(s,str[i]);
    			}
    		}
    		/*
    			乘、除、左括号都是优先级高的,直接压栈
    		*/
    		else if(str[i] == '(' || str[i] == '*' || str[i] == '/'){
    			PushStack(s,str[i]);
    		}
    		/*
    			当遇到右括号是,把括号里剩余的运算符弹出,直到匹配到左括号为止
     			左括号只弹出不打印(右括号也不压栈)
    		*/
    		else if(str[i] == ')'){
    			PopStack(s,data);
    			while(data != '(' ){
    				flag++;			
    				last[flag] = data; 
    				PopStack(s,data);
    			}
    		}
    	}
    	/*
    		最后把栈中剩余的运算符依次弹栈
    	*/
    	while(!Isempty(s)){
    		PopStack(s,data);
    		flag++;			
    		last[flag] = data; 
    	}
    	last[++flag] = '\0';
    }
    
    bool lastnum(Stack &s,char str[],char &data){
    	int len = length(str);
    	char a,b,c;
    	int x,y ;
    	for(int i = 0;i<len;i++){
    		if(IsNumber(str[i])){
    			PushStack(s,str[i]);	
    		}
    		else{
    			PopStack(s,b);
    			PopStack(s,a);
    			if(str[i] == '+'){
    				x = a - '0';
    				y = b - '0';
    				x = x + y;
    			}else if(str[i] == '-'){
    				x = a - '0';
    				y = b - '0';
    				x = x - y;
    			}else if(str[i] == '*'){
    				x = a - '0';
    				y = b - '0';
    				x = x * y;
    			}else if(str[i] == '/'){
    				x = a - '0';
    				y = b - '0';
    				x = x / y;
    			}
    			c = x + 48;
    			PushStack(s,c); 
    		}
    	}
    	PopStack(s,data);
    }
    
    
    
    int main(){
    	Stack s;
    	InitStack(s);
    	char data; 
    	char str[] = "2*(9+6/3-5)+4";
    	int len = length(str);
    	char last[] ="";
    	change(s,str,last);
    	lastnum(s,last,data);
    	int zdk = data - '0';
    	printf("%d",zdk);
    }  
    
    展开全文
  • 中缀表达式求值C语言实现

    千次阅读 2021-05-01 22:01:22
    采用栈来实现中缀表达式求值问题

    如题:写出中缀表达式求值的算法:
    要求:
    ①先乘除,后加减
    ②从左向后算
    ③先括号内,后括号外

    代码实现

    SqStack.h 此文件为封装完成栈的相关操作

    #define MAXSIZE 100
    /*定义顺序栈*/
    typedef struct {
    	int *base;  //用于栈存储的基地址 
    	int *top;  //指向该基地址的栈顶指针 
    	int stackSize;  //栈的大小 
    }SqStackInt;
    /*定义顺序栈*/
    typedef struct {
    	char *base;  //用于栈存储的基地址 
    	char *top;  //指向该基地址的栈顶指针 
    	int stackSize;  //栈的大小 
    }SqStackChar;
    /*初始化*/
    int InitStack_Int(SqStackInt &S){
    	S.base = (int *)malloc(MAXSIZE*sizeof(int));  //给基地址分配一个内存空间 
    	S.top = S.base;  //将栈顶指针指向这个基地址 
    	S.stackSize = MAXSIZE;  //设置栈的大小 
    	return 0;
    } 
    int InitStack_Char(SqStackChar &S){
    	S.base = (char *)malloc(MAXSIZE*sizeof(char));  //给基地址分配一个内存空间 
    	S.top = S.base;  //将栈顶指针指向这个基地址 
    	S.stackSize = MAXSIZE;  //设置栈的大小 
    	return 0;
    } 
    /*进栈*/
    int Push_Int(SqStackInt &S,int e){
    	if(S.top-S.base==S.stackSize) return -1;
    	*S.top = e;  //将输入的值压入栈中 
    	S.top++;  //指针上移一个单位 
    	printf("操作数%d进S1栈\n",e) ;
    	return 0;
    } 
    int Push_Char(SqStackChar &S,char e){
    	if(S.top-S.base==S.stackSize) return -1;
    	*S.top = e;  //将输入的值压入栈中 
    	S.top++;  //指针上移一个单位 
    	printf("操作符%c进S2栈\n",e) ;
    	return 0;
    }
    /*出栈*/
    int Pop_Int(SqStackInt &S,int &e) {
    	if(S.base==S.top) return -1;
    	S.top--;  //指针下移一个 
    	e = *S.top;  //将当前指针所指的值赋值给e 
    	printf("出栈元素为:%d\n",e); 
    	return 0;
    }
    int Pop_Char(SqStackChar &S,char &e) {
    	if(S.base==S.top) return -1;
    	
    	S.top--;  //指针下移一个 
    	e = *S.top;  //将当前指针所指的值赋值给e 
    	printf("出栈符号为:%c\n",e); 
    	
    	return 0;
    }
    /*获取栈的长度*/
    int GetLength_Int(SqStackInt S){
    	return S.top-S.base;  
    }
    int GetLength_Char(SqStackChar S){
    	return S.top-S.base;  
    }
    /*判断栈空*/ 
    int StackEmpty_Int(SqStackInt S) {
    	if(S.top==S.base) return 0;  //为空返回 0 
    	return 1;  //不为空返回1 
    } 
    int StackEmpty_Char(SqStackChar S) {
    	if(S.top==S.base) return 0;  //为空返回 0 
    	return 1;  //不为空返回1 
    } 
    /*清空栈*/ 
    int ClearStack_Int(SqStackInt S){
    	if(S.base) //栈不为空 
    	S.base = S.top;
    	return 0;
    } 
    int ClearStack_Char(SqStackChar S){
    	if(S.base) //栈不为空 
    	S.base = S.top;
    	return 0;
    } 
    /*销毁栈*/ 
    int DestroyStack_Int(SqStackInt &S){
    	if(S.base){
    	free(S.base);
    	S.stackSize = 0;
    	S.top = S.base = NULL; 
    	}
    	return 0;
    }
    int DestroyStack_Char(SqStackChar &S){
    	if(S.base){
    	free(S.base);
    	S.stackSize = 0;
    	S.top = S.base = NULL; 
    	}
    	return 0;
    }
    /*读取栈顶元素*/
    int GetTop_Int(SqStackInt S) {
    	return *(S.top-1); 
    }
    char GetTop_Char(SqStackChar S) {
    	return *(S.top-1); 
    }
    
    

    EvaluateExpression.cpp

    #include<stdio.h>
    #include<stdlib.h> 
    #include"sqStack.h"
    
    int isOper(char c){
    	if(c == '#' || c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'){
    		return 1; //是操作符 
    	}else{
    		return 0;  //不是操作符 
    	}
    }
    /*
    * c1:栈顶操作符
    * c2:扫描操作符 
    *
    */
    char getStackTopPriority(char StackTop,char c){
    	//printf("Priority:%c::%c\n",StackTop,c);
    	if(StackTop == '#' || (StackTop == '(' && c != ')') || c == '(' ||( (StackTop == '+' || StackTop == '-')&&((c == '*' || StackTop == '*')))) {
    		return '<';  //栈顶操作符优先级 小于等于 当前扫描操作符则  操作符进栈 
    	}else if(StackTop =='(' && c == ')'){
    		return '=';
    	}else if(c == '*' || c == '/'||c == ')'){
    		return '>' ;
    	}else{
    		return '>';
    	}
    	
    }
    /*
    *从S1栈中弹出两个操作数 a和b 
    *从S2栈中弹出一个操作符  oper 
    * 然后两个操作数和一个操作符进行运算 
    */
    int operate(int a,char oper,int b){
    	if(oper == '+'){
    		return a+b;
    	}else if(oper=='-'){
    		return a-b; 
    	}else if(oper == '*'){
    		return a*b;
    	}else {
    		return a/b;
    	}
    }
    main(){
    	char arr[] = {'2','+','4','*','5','*','(','2','+','3',')','#'};
    	puts(arr);
    	SqStackInt S1;  //用来存储操作数的栈 int 类型 
    	SqStackChar S2;
    	//初始化两个栈 
    	InitStack_Int(S1); 
    	InitStack_Char(S2);
    	//操作符栈 进栈一个 # 号作为结束标志 
    	Push_Char(S2,'#');
    	int i = 0;  //用于循环遍历 中缀表达式 arr 数组 
    	while(arr[i]!='#'||GetTop_Char(S2)!='#'){
    	
    		if(!isOper(arr[i])){  //如果不是操作符 
    			int e = arr[i] - '0';
    			Push_Int(S1,e);  //进操作数 S1 栈 
    			i++;
    		}else{ 				//是操作符等待进入 S2 栈 
    				char e = arr[i]; 
    				//比较操作符 S2栈  当前栈顶操作符的和当前扫描到的操作符优先级大小 
    				switch (getStackTopPriority(GetTop_Char(S2),e)){  
    					
    				case '<':{  //栈顶操作符优先级小--> 
    					Push_Char(S2,e); 
    					i++;
    					break;
    				}
    					
    				case '=' :{
    					char x;
    					Pop_Char(S2,x);
    					i++;
    					break;
    				}
    				
    				case '>' :{
    					int a,b;char oper;
    					Pop_Int(S1,b);Pop_Int(S1,a);
    					Pop_Char(S2,oper);
    					int e = operate(a,oper,b);
    					Push_Int(S1,e);
    					
    					break;
    				}
    			} 			
    		} 
    	}
    
    	
    	printf("运算结果为:%d",GetTop_Int(S1));
    	
    
    }
    

    运行结果

    在这里插入图片描述

    展开全文
  • 通过把“中缀转后缀”和“后缀求值”两个算法功能...实现对中缀表达式直接求值,新算法还是从左到右扫描中缀表达式, 但同时使用两个栈,一个暂存操作符,一个暂存操作数,来进行求值。 (支持 + - * / ^ 五种运算)

    中缀表达式求值

    通过把“中缀转后缀”和“后缀求值”两个算法功能集成在一起(非简单的顺序调用),

    实现对中缀表达式直接求值,新算法还是从左到右扫描中缀表达式,

    但同时使用两个栈,一个暂存操作符,一个暂存操作数,来进行求值。

    (支持 + - * / ^ 五种运算)
    输入格式:

    共1行,为1个字符串,即一个中缀表达式,

    其中每个数字或符号间由一个空格隔开。

    输出格式:

    共1行,为一个整数,即求值的结果。

    输入样例:

    ( 2 + 3 ) * 6 + 4 / 2

    输出样例:

    32

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <malloc.h>
    #include <math.h>
    #define maximum 100000
    
    typedef struct
    {
        float data[maximum];
        int top;
    }number;
    
    typedef struct
    {
        char data[maximum];
        int top;
    }sign;
    
    void InitNumber(number *stack);
    void GetTopNumber(number stack, float *e);
    void PushNumber(number *stack, float e);
    void PopNumber(number *stack, float *e);
    
    void InitSign(sign *stack);
    void GetTopSign(sign stack, char *e);
    void PushSign(sign *stack, char e);
    void PopSign(sign *stack, char *e);
    
    void Calculate(number *stack, char e);
    
    number Num;
    sign sig;
    char expression[maximum];
    	
    int main()
    {
        gets(expression);
        int length;
        length=strlen(expression);
        int i;
        float en,n;
        char es;
        InitNumber(&Num);
        InitSign(&sig);
        for (i=0;i<length;i++)
        {
            if(expression[i]>='0'&&expression[i]<='9')
            {
                n=expression[i]-'0';
                while (expression[i+1]!='\0')
                {
                    if (expression[i+1]>='0'&&expression[i+1]<='9')
                    {
                        n=n*10+expression[i+1]-'0';
                        ++i;
                    }
                    else break;
                }
                PushNumber(&Num,n);
            }
            else if (expression[i]=='+'||expression[i]=='-'||expression[i]=='*'||expression[i]=='/'||expression[i]=='^'||expression[i]=='('||expression[i]==')')
            {
                switch (expression[i])
                {
                case '+':
                    if(sig.data[sig.top-1]!='+'&&sig.data[sig.top-1]!='-'&&sig.data[sig.top-1]!='*'&&sig.data[sig.top-1]!='/'&&sig.data[sig.top-1]!='^')
                        PushSign(&sig,'+');
                    else
                    {
                        while (sig.top>0&&sig.data[sig.top-1]!='(')
                        {
                            PopSign(&sig,&es);
                            Calculate(&Num,es);
                        }
                        PushSign(&sig,'+');
                    }
                    break;
                case '-':
                    if(sig.data[sig.top-1]!='+'&&sig.data[sig.top-1]!='-'&&sig.data[sig.top-1]!='*'&&sig.data[sig.top-1]!='/'&&sig.data[sig.top-1]!='^')
                        PushSign(&sig,'-');
                    else
                    {
                        while (sig.top>0&&sig.data[sig.top-1]!='(')
                        {
                            PopSign(&sig,&es);
                            Calculate(&Num,es);
                        }
                        PushSign(&sig,'-');
                    }
                    break;
                case '*':
                    if(sig.data[sig.top-1]!='*'&&sig.data[sig.top-1]!='/'&&sig.data[sig.top-1]!='^')
                        PushSign(&sig,'*');
                    else
                    {
                        while (sig.top>0&&sig.data[sig.top-1]!='(')
                        {
                            PopSign(&sig,&es);
                            Calculate(&Num,es);
                        }
                        PushSign(&sig,'*');
                    }
                    break;
                case '/':
                    if(sig.data[sig.top-1]!='*'&&sig.data[sig.top-1]!='/'&&sig.data[sig.top-1]!='^')
                        PushSign(&sig,'/');
                    else
                    {
                        while (sig.top>0&&sig.data[sig.top-1]!='(')
                        {
                            PopSign(&sig,&es);
                            Calculate(&Num,es);
                        }
                        PushSign(&sig,'/');
                    }
                    break;
                case '^':
                    if(sig.data[sig.top-1]!='^')
                        PushSign(&sig,'^');
                    else
                    {
                        while (sig.top>0&&sig.data[sig.top-1]!='(')
                        {
                            PopSign(&sig,&es);
                            Calculate(&Num,es);
                        }
                        PushSign(&sig,'^');
                    }
                case '(':
                    PushSign(&sig,'(');
                    break;
                case ')':
                    while (sig.data[sig.top-1]!='(')
                    {
                        PopSign(&sig,&es);
                        Calculate(&Num,es);
                    }
                    PopSign(&sig,&es);
                }
            }
        }
        while (sig.top>0)
        {
            PopSign(&sig,&es);
            Calculate(&Num,es);
        }
        GetTopNumber(Num,&en);
        printf("%.0f\n",en);
        return 0;
    }
    
    void InitNumber(number *stack)
    {
        stack->top=0;
    }
    
    void GetTopNumber(number stack, float *e)
    {
        if(stack.top==0) return;
        else *e=stack.data[stack.top-1];
    }
    
    void PushNumber(number *stack, float e)
    {
        if(stack->top>=maximum) return;
        else stack->data[stack->top++]=e;
    }
    
    void PopNumber(number *stack, float *e)
    {
        if(stack->top==0) return;
        else *e=stack->data[--stack->top];
    }
    
    void InitSign(sign *stack)
    {
        stack->top=0;
    }
    
    void GetTopSign(sign stack, char *e)
    {
        if(stack.top==0) return;
        else *e=stack.data[stack.top-1];
    }
    
    void PushSign(sign *stack, char e)
    {
        if(stack->top>=maximum) return;
        else 
    	{
    		stack->data[stack->top]=e;
    		stack->top++;
    	}
    }
    
    void PopSign(sign *stack, char *e)
    {
        if(stack->top==0) return;
        else *e=stack->data[--stack->top];
    }
    
    void Calculate(number *stack, char e)
    {
        float num1,num2,result;
        PopNumber(stack, &num2);
        PopNumber(stack, &num1);
        switch (e)
        {
            case '+':
                result=num1+num2;
                PushNumber(stack,result);
                break;
            case '-':
                result=num1-num2;
                PushNumber(stack,result);
                break;
            case '*':
                result=num1*num2;
                PushNumber(stack,result);
                break;
            case '/':
                if (num2==0) printf("表达式错误!");
                else
                {
                    result=num1/num2;
                    PushNumber(stack,result);
                    break;
                }
            case '^':
                result=pow(num1,num2);
                PushNumber(stack,result);
                break;
        }
    }
    
    展开全文
  • 从键盘输入中缀表达式,建立操作数与运算符堆栈,计算并输出表达式的求值结果。 基本要求:实现 +, -, *, /四个二元运算符以及(); 操作数范围为0至9。 提高要求:实现+, -两个一元运算符(即正、负号); 操作...
  • C语言一道练习如何建立栈和运用栈来进行...里面涉及加减乘除括号的优先级考虑和入栈出栈的规则来实现计算中缀表达式。作为数据结构中比较重要的一个结构——栈,我们可以通过这道题更加好的理解栈的用途并熟悉栈的运用
  • 中缀表达式求值

    2018-12-20 13:57:43
    完美的中缀表达式求值代码,适合学习数据结构的人参考
  • c语言实现中缀表达式转后缀表达式并求得计算结果,用顺序栈结构。 当输入者输入错误信息的时候需要报错,并说明错误的种类。
  • 有关中缀表达式求值,扫一遍,有需要的可以看看,可以运行成功的
  • 输入常规表达式后,自动转换成中缀表达式,并计算结果。C语言实现,原创代码,欢迎下载。
  • 设计思路:为了设计一个完整运算器,可以采用将中缀表达式转化为后缀表达式进行求解。具体思路: 第一步:先初始化两个栈,分别盛放操作数和操作符; 第二步:将输入的字符串去掉空格,从字符串开头开始遍历; 第三...
  • 一、先将中缀表达式转为后缀表达式 规则: 遇到数字:直接输出 遇到左括号:直接入栈 遇到右括号:输出栈顶元素,直至遇到左括号或者栈空;右括号不入栈 遇到运算符:分两种情况:i)当前运算符优先级大于栈顶...

    一、先将中缀表达式转为后缀表达式

    规则:

    1. 遇到数字:直接输出
    2. 遇到左括号:直接入栈
    3. 遇到右括号:输出栈顶元素,直至遇到左括号或者栈空;右括号不入栈
    4. 遇到运算符:分两种情况:i)当前运算符优先级大于栈顶优先级,直接入栈;ii)当前运算符优先级小于栈顶,则先输出栈顶元素,直至栈空或遇到左括号,最后入栈。

    举例:有中缀表达式:A+B*(C-D)-E/F,怎么转后缀表达式呢

    步骤1:遇到A,输出A                             栈:空

    步骤2:遇到+,入栈                                栈:+

    步骤3:遇到B,输出B     累计输出:AB                                        栈:+

    步骤4:遇到*,'*'的优先级大于'>',入栈   累计输出:AB              栈:*+

    步骤5:遇到(,入栈   累计输出:AB                                           栈:(*+

    步骤6:遇到C,输出C  累计输出:ABC                         

    展开全文
  • c语言中缀表达式计算

    2015-01-03 18:15:23
    利用c语言写的中缀表达式,主要数据结构是栈。
  • C语言中缀表达式求值(综合)

    万次阅读 多人点赞 2019-04-13 10:59:06
    基本思路:先把输入的中缀表达式→后缀表达式→进行计算得出结果 栈:”先进先出,先进后出“! 中缀转后缀(先把转换后的后缀表达式存入字符数组):从左至右依次读取,遇到运算数存入字符数组,遇到运算符压入栈...
  • 表达式是数据运算的基本形式。人们的书写习惯是中缀式,如:11+22*(7-4)/3.中缀式的计算按运算符的优先级及括号优先的原则,相同级别从左到右进行计算。表达式还有后缀表达式(如:11 22 7 4 - * 3 / +)和前缀...
  • 求表达式是栈的经典操作,我只简单地实现了正数的四则运算,包括括号运算,也可计算小数,没有检查表达式是否输入正确,以后再改进。实现过程中借鉴了其它博主的一些算法,如有侵权,我会立即删除。 #include &...
  • //用于指向字符串(中缀表达式)的指针 //声明两个栈,一个float型,一个char型 //表达式中操作数存在一个栈内,运算符存入一个栈内 //top1,top2用于指向两个栈的栈顶 float s1[maxSize];int top1=-1; char s2[maxSize...
  • 该程序实现了运算表达式转换为中缀表达式中缀表达式转换为后缀表达式及后缀表达式求值。该程序已实现加减乘除括号运算符及余、幂指数的求解
  • 中缀表达式,转换为后缀表达式和前缀表达式,再分别计算转换后的表达式,比较两个计算结果,判断转换正确性和计算正确性。 ·编程 (1)读入中缀表达式,表达式的数据可以是实型、整型; (2)转换为后缀表达式...
  • 表达式求值(C语言栈实现).已测试,没有任何错误和警告
  • 基于栈结构的中缀表达式求值c语言详细的叙述了如何栈结构的中缀表达式
  • 头文件(tou.h): typedef char ElemType;... //存储表达式 printf("请输入表达式:"); scanf("%s", str); double result = Calculate(str); printf("结果是:%lf\n\n", result); } return 0; } 测试结果:
  • 从键盘输入中缀表达式,建立操作数与运算符堆栈,计算并输出表达式的求值结果。 基本要求:实现 +, -, *, /四个二元运算符以及(); 操作数范围为0至9。 提高要求:实现+, -, *, /四个二元运算符以及(); ...
  • 中缀表达式的计算 c语言链表实现

    多人点赞 2020-06-20 17:34:34
    中缀表达式的计算 c语言链表实现 1题目 输入一个中缀算术表达式,计算其结果。对输入的表达式,做如下假设: (1)只考虑+、-、*、/这四种运算符,中缀表达式中只有一种括号(); (2)输入的中缀表达式中数字只有...
  • 本文实例为大家分享了C语言实现中缀表达式转后缀表达式的具体代码,供大家参考,具体内容如下 中缀表达式转换为后缀表达式(思路) 1.创建栈 2.从左向右顺序获取中缀表达式 a.数字直接输出 b.运算符 情况一:遇到左...
  • 此程序先将输入的中缀表达式转化为后缀表达式,然后计算后缀表达式的,此为栈的应用。
  • 一、后缀表达式求值 后缀表达式也叫逆波兰表达式,其求值过程可以用到栈来辅助存储。假定待求值的后缀表达式为:6523+ 8 * + 3+*,则其求值过程如下: 1)遍历表达式,遇到的数字首先放入栈中,此时栈如下所示: ...
  • 模拟计算器的功能,对输入的一串表达式进行求值。算法定义了运算符的优先级,最后利用栈的方法来实现。
  • //用于指向字符串(中缀表达式)的指针 //声明两个栈,一个float型,一个char型 //表达式中操作数存在一个栈内,运算符存入一个栈内 //top1,top2用于指向两个栈的栈顶 float s1[maxSize];int top1=-1; char ...

空空如也

空空如也

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

中缀表达式求值c语言

c语言 订阅