精华内容
下载资源
问答
  • 后缀表达式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语言实现中缀表达式转后缀表达式的具体代码,供大家参考,具体内容如下 中缀表达式转换为后缀表达式(思路) 1.创建栈 2.从左向右顺序获取中缀表达式 a.数字直接输出 b.运算符 情况一:遇到左...
  • 首先中缀表达式转后缀表达式(逆波兰表达式)需要用到一个栈来辅助实现。下面有几条规则(抄的网友的,哈哈哈自己也重新整理了一下) 具体转换方式: 首先的优先级我把它分为( > ÷ > × > - > + 将...

    栈我就是用的上一篇写的那个链栈, 可能有些栈的方法并没有用到

    首先中缀表达式转后缀表达式(逆波兰表达式)需要用到一个栈来辅助实现。下面有几条规则(抄的网友的,哈哈哈自己也重新整理了一下)

    具体转换方式: 首先的优先级我把它分为   ( > ÷ > × > - > +

    1. 将字符串从左到右进行遍历
    2. 运算数,直接输出.
    3. 左括号,直接压入堆栈,(括号是最高优先级,无需比较)(入栈后优先级降到最低,确保其他符号正常入栈)
    4. 右括号,(意味着括号已结束)不断弹出栈顶运算符并输出直到遇到左括号(弹出但不输出)
    5. 运算符, 运算符都要有入栈分三种情况 

                  5.1 如果当前运算符优先级 > 栈顶运算符 直接进栈

                  5.2 如果当前运算符优先级 < 栈顶运算符 出栈 然后再次判断 大于为止,进栈

                  5.3 如果当前运算符优先级 = 栈顶运算符 出栈 然后再次判断 大于为止,进栈

          如果对象处理完毕,则按顺序弹出并输出栈中所有运算符.

    代码

    #include<stdio.h>
    #include<stdlib.h>
    #include<string>
    using namespace std;
    typedef char DataType;
    
    typedef struct Node
    {
    	DataType data;
    	int lengh;
    	struct Node * next;
    }Stack;
    
    void init_stack(Stack *stack); 
    //压栈 
    void stack_push(Stack *stack, DataType data);
    //出栈 
    bool stack_pop(Stack *stack);
    //显示栈顶元素 
    DataType get_top(Stack *stack); 
    //显示栈内的所有元素
    bool show_stack(Stack *stack); 
    int main()
    {
    	Stack stack;
    	init_stack(&stack);
    	char c;
    	char s[100];
    	string s1;
    	gets(s);
    	for(int i = 0; s[i] != '\0'; i++)
    	{
    		if(s[i] >= '0' && s[i] <= '9' || s[i] == '.')
    		{
    			s1 += s[i];
    			if(/*s[i+1] != '\0' &&*/ (s[i + 1] < '0' || s[i + 1] > '9'))
    			{
    				s1 += " "; //把输入进去的数用空格隔开 
    			}
    		}
    		else if(s[i] == '(') //优先级进栈前为5 入栈后为-1 
    		{
    			stack_push(&stack,s[i]);
    		}
    		else if(s[i] == ')') //")"优先级为4 
    		{
    			while(true)
    			{
    				c = get_top(&stack);
    				s1 += c;
    				stack_pop(&stack);
    				if(get_top(&stack) == '(')
    				{
    					stack_pop(&stack);
    					break;
    				}
    			}
    		}
    		else if(s[i] == '+') //"+" 优先级为0 
    		{
    			if(stack.lengh != 0 && ( get_top(&stack) == '/' || get_top(&stack) == '*' || get_top(&stack) == '-' || get_top(&stack) == '+'))
    			{
    				c = get_top(&stack);
    				s1 += c;
    				stack_pop(&stack);
    			}
    			stack_push(&stack,s[i]);
    		}
    		else if(s[i] == '-') //"-" 优先级为1 
    		{
    			if(stack.lengh != 0 &&(get_top(&stack) == '/' || get_top(&stack) == '*' || get_top(&stack) == '-'))
    			{
    				c = get_top(&stack);
    				s1 += c;
    				stack_pop(&stack);
    			}
    			stack_push(&stack,s[i]);
    		}
    		else if(s[i] == '*') //"*" 优先级为2 
    		{
    			if(stack.lengh != 0 && get_top(&stack) == '/' || get_top(&stack) == '*')
    			{
    				c = get_top(&stack);
    				s1 += c;
    				stack_pop(&stack);
    			}
    			stack_push(&stack,s[i]);
    		}
    		else if(s[i] == '/') //"/" 优先级为3 
    		{
    			if(stack.lengh != 0 && get_top(&stack) == '/')
    			{
    				c = get_top(&stack);
    				s1 += c;
    				stack_pop(&stack);
    			}
    			stack_push(&stack,s[i]);
    		}
    		
    	}
    	while(stack.lengh != 0)
    	{
    		c = get_top(&stack);
    		s1 += c;
    		stack_pop(&stack);
    	}
    	printf("%s",s1.c_str());
    	return 0;	
    } 
    
    //初始化栈
    void init_stack(Stack *stack)
    {
    	stack = (Stack *)malloc(sizeof(Stack));
    	stack->next = NULL;
    	stack->lengh = 0;
    }
    //压栈
    void stack_push(Stack *stack, DataType data)
    {
    	Stack *p = (Stack *)malloc(sizeof(Stack));
    	p->data = data;
    	p->next = stack->next;
    	stack->next = p;	
    	stack->lengh ++;
    }
    //出栈 
    bool stack_pop(Stack *stack)
    {
    	Stack *p = stack->next;
    	if(stack->next == NULL)
    	{
    		printf("栈空,不能出栈\n");
    		return false;
    	}
    	stack->next = p->next;
    	free(p);
    	stack->lengh --;
    	return true;
    }
    //显示栈顶元素
    DataType get_top(Stack *stack)
    {
    	if(stack->lengh == 0)
    	{
    		printf("栈空,不能返回元素\n");
    		return false;
    	}
    	else
    		return stack->next->data;
    }
    //显示栈内的所有元素
    bool show_stack(Stack *stack)
    {
    	if(stack->lengh == 0)
    	{
    		printf("栈空\n");
    		return false;
    	}
    	Stack *p = stack;
    	for(int i = 0; i < stack->lengh; i++)
    	{
    		printf("%c",p->next->data);
    		p = p->next;
    	}
    	printf("\n");
    }
    

         

     

    展开全文
  • 本文实例为大家分享了C语言实现对后缀表达式(逆波兰表达式)的求解代码,供大家参考,具体内容如下 逆波兰表达式: 逆波兰表达式又叫后缀表达式。它是由相应的语法树的后序遍历的结果得到的。 例:5 – 8*(6 + 7) +...
  • 原题地址:P1449 后缀表达式-洛谷 题目描述 所谓后缀表达式是指这样的一个表达式:式中不再引用括号,运算符号放在两个运算对象之后,所有计算按运算符号出现的顺序,严格地由左而右新进行(不用考虑运算符的优先级...

    原题地址:P1449 后缀表达式-洛谷

    题目描述

    所谓后缀表达式是指这样的一个表达式:式中不再引用括号,运算符号放在两个运算对象之后,所有计算按运算符号出现的顺序,严格地由左而右新进行(不用考虑运算符的优先级)。

    如:3*(5–2)+7对应的后缀表达式为:3.5.2.-*7.+@。’@’为表达式的结束符号。‘.’为操作数的结束符号。

    输入输出格式

    输入格式:

    输入:后缀表达式

    输出格式:

    输出:表达式的值

    输入输出样例

    输入样例#1:
    3.5.2.-*7.+@
    

    输出样例#1:

    16
    

    说明

    字符串长度,1000内。


    解题思路:

    其实这个后缀表达式计算的规则很简单,就是从左到右遍历表达式的每个数字和符号,遇到是数字的就进栈,遇到是符号,就将处于栈顶两个数字出栈,进行运算,运算结果再进栈,一直到遇见 '@' 就输出栈中的第一个数字(同时也是唯一的一个数字)。

    其中需要注意的也只是一个如何存储一位数的数字,整体来说没什么难度。

    AC代码:

    #include <stdio.h>
    int main(){
    	char ch;
    	int num[1005], cnum = 0;
    	int a = 0;
    	while(scanf("%c", &ch), ch !='@'){
    		if(ch == '+'){
    			num[a - 2] = num[a - 1] + num[a - 2];
    			a--;
    		}
    		else if(ch == '-'){
    			num[a - 2] = num[a - 2] - num[a - 1];
    			a--;
    		}
    		else if(ch == '*'){
    			num[a - 2] = num[a - 2] * num[a - 1];
    			a--;
    		}
    		else if(ch == '/'){
    			num[a - 2] = num[a - 2] / num[a - 1];
    			a--;
    		}
    		else if(ch =='.'){
    			num[a] = cnum;
    			a++;
    			cnum = 0;
    		}
    		else
    			cnum = cnum * 10 + (ch - '0');
    	}
    	printf("%d", num[0]);
    	return 0;
    }
    
    展开全文
  • //1.h #ifndef STACK_H #define STACK_H #include<stdio.h> #include<stdlib.h> typedef struct astack *Stack; typedef struct astack { int top; int maxtop; char* data; }Astack; Stack NewEmpty(int size) { St
  • //1.h #ifndef STACK_H #define STACK_H #include<stdio.h> #include<stdlib.h> typedef struct astack *Stack; typedef struct astack { int top; int maxtop; char* data; }Astack; Stack NewEmpty(int size) { S
  • 后缀表达式什么是后缀表达式后缀表达式计算功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...

    什么是后缀表达式

    后缀表达式,又称逆波兰式,指的是不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则)。

    后缀表达式计算

    后缀表达式计算与前缀表达式类似,只是顺序是从左至右,具体过程如下:
    从左至右扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(次顶元素 op 栈顶元素),并将结果入栈;重复上述过程直到表达式最右端,最后运算得出的值即为表达式的结果

    计算步骤

    例如:后缀表达式为9+(3-1)*2+5/2转为后缀表达式为 9 3 1 - 2 * + 5 / 2 +

    1. 初始化一个空栈。此栈用来对要运算的数字进出使用
    2. 将9 3 1压栈遇到符号- 将栈顶两个元素拿出计算 再存入栈
    3. 遇到数字继续入栈 遇到符号继续将栈顶两个元素拿出计算 再存入栈
    4. 同样的操作步骤直至表达式计算完成

    中缀表达式

    中缀表达式就是四则运算表达式

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

    上面的计算规则就是转换规则
    即从左到右遍历,遇到数字就先写上,遇到任何运算符号 先判断与当前栈内的符号优先级,如果优先级高则直接进行运算,如果栈内的优先级高则先出栈再将当前的运算符压栈 直至栈内运算符运算完毕

    C语言实现版

    #include <stdio.h>
    #include <stdlib.h>
    
    #define STACKSIZE 250   //定义数组最大的容量
    //栈的结构体
    typedef struct _stack {
        char dat;
        struct _stack *next;
    } stack;
    
    int advance(char x) { //判断优先级
        if (x == '+' || x == '-')
            return 0;
        else if (x == '*' || x == '/')
            return 1;
        else if (x == '@' || x == '(' || x == ')')
            return -1;
    }
    
    int main() {
        // s是栈 top是栈顶指针
        stack *s, *top;
        char c;
        int calc[50];
        int i = 0;
        s = (stack *) malloc(sizeof(stack));
        s->dat = '@';   //flag
        s->next = NULL;
        top = s;
        c = getchar();
        while (c != '\n') {
            if (c >= '0' && c <= '9') {
                i++;
                calc[i] = c - '0';
            } else if (c == '(') {
                s = (stack *) malloc(sizeof(stack));
                s->dat = c;
                s->next = top;
                top = s;
            } else if (c == ')') {
                while (top->dat != '(') {
                    s = top;
                    if (top->dat == '+') {
                        calc[i - 1] = calc[i - 1] + calc[i];
                        i--;
                    } else if (top->dat == '-') {
                        calc[i - 1] = calc[i - 1] - calc[i];
                        i--;
                    } else if (top->dat == '*') {
                        calc[i - 1] = calc[i - 1] * calc[i];
                        i--;
                    } else if (top->dat == '/') {
                        calc[i - 1] = calc[i - 1] / calc[i];
                        i--;
                    }
                    top = top->next;
                    free(s);
                }
                s = (stack *) malloc(sizeof(stack));
                top = top->next;
                free(s);
            } else {  // 肯定是+ - * /其中一种情况
                int a = advance(c);
                int b = advance(top->dat);
                if (a > b) { // 判断优先级,大于压栈
                    s = (stack *) malloc(sizeof(stack));
                    s->dat = c;
                    s->next = top;
                    top = s;
                } else { // 栈内优先级高,弹栈一直到可以压栈为止
                    while (a <= b) {
                        s = top;
                        if (top->dat == '+') {
                            calc[i - 1] = calc[i - 1] + calc[i];
                            i--;
                        } else if (top->dat == '-') {
                            calc[i - 1] = calc[i - 1] - calc[i];
                            i--;
                        } else if (top->dat == '*') {
                            calc[i - 1] = calc[i - 1] * calc[i];
                            i--;
                        } else if (top->dat == '/') {
                            calc[i - 1] = calc[i - 1] / calc[i];
                            i--;
                        }
                        top = top->next;
                        free(s);
                        b = advance(top->dat);
                    }
                    s = (stack *) malloc(sizeof(stack));
                    s->dat = c;
                    s->next = top;
                    top = s;
                }
            }
            c = getchar();  // 读取下一个字符
        }
        // 把栈内的元素弹完
        while (top->dat != '@') {
            s = top;
            if (top->dat == '+') {
                calc[i - 1] = calc[i - 1] + calc[i];
                i--;
            } else if (top->dat == '-') {
                calc[i - 1] = calc[i - 1] - calc[i];
                i--;
            } else if (top->dat == '*') {
                calc[i - 1] = calc[i - 1] * calc[i];
                i--;
            } else if (top->dat == '/') {
                calc[i - 1] = calc[i - 1] / calc[i];
                i--;
            }
            top = top->next;
            free(s);
        }
        printf("%d\n", calc[1]);
        return 0;
    }
    
    
    展开全文
  • 表达式的转换中缀表达式转化为后缀表达式 C语言编程
  • C语言计算后缀表达式,从控制台输入,以空格为分割输入,支持多位数和负数运算,支持加、减、乘、除、阶乘操作,支持表达式错误检测异常。 input: 3 1 -2 * 1 10 - 6 + 3 1 - ! Output: -2 -3 2 #include<...
  • printf("输入后缀表达式:"); while(c1!='#') { c1=getchar(); if(!operate(c1)) { push(s,(float) (c1-48)); } else { b=top(s); pop(s); a=top(s); pop(s); result=cal(a,b,c1); push(s,result); } } printf("%f\...
  • 假定运算符集合为{ +、-、*、/、(、)},利用栈将输入的中缀表达式转换成等价的后缀表达式,并输出。 输入格式: 输入一个字符串表示的中缀表达式(以“#”结束),其中每个操作数用一个小写字母表示。 输出格式: 将...
  • 中缀表达式转后缀表达式 void MidToFinal(char *mid,char *final){ //中缀表达式为middle,要转换成后缀表达式传给last //新建一个栈,来存储符号 char e; Stack S; if(OK!=InitStack(&S)){ printf("初始化栈失败!...
  • C语言后缀表达式计算一、设计思想计算算数表达式并求值,采取的共有两种方法:先将算数表达式转化为后缀表达式,然后对后缀表达式进行计算。对算数表达式进行直接的计算。第一种算法这种解决方案又分为两步:1.将...
  • 实现效果 源码 #include<stdio.h> #include<string.h> //创建栈 typedef struct node { char s[1000]; int top; }Stack; //判断符号的函数 int weight(char ch, int flag) ...fla
  • 利用C语言实现中缀表达式转化为后缀表达式!!利用栈。
  • C语言中缀表达式转后缀表达式

    千次阅读 2021-09-22 21:14:20
    逆波兰式(Reverse Polish notation,RPN,或逆波兰记法),也叫后缀表达式(将运算符写在操作数之后)。 将中缀表达式转化为后缀表达式的原因: 原因就在于这个简单是相对人类的思维结构来说的,对计算机而言中序...
  • 中缀表达式转换为后缀表达式(思路) 1.创建栈 2.从左向右顺序获取中缀表达式 a.数字直接输出 b.运算符 情况一:遇到左括号直接入栈,遇到右括号将栈中左括号之后入栈的运算符全部弹栈输出,同时左括号出栈但是不...
  • 中缀表达式转为后缀表达式:1.遇到操作数:直接输出(添加到后缀表达式中)2.栈为空时,遇到运算符,直接入栈3.遇到左括号:将其入栈4.遇到右括号:执行出栈操作,并将出栈的元素输出,直到弹出栈的是左括号,左括号不...
  • #include<stdio.h> #include<stack> using namespace std; stack<int> s; //考虑多位数字 空格分割 int main() { char str[100]={"2 3 * ... if(str[i]=='+'||str[i]=='-'||str[i]=='*'||str[i]=.
  • C语言用栈实现 中缀表达式转后缀表达式 数据结构
  • C语言】中缀表达式转后缀表达式

    千次阅读 2021-03-14 15:31:53
    三、中缀表达式转后缀表达式 例如: 中缀表达式:123+5*21-7/(4-3) 后缀表达式:123 5 21 * + 7 4 3 / - 转换规则: 如果是数字,直接输出; 如果是左括号,直接入栈; 如果是右括号,一直出栈,直到遇到第一个左...
  • 第二行输入一个字符串表示后缀表达式(每个数据或者符号之间用逗号隔开,保证输入的后缀表达式合法,每个数包括中间结果保证不超过long long长整型范围) 输出格式: 输出一个整数,即后缀表达式的值。 样例1">...
  • } //表达式运算符优先级低则执行出栈操作,弹出的栈顶元素成为后缀表达式的一部分 //当遇到“)”,则执行出栈操作直到“(”,但括号不计入后缀表达式中 while (!IsEmpty(Stack) && JudgeLevel(0, a[i]) (1, Stack...
  • 在开始之前,我们首先要了解以下运算符在C语言中的优先级: ...这样的一个表达式就是中缀表达式(也称中序表达式),但由于这种表达式不容易被计算机解析,所以我们需要将其转化为后缀表达式! 后...
  • c语言后缀表达式

    千次阅读 2020-03-25 18:17:44
    后缀表达式计算请使用已定义好的栈完成后缀表达式计算: (1)如果是操作数,直接入栈 (2)如果是操作符op,连续出栈两次,得到操作数x 和 y,计算 x op y,并将结果入栈。后缀表达式示例如下: 9 3 1 - 3 * + 10 2 /...
  • 中缀表达式到后缀表达式的转换是堆栈应用的典型例子。通过只允许操作‘+’,‘-’,‘*’,‘/’,并坚持优先级法则,即可实现该操作。 1. 规则 假设读入的中缀表达式是正确的。 当读到操作数时,立即输出。 操作符...
  • 本文实例为大家分享了C++实现中缀表达式转后缀表达式的具体代码,供大家参考,具体内容如下 题目:现有中缀表达式如:1+(2-3)*4+10/5 请用栈的特性编写一个程序,使得程序输出后缀表达式 分析如下: STEP1: 1+(2-3)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,065
精华内容 10,426
关键字:

后缀表达式c语言