精华内容
下载资源
问答
  • 中缀变后缀

    千次阅读 2015-04-10 19:35:51
    中缀表达式转换为后缀表达式(1042) Time limit(ms): 1000 Memory limit(kb): 10000 Submission: 149 Accepted: 27 Accepted 中缀表达式是一个通用的算术或逻辑公式表示...

    中缀表达式转换为后缀表达式(1042)

    Time limit(ms): 1000
    Memory limit(kb): 10000
    Submission: 149
    Accepted: 27
    Accepted

    中缀表达式是一个通用的算术或逻辑公式表示方法,操作符是以中缀形式处于操作数的中间(例:3 + 4),中缀表达式是人们常用的算术表示方法。后缀表达式不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则,如:(2 + 1) * 3 , 即2 1 + 3 *。利用栈结构,将中缀表达式转换为后缀表达式。(测试数据元素为单个字符)

    Description

    中缀表达式

    Input

    后缀表达式

    Output
    1
    A+(B-C/D)*E
    Sample Input
    1
    A B C D / - E * +

    #include<stdio.h>

    #include<string.h>
    #include<stdlib.h>
    int main()
    {
    void res();
    res();
    return 0;
    }
    void res()
    {
    void turn(char str[]);
    char str[100];
    while(scanf("%s",str)!=EOF)
    {
    turn(str);
    }
    }
    void turn(char str[])
    {
    char stack1[100];
    char str1[100];
    int len=strlen(str);
    int i,j=0,k=0;
    for(i=0;i<len;i++)
    {
    if(str[i]=='+' || str[i]=='-' || str[i]=='*' || str[i]=='/' || str[i]=='(' || str[i]==')')
    {
    stack1[j]=str[i];
    j++;
    if(str[i]==')')
    {
    j=j-1;
    while(1)
    {
    j--;
    if(stack1[j]=='(')
    break;
    else
    {
    str1[k]=stack1[j];
    k++;
    }
    }
    }
    }
    else
    {
    str1[k]=str[i];
    k++;
    }
    }
    for(i=j-1;i>=0;i--,k++)
    {
    str1[k]=stack1[i];
    }
    for(i=0;i<k;i++)
    {
    if(i==0)
    printf("%c",str1[i]);
    else 
    printf(" %c",str1[i]);
    }

    }

    用两个字符数组存储数据。一个存运算符,另外一个存字符,当遇到‘)’',就向前读取运算符,直到读到‘(’,此过程中,每读一个运算符,就要把这个运算符放在此时存字符的数组后面,当读取结束后,把存运算符的数组中的数据自后向前存入字符数组中。

    展开全文
  • 举例说明栈的应用——中缀变后缀
  • 数据结构中用中缀或中缀变后缀对表达式求值
  • 利用栈表达式的中缀变后缀,还有输入输出形式!
  • 中缀变后缀表达式

    2012-11-21 19:15:20
    中缀后缀转换表达式 运算符有+,-,*,/ 和^(指数运算),可以处理圆括号(),并假定输入的算术表达式正确。 测试输入 1 (A-(B*C+D)*E)/(F+G)# 输出 ABC*D+E*-FG+/
  • 用c++中的堆栈实现中缀表达式变后缀表达式
  • 栈_中缀变后缀

    2019-09-17 03:27:14
    demo01: a+b*c+( d*e + f )*g转换成abc*+de*f+g*+ 1.当读到一个操作数,立即将他放到输出中,操作符则不立即输出。放入栈中,遇到左 1.a+b*c+(d*e+f)*g stack : + 输出 a,b ...

    demo01:

    a+b*c+( d*e  + f )*g转换成abc*+de*f+g*+

    1.当读到一个操作数,立即将他放到输出中,操作符则不立即输出。放入栈中,遇到左

     

    1.a+b*c+(d*e+f)*g

      stack :

        +           输出 a,b

      back top:

     

    2.  read *:     输出  a b  c

    *

    +

     

    3.  read +:          输出  a b c  * +

    注意

    * > +; out

    + = +; out

    +; 注意这个是新的+

     

    4.继续读入( 

    ( 具有最高优先级      输出  a  b  c * + d

    +

     

    5. 读入*

    +(*               a  b  c * + d  e

     

    6.read +             a  b  c * + d  e

    +<*;

    + ( *   

     

    7. read +           a  b  c * + d  e  

    + (  *

     

    8.                     a b c * + d e * f

    + ( +

     

    9.  read  )

    匹配退出:       a b c * + d e * f +

    +

     

    10 :

    + *        a b c * + d e * f + g

     

    11

    结束:   a b c * + d e * f + g   (* +)  //依次从栈底压入输出

    转载于:https://my.oschina.net/u/578921/blog/176085

    展开全文
  • 中缀变后缀(nyoj)

    2013-11-03 14:55:28
    中缀变后缀式 时间限制:1000 ms | 内存限制:65535 KB 难度:3 描述人们的日常习惯是把算术表达式写成中缀式,但对于机器来说更“习惯于”后缀式,关于算术表达式的中缀式和后缀式的论述一般的...

    中缀式变后缀式

    时间限制:1000 ms  |  内存限制:65535 KB
    难度:3
    描述
    人们的日常习惯是把算术表达式写成中缀式,但对于机器来说更“习惯于”后缀式,关于算术表达式的中缀式和后缀式的论述一般的数据结构书都有相关内容可供参看,这里不再赘述,现在你的任务是将中缀式变为后缀式。
    输入
    第一行输入一个整数n,共有n组测试数据(n<10)。
    每组测试数据只有一行,是一个长度不超过1000的字符串,表示这个运算式的中缀式,每个运算式都是以“=”结束。这个表达式里只包含+-*/与小括号这几种符号。其中小括号可以嵌套使用。数据保证输入的操作数中不会出现负数。
    数据保证除数不会为0
    输出
    每组都输出该组中缀式相应的后缀式,要求相邻的操作数操作符用空格隔开。
    样例输入
    2
    1.000+2/4=
    ((1+2)*5+1)/4=
    样例输出
    1.000 2 4 / + =
    1 2 + 5 * 1 + 4 / =


    代码

    #include<stdio.h>
    #include<stack>
    #include<ctype.h>
    
    using namespace  std;
    
    stack<char>stack_char;
    
    #define MAXSIZE 1010
    
    int main()
    {
    	int count, i;
    	char str[MAXSIZE];
    
    	scanf("%d", &count);
    	while(count--)
    	{
    		while(!stack_char.empty())
    			stack_char.pop();						//将栈清空
    		scanf("%s", str);
    		stack_char.push('=');						//首先将栈中压入一个括号,
    		for(i = 0; str[i] != '='; i++)
    		{
    			if(isdigit(str[i]) || str[i] == '.')
    			{
    				printf("%c", str[i]);				  //数字直接打印
    				continue;
    			}
    			if(i > 0 && isdigit(str[i - 1]))
    				printf(" ");
    			switch(str[i])
    			{
    			case '(':
    				stack_char.push(str[i]);
    				break;
    			case '+':
    			case '-':
    				while(stack_char.top() != '(' && stack_char.top() != '=')
    				{
    					printf("%c ", stack_char.top());
    					stack_char.pop();
    				}
    				stack_char.push(str[i]);				
    				break;
    			case '*':
    			case '/':
    				while((stack_char.top() == '*' || stack_char.top() == '/') && stack_char.top() != '=')//栈顶符号为‘*’‘/’时依次弹栈
    				{
    					printf("%c ", stack_char.top());
    					stack_char.pop();
    				}
    				stack_char.push(str[i]);
    				break;
    			case ')':									//栈顶符号依次输出
    				while(stack_char.top() != '(')
    				{
    					printf("%c ", stack_char.top());
    					stack_char.pop();
    				}
    				stack_char.pop();
    			}
    		}
    		while(!stack_char.empty())
    		{
    			printf(" %c", stack_char.top());
    			stack_char.pop();
    		}
    		printf("\n");
    	}
    	return 0;
    }





    展开全文
  • 本文档是用于中缀表达式直接求值和中缀表达式转化为后缀表达式求值,因此,并且还存在文档。
  • 【转载】中缀变后缀

    2015-07-10 09:45:44
    program bds; const m=50; type {定义栈}  stack=array[1..m] of char;  stack1=array[1..m] of real; var  s:stack;  s1:stack1;  e,a:string;... {中缀表达式e转后缀表达式a, s为运
    program bds;
    const m=50;
    type {定义栈}
      stack=array[1..m] of char;
      stack1=array[1..m] of real;
    var
     s:stack;
     s1:stack1;
     e,a:string;
     i,l,p,y:integer;
     x:real;
    begin
      {中缀表达式e转后缀表达式a, s为运算符栈,P为指针}
     read(e);{读入一个中缀表达式}
     p:=0;
     l:=length(e);
     for i:=1 to l do
      begin
       case e[i] of
        '0'..'9':a:=a+e[i]; {若为数字,进入后缀表达式}
        '(':begin p:=p+1;s[p]:='('; end;{若为左括号,进栈}
        ')':begin     {若为右括号,则左括号前的所有运算符出栈进入后缀表达式,)舍}
            while s[p]<>'(' do
             begin
              a:=a+s[p];p:=p-1;
             end;
             p:=p-1;
            end;
        '+','-':begin{若为+-号,则左括号前的所有运算符出栈进入后缀表达式,+-号进栈}
                   while (s[p]<>'(') and (p<>0) do
                    begin a:=a+s[p];p:=p-1;end;
                   p:=p+1;s[p]:=e[i];
                end;
        '*','/':begin  {若为*/号,则左括号前的栈顶的*/出栈进入后缀表达式,*/号进栈}
                 while (p<>0) and ((s[p]='*') or (s[p]='/')) do
                  begin
                   a:=a+s[p];p:=p-1;
                  end;
                 p:=p+1; s[p]:=e[i];
                end;
        end;{case}
       end;{for}
       while p<>0 do {所有运算符出栈进入后缀表达式}
       begin
        a:=a+s[p];p:=p-1;
       end;
       writeln(a);
      { 计算后缀表达a的值,S1为存放操作数的栈,P为栈指针}
      l:=length(a); p:=0;
      for i:=1 to l do
       begin
        case a[i] of
         '0'..'9':begin {是操作数,将操作数转为数值类型数据后进栈}
                   p:=p+1; val(a[i],x,y); s1[p]:=x;
                  end;
         '+':begin     {栈顶的两个操作数出栈,进行加法运算,其结果进栈}
              x:=s1[p];p:=p-1; s1[p]:=s1[p]+x;
             end;
         '-':begin     {栈顶的两个操作数出栈,进行减法运算,其结果进栈}
              x:=s1[p];p:=p-1; s1[p]:=s1[p]-x;
             end;
         '*':begin     {栈顶的两个操作数出栈,进行乘法运算,其结果进栈}
              x:=s1[p];p:=p-1; s1[p]:=s1[p]*x;
             end;
         '/':begin     {栈顶的两个操作数出栈,进行除法运算,其结果进栈}
              x:=s1[p];p:=p-1; s1[p]:=s1[p]/x;
             end;
        end;{case}
       end;{for}
       writeln(s1[p]:5:2); {栈底的结果为最终运算结果}
      end.

    展开全文
  • C++计算器中缀变后缀

    2015-06-29 11:23:07
    //这部分是计算器的部分Run()是后缀运算,postfixRun()是中缀变后缀然后运算 ////////////////////////////////////////////////////////////// #ifndef _STACK_H_ #define _STACK_H_ #include <iostream...
  • java中缀变后缀表达式

    2007-08-10 15:44:40
    供大家参考学习,希望提些意见
  • 中缀变后缀的方法

    2013-12-05 14:27:04
    #include #inlcude using namespace std; bool priorCmp(char op1,char op2) {  bool ret=false; } void process(char* s[]) {  stack operS;  int i=0;  operS.push('#');  whi
  • //后缀变中缀 #include #include "three20.h" #include //建栈 Stack CreateStack() {  Stack s;  s=(Stack)malloc(sizeof(struct Node));  if(s==NULL)  {  printf("error")...
  • 栈s1存储操作符,栈s2存储操作数: 1)exp从左向右遍历,遇到操作数则直接入栈s2,遇到操作符时,当前操作符cur优先级与栈顶元素x作比较,如果cur > x ,直接入栈s1;如果cur 2)如果遇到 '( ',压入s1,知道遇到 ...
  • 1.输入一个中缀表达式将其转换为后缀表达式。 2.将转换过的后缀表达式的计算出来。 其中涉及到链表反转函数reversal,icp,isp(运算符在栈内栈外的优先级),进栈push,出栈pop,, 但是没有顺利的用模板。 ...
  • 诸如1+2*(3-4)+5的简单表达式 ...可把中缀表达式转换为后缀表达式计算。 算法如下:  1.设置一个运算符栈,从左到右对每个字符进行处理。  2.遇到左括号 ' '(直接入栈  3.遇到数字,原样输出。  
  • 闲着没事写了一个计算器回忆一下,支持加减乘除,括号,10以上的运算和负数。 不过没做错误判定,你的式子要是对的才行。。。 -19+(-3-(-11))*13+4/2 我的例子 ...因为最近用STL比较多,为了写起来方便,所以多了很多...
  • 原文链接:NYOJ-257 - 郁闷的C小加(一)题目大意:我们熟悉的表达式如a+b、a+b*(c+d)等都属于中缀表达式。...ACM队的“C小加”正在郁闷怎样把一个中缀表达式转换为后缀表达式,现在请你设计一个程序,帮助C小加把中
  • Problem code: ONP Transform the algebraic expression with brackets into RPN form (Reverse Polish Notation). Two-argument operators: +, -, *, /, ^ (priority from the lowest to the highest), brackets
  • 1、队列的链表实现 代码: //请在DEV中运行,先勾选“Tools" -勾选”Compailer Options"-再勾选"Add~~~“-框框中输入"-std=c++11” /*链队列的实现*/ #include &... struc...
  • 将输入的表达式由中缀变后缀 后输出结果 完全用C语言实现的
  • 中缀变后缀

    2017-08-10 10:36:39
    中缀变后缀式 时间限制:1000 ms | 内存限制:65535 KB 难度:3 描述 人们的日常习惯是把算术表达式写成中缀式,但对于机器来说更“习惯于”后缀式,关于算术表达式的中缀式和后缀式的论述一般的...
  • 不通过您的代码已保存运行超时:您的程序未能在规定时间内运行结束,请检查是否循环有错或算法复杂度过大。...public class Main{public static void main(String [] args){Scanner sc=new Scanner(System.in);...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 229
精华内容 91
关键字:

中缀变后缀