精华内容
下载资源
问答
  • c语言后缀表达式转换
    2021-05-20 08:08:19

    逆波兰表达式(Reverse Polish Notation)又叫后缀表达式。它是一种非常的表达式,可以将复杂的表达式转换成可以依靠简单的操作得到结果的表达。下面这段C语言即是用于实现将中缀表达式转换成后缀表达式,并计算出结果。相比于网上现有的程序此程序的最大优点在于:1、支持浮点运算;2、支持以符号和单词代表数值;3、支持参与运算的是多位数;

    中缀转换后缀的规则:

    1、依次读取中缀表达式,如果遇到操作数(即数字或代表数字的字母组合),直接将其输出为后缀表达式的一部分;

    2、如果读取到操作符,则将其放入到一个栈中,遇到左括号时我们也将其放入栈中;

    3、上述操作符入栈前先需比较当前入栈的操作符与栈内已有操作符的优先级。如果栈内已有操作符的优级高于 当前入栈的操作符时,则先依次弹出栈内操作符,并将弹出的内容输出为后缀表达式的一部分,直至栈内操作符的优级低于当前需要入栈的操作符;

    4、如果读取一个右括号,则将之前入栈的元素弹出,将弹出的操作符作为后缀表达式的一部分输出,直到遇到左括号为止;

    5、上述弹栈时,如果遇到左括号,则只弹出,弹出的内容不作为后缀表达式的一部分;

    6、中缀表达式读取完毕后,依次弹出栈内操作符,并将其作为后缀表达式的一部分输出;

    /******************

    * Author: Wayne Wang

    * Modified: Aug 22 2018

    *

    *

    */

    #include#include#include#include

    #define MAX_LEN   256

    #define ELEMENT_TYPE_VALUE   0

    #define ELEMENT_TYPE_OP  1

    #define STACK_END_FLAG  '#'

    typedef union rpn_element{

    float               value;

    char                op;

    }rpn_element_u;

    typedef struct {

    rpn_element_u         value;

    int                   type;

    }rpn_element_t;

    typedef struct __rpnList__{

    rpn_element_u              value;

    int                        type;

    struct __rpnList__         *next;

    }rpn_element_list_t;

    typedef struct {

    char                *name;

    float               value;

    }rpn_var_t;

    typedef struct {

    char               *data;

    int                 len;

    }rpn_str_t;

    typedef struct __stack__{

    rpn_element_u              value;

    int                        type;

    struct __stack__           *next;

    }rpn_stack_t;

    rpn_var_t vars[] = {{"one",1.2},{"two",2.3},{"three",3.4},{"four",4.5},{"five",5.6}};

    void rpn_init(rpn_stack_t **s);

    void rpn_free_list(rpn_element_list_t *node);

    void rpn_push(rpn_stack_t **s,rpn_element_t *e);

    void rpn_pop(rpn_stack_t **s, rpn_element_t **e);

    int  rpn_getoplevel(char op);

    void rpn_print_list(rpn_element_list_t *node);

    int build_rpn_exprss(char *express,rpn_element_list_t **list);

    int rpn_cac_express(rpn_element_list_t *node,float *ret);

    int main(void){

    rpn_element_list_t      *list;

    float                   value;

    char *express = "(one+five) + ((four-two)+ 2)*three=\0";

    if(build_rpn_exprss(express,&list) == 0){

    rpn_print_list(list);

    }

    else{

    printf("build  RPN error");

    }

    rpn_cac_express(list,&value);

    printf("Answer: %f",value);

    return 0;

    }

    更多相关内容
  • 主要为大家详细介绍了C语言实现中缀表达式转换后缀表达式,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 中缀表达式转换后缀表达式 最近在复习考研,C语言+数据结构,在此记录实验代码,仅供参考 #include <stdio.h> #include <string.h> int yxj(char p,char q) //判断运算符优先级 { if((p == '+' || p...

    中缀表达式转换为后缀表达式

    最近在复习考研,C语言+数据结构,在此记录实验代码,仅供参考

    #include <stdio.h>
    #include <string.h>
    
    int yxj(char p,char q)             //判断运算符优先级
    {
        if((p == '+' || p == '-') && (q == '*' || q == '/'))
        {
            return 0;
        }
        else {
            if(p == q)
            {
                return 0;
            }
            else {
                return 1;
            }
        }
    }
    
    int main()
    {
        char str[15] = "(a+b*c)/d-e",stack[100];
        int top = -1;
        char *p = str;
    
        while(*p != '\0')
        {
            if(*p >= 'a' && *p <= 'z')
            {
                printf("%c",*p);
            }
            else {
                if(*p == '(' || *p == '[' || *p == '{')
                {
                    stack[++top] = *p;
                }
                else {
                    if(*p == ')')
                    {
                        while(stack[top] != '(' && stack[top] != '[' && stack[top] != '{')
                        {
                            printf("%c",stack[top--]);
                            stack[top + 1] = ' ';
                        }
                        if(stack[top] != '(')
                        {
                            printf("括号不匹配!");
                            return 0;
                        }
                        else {
                            top--;
                            stack[top + 1] = ' ';
                        }
                    }
    
                    if(yxj(*p,stack[top]))
                    {
                        stack[++top] = *p;
                    }
                    else {
                         printf("%c",stack[top--]);
                         stack[top] = *p;
                    }
                }
            }
            p++;
        }
    
        while(stack[top] == '+' || stack[top] == '-' || stack[top] == '*' || stack[top] == '/')
        {
            printf("%c",stack[top--]);
        }
    
        if(top != -1)
        {
            printf("括号不匹配!");
        }
    
        return 0;
    }
    
    
    展开全文
  • C语言中缀表达式转成后缀表达式,并计算它的值

    千次阅读 多人点赞 2021-04-07 11:11:35
    C语言中,将中缀表达式转成后缀表达式,并计算它的结果,具体的思路如下: 1、定义两个栈,numStack用于存放运算对象,最后存放运算结果的,fuStack用于存放运算符号的 2、从左到右遍历字符串 3、如果当前的字符是...

    在C语言中,将中缀表达式转成后缀表达式,并计算它的结果,具体的思路如下:
    1、定义两个栈,numStack用于存放运算对象,最后存放运算结果的,fuStack用于存放运算符号的
    2、从左到右遍历字符串
    3、如果当前的字符是一个数字,那么先不要着急将其转成数字,然后压入到numStack中,因为考虑到多位数字的情况,所以需要从当前下标开始遍历,一直遍历到第一个运算符出现,那么这时候才可以将运算符前面的数字转成字符串。然后调用atoi,将字符串转成一个数字。这时候,将这个数字输出,同时将其压入到numStack中。
    4、如果当前的字符是一个字符,那么这时候需要分几种情况进行讨论:

    (1)如果栈为空或者当前符号是一个左括号,直接将当前符号压入到fuStack中
    (2)否则,如果栈顶符号是一个左括号,那么直接将当前符号压入到fuStack中
    (3)否则,如果当前符号是一个右括号,那么需要将从fuStack中跳出字符,并输出这
    个字符,然后从numStack中跳出两个数字,进行相应的运算,将运算结果压numStack
    中,重复(3)操作,直到fuStack的栈顶符号是一个左括号,那么这时候,将左括号从
    fuStack中跳出,注意不需要输出
    (4)否则,当前符号是一个普通运算符的时候,那么这时候,需要比较当前符号和栈 
      顶符号的优先级,如果当前的符号优先级大于栈顶符号的优先级,那么直接将当前符
    号压入到fuStack中,否则,当前符号的优先级小于等于栈顶符号的优先级,那么需要将
    栈顶符号跳出,并输出,然后从numStack中跳出两个数字,进行相应的运算,然后将
    运算结果压入到numStack中,重复这个步骤,直到当前符号的优先级大于栈顶符号的优
    先级才可以将当前符号压入到fuStack中
    

    5、遍历完之后,操作还没有结束,还需要判断fuStack是否为空,如果不为空,那么就从fuStack中跳出栈顶元素,并将其输出,同时,将从numStack中跳出两个数字,进行相应的运算,将运算结果压入到numStack中,重复5的操作,直到fuStack为空。
    6、这时候,上述操作都完成之后,这时候numStack的栈顶元素就是整个表达式的运算结果,将其输出即可。

    题目的链接:
    https://pintia.cn/problem-sets/434/problems/5893
    对应的代码:

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    #define MAX_SIZE 21
    #define ERROR 0
    #define OK 1
    typedef struct Num{
        int msg[MAX_SIZE];
        int top;
    }numStack;
    void initStack(numStack *num){
        num->top = 0;
    }
    
    int push(numStack *num,int e){
        if(num->top == MAX_SIZE)
            return ERROR;
        num->msg[num->top++] = e;
        return OK;
    }
    int pop(numStack *num,int *e){
        if(num->top == 0)
            return ERROR;
        *e = num->msg[--num->top];
        return OK;
    }
    int getTop(numStack *num,int *e){
        if(num->top == 0)
            return ERROR;
        *e = num->msg[num->top - 1];
        return OK;
    }
    int isEmpty(numStack *num){
        return num->top == 0;
    }
    typedef struct FU{
        char msg[MAX_SIZE];
        int top;
    }fuStack;
    void initFuStack(fuStack *fu){
        fu->top = 0;
    }
    
    int pushFu(fuStack *fu,char e){
        if(fu->top == MAX_SIZE)
            return ERROR;
        fu->msg[fu->top++] = e;
        return OK;
    }
    int popFu(fuStack *fu,char *e){
        if(fu->top == 0)
            return ERROR;
        *e = fu->msg[--fu->top];
        return OK;
    }
    int getFuTop(fuStack *fu,char *e){
        if(fu->top == 0)
            return ERROR;
        *e = fu->msg[fu->top - 1];
        return OK;
    }
    int isFuEmpty(fuStack *fu){
        return fu->top == 0;
    }
    int level(char ch){
        if(ch == '+' || ch == '-')
            return 1;
        else if(ch == '*' || ch == '/')
            return 2;
        else
            return 0;
    }
    int isNum(char ch){
        if(ch >= '0' && ch <= '9')
            return 1;
        return 0;
    }
    int yunsuan(char ch,numStack *num,int *result){
       int a,b;
       pop(num,&a);
       pop(num,&b);//将从栈中跳出两个元素,并将他们的值赋给a、b
       /*
       值得注意的是,必须是b - a,b / a,因为栈式先进后出的结构
       */
       switch(ch){
          case '+':
              *result = b + a;
               break;
          case '-':
              *result = b - a;
               break;
          case '*':
              *result = b * a;
               break;
          case '/':
              if(a == 0){
                return ERROR;//如果不符合运算法则,那么返回ERROR
              }
              *result = b / a;
              break;
       }
       return OK;
    }
    void getPreExpression(numStack *num,fuStack *fu,char *msg){
        int i,result,j,k = 0,a,b,count = 0;//count表示数字的个数
        char ch,tmp,arr[MAX_SIZE];//arr数组用于多位数字的拼接,ch表示当前的字符,tmp表示fuStack的栈顶元素
        for(i = 0; msg[i] != '\0'; i++){
            ch = msg[i];
            if(isNum(ch)){
                j = i;
                k = 0;//重置k
                //拼接数字
                while(isNum(msg[j])){
                    arr[k++] = msg[j];
                    j++;
                }
                arr[k] = '\0';//这一步十分重要
                /*
                这一步将i回到最后一个数字,因为在for循环中还会进行i++的操作,
                如果没有这一步,那么就会导致读取到的字符不全
                */
                i = j - 1;
                a = atoi(arr);//调用atoi方法,从而将这个多位数字的字符串转成整形数字
                count++;
                if(count == 1)
                    printf("%d",a);//如果是第一个数字,那么前面不需要输出一个空格,否则要在前面输出空格
                else
                    printf(" %d",a);
                push(num,a);//将数字压入栈中
            }else{
                //如果是运算符,那么需要分情况讨论
                if(isFuEmpty(fu) || ch == '('){
                    //如果栈为空或者当前字符为左括号,直接将当前符号压入栈中
                    pushFu(fu,ch);
                }else{
                    /*
                    如果栈不为空,那么需要讨论几种情况:
                    ①栈顶是左括号,直接将当前字符压入栈中
                    ②否则,如果当前符号是一个右括号,那么将从栈中跳出栈顶元
                    素,并将其输出,同时将从numStack栈中跳出两个数字,进行相应
                    的运算,之后将运算结果压入到numStack中,重复③的操作,直到
                    栈顶符号式左括号,之后将左括号从fuStack中跳出
                    ③否则,当前字符是普通字符,那么需要判断优先级。如果当前符
                    号的优先级大于栈顶元素的优先级,那么直接入fu栈,否则从符栈
                    中不断跳出栈顶元素,并将其输出,同时将从numStack中跳出两
                    个数字,进行相应的运算,然后将运算结果压入到numStack中,
                    重复此操作,直到当前符号的优先级大于栈顶符号的优先级,才将
                    当前符号压入到fuStack中
                    */
                    getFuTop(fu,&tmp);
                    if(tmp == '('){
                        //如果栈顶元素是一个左括号,那么直接入栈
                        pushFu(fu,ch);
                    }else{
                      //当前的字符不是一个左括号,那么需要判断当前的符号是否为一个右括号
                      if(ch == ')'){
                        getFuTop(fu,&tmp);
                        while(tmp != '('){
                           popFu(fu,&tmp);
                           printf(" %c",tmp);
                           if(!yunsuan(tmp,num,&result)){
                              printf("被除数不可以为0,运算错误!!!\n");
                              return;
                           }
                           push(num,result);//如果运算符合运算法则,那么将运算结果压入到栈中
                           getFuTop(fu,&tmp);
                        }
                        popFu(fu,&tmp);
                      }else{
                         //当前的符号是一个普通符号,那么需要比较优先级
                         label:
                             if(isFuEmpty(fu) || level(ch) > level(tmp)){
                                    //当前符号的优先级大于栈顶符号的优先级,那么直接入栈
                                pushFu(fu,ch);
                             }else{
                                 //当前的符号的优先级小于等于栈顶符号的优先级,那么将栈顶元素从fu栈中跳出并输出
                                popFu(fu,&tmp);
                                printf(" %c",tmp); 
                                if(!yunsuan(tmp,num,&result)){
                                    printf("被除数不可以为0,运算错误!!!\n");
                                    return;
                                }
                                push(num,result);//如果运算符合运算法则,那么将运算结果压入到栈中
                                getFuTop(fu,&tmp);
                                goto label;//利用goto语句,从而实现当前的符号的优先级小于栈顶符号的优先级,然后将其压入
                             }
                      }
                    }
                }
    
            }
        }
        //将num压入到fu栈中
        while(!isFuEmpty(fu)){
             popFu(fu,&tmp);
             printf(" %c",tmp);
             if(!yunsuan(tmp,num,&result)){
             //将进行相应的运算,然后将对应的运算结果赋值给result
                printf("被除数不可以为0,运算错误!!!\n");
                return;
             }
             push(num,result);//如果运算符合运算法则,那么将运算结果压入到栈中
        }
        printf("\n");
        pop(num,&a);//将num中的栈顶元素的值赋给a,并将其删除
        printf("%s的运算结果为%d\n",msg,a);
    }
    int main(){
        numStack *num = (numStack *)malloc(sizeof(numStack));
        fuStack *fu= (fuStack *)malloc(sizeof(fuStack));
        char msg[MAX_SIZE];
        initStack(num);//将栈进行初始化
        initFuStack(fu);
        scanf("%s",msg);//输入字符串
        getPreExpression(num,fu,msg);//将后缀表达式输出,同时将它的运算结果输出
        return 0;
    }
    
    
    

    对应的结果:
    在这里插入图片描述
    在这里插入图片描述

    不足之处:
    1、如果数字是一个小数的情况,则时候就会明显发生错误。
    如下图,输入这样的例子,就直接程序结束了.
    在这里插入图片描述
    2、如果一开始输入的就是负数之类的数的话,那么这时候也是不可以进行运算的。比如-5+6等诸如这样的例子,不可以进行运算。

    如果有什么好的建议,请大家指正哈!

    展开全文
  • C语言 实现后缀表达式求值(理解不同方式)

    写在前面

            在数据结构中,栈是非常重要的储存结构,比如栈应用于求表达式,将输入的等式进行转换,如前缀表达式、后缀表达式等然后进行求值并返回结果。

            但是本文并为使用栈实现后缀表达式求值,而是通过一般函数方法,需要先计算一下,将原式转换成后缀表达式后再输入求值哦,试试看。

    代码实现

    #include <stdio.h>
    #include <stdlib.h>
    
    void evalPf(char*);
    double cal(double, char, double);
    
    int main(){
    	char input[80];
    	printf("请输入后缀式:\n\n"); 
    	printf("例如:\n算式 (1+2)*(3+4) 的后缀式为:12+34+*  \n\n"); 
    	scanf("%s", input); 
    	evalPf(input);
    	return 0;
    }
    
    void evalPf(char* postfix){ 
    	double stack[80] = {0.0}; 
    	char temp[2];
    	char token;
    	int top = 0, i = 0;
    	temp[1] = '\0';
    	while(1){
    		token = postfix[i];
    		switch(token){
    			case '\0':
    				printf("原式 = %f\n", stack[top]); 
    				return;
    			case '+': 
    			case '-': 
    			case '*': 
    			case '/': 
    				stack[top-1] =cal(stack[top], token, stack[top-1]);
    				top--; 
    				break;
    			default:
    				if(top < sizeof(stack) / sizeof(float)){ 
    					temp[0] = postfix[i];
    					top++;
    					stack[top] = atof(temp);
    				}
    				break;
    		}
    		i++;
    	}
    }
    	
    
    double cal(double p1, char op, double p2){ 
    	switch(op){
    		case '+':
    			return p1 + p2;
    		case '-':
    			return p1 - p2; 
    		case '*':
    			return p1 * p2;
    		case '/':
    			return p1 / p2;
    	}
    }

    运行结果

     

    展开全文
  • 本文实例为大家分享了C语言实现对后缀表达式(逆波兰表达式)的求解代码,供大家参考,具体内容如下 逆波兰表达式: 逆波兰表达式又叫后缀表达式。它是由相应的语法树的后序遍历的结果得到的。 例:5 – 8*(6 + 7) +...
  • 中缀表达式到后缀表达式转换是堆栈应用的典型例子。通过只允许操作‘+’,‘-’,‘*’,‘/’,并坚持优先级法则,即可实现该操作。 1. 规则 假设读入的中缀表达式是正确的。 当读到操作数时,立即输出。 操作符...
  • C语言】中缀表达式转后缀表达式

    千次阅读 2021-03-14 15:31:53
    三、中缀表达式转后缀表达式 例如: 中缀表达式:123+5*21-7/(4-3) 后缀表达式:123 5 21 * + 7 4 3 / - 转换规则: 如果是数字,直接输出; 如果是左括号,直接入栈; 如果是右括号,一直出栈,直到遇到第一个左...
  •  最后得到的结果就是 一个反向的 后缀表达式 */ #include #include #include typedef double DateType; typedef char SymbolType; typedef struct RpnNode{ SymbolType symol; DateType data; ...
  • 后缀表达式什么是后缀表达式后缀表达式计算功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...
  • 一、后缀表达式求值 后缀表达式也叫逆波兰表达式,其求值过程可以用到栈来辅助存储。假定待求值的后缀表达式为:6523+ 8 * + 3+*,则其求值过程如下: 1)遍历表达式,遇到的数字首先放入栈中,此时栈如下所示: ...
  • 中缀表达式转换后缀表达式C语言代码+详解)

    万次阅读 多人点赞 2019-01-22 14:53:22
    中缀表达式转换后缀表达式 1.创建栈 2.从左向右顺序获取中缀表达式 a.数字直接输出 b.运算符 情况一:遇到左括号直接入栈,遇到右括号将栈中左括号之后入栈的运算符全部弹栈输出,同时左括号出栈但是不输出。...
  • 在开始之前,我们首先要了解以下运算符在C语言中的优先级: ...这样的一个表达式就是中缀表达式(也称中序表达式),但由于这种表达式不容易被计算机解析,所以我们需要将其转化为后缀表达式! 后...
  • 请设计程序将中缀表达式转换后缀表达式。 输入格式: 输入在一行中给出不含空格的中缀表达式,可包含+、-、*、\以及左右括号(),表达式不超过20个字符。 输出格式: 在一行中输出转换后的后缀表达式,要求不同...
  • C语言用栈实现 中缀表达式转后缀表达式 数据结构
  • 数据结构作业 中 中缀表达式转换后缀表达式 主要是对栈的应用 第一次上传 呵呵 没经验
  • 要求设计类(或类模板)来描述算术表达式及其操作,包含必要的构造函数和析构函数,以及其他能够完成如下功能的成员函数:输入算术表达式(中缀表示)中缀表达式转换后缀表达式输出表达式对后缀表达式求值
  • 将由数字和四则运算符组成的后缀表达式变换为中缀表达式。 输入的后缀表达式包含的运算符不超过15个。 要求转换后的中缀表达式中不应出现不必要的括号。 例如,整个表达式两端的括号要省略,不影响原计算结果的括号...
  • 输入一个中缀表达式,编程输出其后缀表达式,要求输出的后缀表达式的运算次序与输入的中缀表达式的运算次序相一致。为简单起见,假设输入的中缀表达式由+(加)、-(减)、×(乘)、/(除)四个运算符号以及左右...
  • 在将中缀表达式转换后缀的时候,遵循的原则是: 从左到右依次扫描中缀表达式,如果读到的是操作数,直接存入 exp 栈 如果读到的是运算符,则进行判断 该运算符是 ’ ( ',则直接存入 opt 栈 该运算符是 ’ ) ',...
  • 本文实例为大家分享了C++实现中缀表达式转后缀表达式的具体代码,供大家参考,具体内容如下 题目:现有中缀表达式如:1+(2-3)*4+10/5 请用栈的特性编写一个程序,使得程序输出后缀表达式 分析如下: STEP1: 1+(2-3)...
  • 后缀表达式的值(c语言

    千次阅读 2019-03-24 22:10:23
    我们平时数学上用的算术表达式(中缀表达式)转换后缀表达式后,它主要是字符串形式(如果不会,建议先学习中转后的操作)。 要实现对其的求值,有如下几个步骤: (对整个字符串进行遍历) 将字符串型的数字转换...
  • C语言数据结构之利用栈将中缀表达式转换后缀表达式方法:利用栈的特性来解析中缀表达式,最后输出后缀表达式 具体: 如果是数字则输出 如果是'('入栈 如果是')'将'('到')'的内容输出 如果是'+' '-',如果栈为...
  • 后缀表达式求值c语言算法Here you will get algorithm and program for evolution of postfix expression in C. 在这里,您将获得用于C语言后缀表达式演变的算法和程序。 In postfix or reverse polish notation...
  • 1、栈的基本操作函数 Stack.c #include "Stack.h... if (val) { printf("转换后缀表达式:"); convertExp(str); puts(Exp); printf("表达 式 求 值 为:%s = %d\n",str,calcExp()); return 0; } } } 三、实际运行效果
  • c语言实现中缀表达式向后缀表达式转换 分类:算法+数据结构
  • 一、先将中缀表达式转为后缀表达式 规则: 遇到数字:直接输出 遇到左括号:直接入栈 遇到右括号:输出栈顶元素,直至遇到左括号或者栈空;右括号不入栈 遇到运算符:分两种情况:i)当前运算符优先级大于栈顶...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,649
精华内容 7,059
关键字:

c语言后缀表达式转换