精华内容
下载资源
问答
  • 文章目录中缀表达式前缀表达式前缀求值中缀变前缀前缀变中缀后缀表达式中缀变后缀后缀变中缀后缀求值 中缀表达式     中缀即我们平时用的数学表达式,其递归定义为中缀表达式 运算符 中缀表达式。举例:1+2,(1...

    中缀表达式

        中缀即我们平时用的数学表达式,其递归定义为中缀表达式 运算符 中缀表达式。举例:1+2,(1+2)*(3+4).这种表达式便于直观理解但是不方便计算机计算。后来有波兰人发明了前缀,后缀表达式。前缀表达式也叫波兰式,后缀表达式也叫逆波兰式。前后缀表达式经常作为栈在优先级的应用的例题。

    前缀表达式

        前缀表达式递归定义为 运算符 前缀表达式 前缀表达式

    前缀求值

        前缀计算方式即将运算符最右边两个放一起计算。
    例题1:中缀表达式:1+((2+3)*4)-5,其对应前缀为- + 1 * + 2 3 4 5.前缀求值方式为每次取两个数字进行计算。具体如下(声明两个stack, s1和s2)

    s1 s2 说明
    - + 1 * + 2 3 4 5 初始
    - + 1 * + 2 3 4 5
    - + 1 * + 2 3 4 5
    - + 1 * + 2 3 4 5
    - + 1 * + 2 3 4 5
    - + 1 * 5 4 5 2 3出栈,做加法再push回去
    - + 1 20 5 5 4出栈,做乘法再push回去
    - + 1 20 5
    - 21 5 20 1出栈,做加法再push回去
    16 21 5出栈,做加法再push回去

    最后结果16.
    可见前缀表达式通过栈保证每次都是当前优先级最高的两个做运算,也可以理解为保证先计算当前子前缀表达式。py代码如下:

    def calPre(number):
        stack = []
        while number:
            if number[-1].isdigit():
                stack.append(int(number[-1]))
                number.pop()
            else:
                a = stack[-1]
                b = stack[-2]
                stack.pop()
                stack.pop()
                if number[-1] == '+':
                    stack.append(a+b)
                elif number[-1] == '-':
                    stack.append(a-b)
                elif number[-1] == '*':
                    stack.append(a*b)
                else:
                    stack.append(a/b)
                number.pop()
        return stack[0]
    

    中缀变前缀

        那么先问问题来了,怎样将中缀变前缀?流程如下(摘抄自https://blog.csdn.net/idestina/article/details/81705516):
    1.初始化两个栈:运算符栈S1和储存中间结果的栈S2;
    2.从右至左扫描中缀表达式;
    3.遇到操作数时,将其压入S2;
    4.遇到运算符时,比较其与S1栈顶运算符的优先级:
      4.1. 如果S1为空,或栈顶运算符为右括号“)”,则直接将此运算符入栈;(右括号出现为了等待左括号,另外如果栈顶是右括号,此时开始计算子缀表达式)
      4.2. 否则,若优先级比栈顶运算符的较高或相等,也将运算符压入S1;
      4.3. 否则,将S1栈顶的运算符弹出并压入到S2中,再次转到(4-1)与S1中新的栈顶运算符相比较;(只有当 当前运算符级别比栈顶的低时才把栈顶的弹出,这样保证低级别尽可能留在最后计算,这句话纯属个人理解)
    5.遇到括号时:
      5.1. 如果是右括号“)”,则直接压入S1;
      5.2.如果是左括号“(”,则依次弹出S1栈顶的运算符,并压入S2,直到遇到右括号为止,此时将这一对括号丢弃;(一对括号内部是一个子表达式,也是一个子前缀表达式,虽然物理上是一串字符串,但是逻辑上就是一个数字因此需要将其算完)
    6.重复步骤(2)至(5),直到表达式的最左边;
    7.将S1中剩余的运算符依次弹出并压入S2;
    8.依次弹出S2中的元素并输出,结果即为中缀表达式对应的前缀表达式。
    这里边最关键的是栈的应用,如何通过栈安排好不同优先级的运算符。

    例题2:已知中缀表达式:1+((2+3)*4)-5 求前缀表达式。

    当前符号 s1(符号栈) s2(暂存结果) 说明
    5 5
    - - 5 符号栈空,直接push进去
    ) )- 5 )直接push进去
    4 )- 4 5 )直接push进去
    * *)- 4 5 栈顶是右括号,*直接push进去
    ) )*)- 4 5 )直接push进去
    3 )*)- 3 4 5 3直接push进去
    + +)*)- 3 4 5 +直接push进去
    2 +)*)- 2 3 4 5 2 直接push进去
    ( *)- + 2 3 4 5 遇到(,就把符号栈依次出栈直到遇到),)丢弃
    ( - * + 2 3 4 5 再次遇到(,就把符号栈依次出栈直到遇到),)丢弃
    + ± * + 2 3 4 5 栈顶优先级不低于+ 直接入栈
    1 ± 1* + 2 3 4 5 1入栈
    -+1* + 2 3 4 5 剩余依次入栈

    另外如果仅仅为了手工生成前缀,可以这样做:1+((2+3)*4)-5
    还是从右往左,遇到第一个符号是-,可以把中缀表达式分成两个部分:
    1+((2+3)*4)-5,那么其前缀表达式为 :
    -①1+((2+3)*4)②5
    下一步是把①②分别转化成中缀表达式,②不用转,直接看①
    ①可以写成:
    +③1 ④((2+3)*4))
    之后每一步如法炮制……
    下面是算法的代码实现:

    level = {'+':0,'-':0,'*':1,'/':1,'(':2,')':2}
    def midToPre(str):
        symbol,number = [],[]
    
        for i in range(len(str)-1,-1,-1):
            s = str[i]
            if s.isdigit():
                number.append(s)
            else:
                if not symbol or s == ')' or symbol[-1] == ')':#左括号或者symbol空直接入栈
                    symbol.append(s)
                elif s == '(':
                    while symbol[-1] != ')':
                        number.append(symbol[-1])
                        symbol.pop()
                    symbol.pop()
                else:
                    while symbol and level[s] < level[symbol[-1]]:
                        number.append(symbol[-1])
                        symbol.pop()
                    symbol.append(s)
        while symbol:
            number.append(symbol[-1])
            symbol.pop()
        number.reverse()
        return number
    

    前缀变中缀

    前缀变中缀的过程类似前缀求值计算。每次弹出两个,当当前运算符高于上次运算符时加上括号。
    例题:-+1* + 2 3 4 5 变中缀

    当前符号 stack 说明
    5 5
    4 4 5
    3 3 4 5
    2 2 3 4 5
    + 2+3 4 5
    * (2+3)*4 5 *高于+,加上括号
    1 1 (2+3)*4 5
    + 1+(2+3)*4 5
    - 1+(2+3)*4 - 5

    代码如下:

    def preToMid(preList):
        stack = []
        last = ''
        for i in range(len(preList)-1,-1,-1):
            s = preList[i]
            if s.isdigit():
                stack.append(s)
            else:
                if last != '' and level[s] > level[last]:
                    stack[-1] = ')'+stack[-1]+'('#最后要翻转
                a = stack[-1]
                b = stack[-2]
                stack.pop()
                stack.pop()
                stack.append(b+s+a)
                last = s
        return stack[0][::-1]
    

    后缀表达式

    后缀求值

        后缀表达式顾名思义,运算符在 后边,定义为 后缀表达式 运算符 后缀表达式。例如:1+((2+3)×4)-5的后缀表达式为1 2 3 + 4 × + 5 -。这个求值和前缀类似 ,不再赘述。

    中缀变后缀

        
    1.初始化两个栈:运算符栈S1和储存中间结果的栈S2;
    2.从左至右扫描中缀表达式;
    3.遇到操作数时,将其压入S2;
    4.遇到运算符时,比较其与S1栈顶运算符的优先级:
      4.1. 如果S1为空,或栈顶运算符为左括号“(”,则直接将此运算符入栈;
      4.2. 否则,若优先级比栈顶运算符的较高(不含 相等),也将运算符压入S1;
      4.3. 否则,将S1栈顶的运算符弹出并压入到S2中,再次转到(4-1)与S1中新的栈顶运算符相比较;(只有当 当前运算符级别比栈顶的低时才把栈顶的弹出,这样保证低级别尽可能留在最后计算,这句话纯属个人理解)
    5.遇到括号时:
      5.1. 如果是左括号“(”,则直接压入S1;
      5.2.如果是右括号“)”,则依次弹出S1栈顶的运算符,并压入S2,直到遇到右括号为止,此时将这一对括号丢弃;
    6.重复步骤(2)至(5),直到表达式的最左边;
    7.将S1中剩余的运算符依次弹出并压入S2;
    8.依次弹出S2中的元素并输出,结果即为中缀表达式对应的前缀表达式。
    注意与前缀的区别。

    后缀变中缀

    展开全文
  • 算法训练 表达式计算 时间限制:1.0s 内存限制:256.0MB   问题描述  输入一个只包含加减乖除和括号的合法表达式,求表达式的值。其中除表示整除。 输入格式  输入一行,包含一个表达式。 输出格式  ...
      算法训练 表达式计算  
    时间限制:1.0s   内存限制:256.0MB
        
    问题描述
      输入一个只包含加减乖除和括号的合法表达式,求表达式的值。其中除表示整除。
    输入格式
      输入一行,包含一个表达式。
    输出格式
      输出这个表达式的值。
    样例输入
    1-2+3*(4-5)
    样例输出
    -4
    数据规模和约定

      表达式长度不超过100,表达式运算合法且运算过程都在int内进行。





    下面这段话转自

    http://www.nowamagic.net/librarys/veda/detail/2307

    我们把平时所用的标准四则运算表达式,即“9+(3-1)*3+10/2"叫做中缀表达式。因为所有的运算符号都在两数字的中间,现在我们的问题就是中缀到后缀的转化。

    中缀表达式“9+(3-1)*3+10/2”转化为后缀表达式“9 3 1-3*+ 10 2/+”

    • 规则:从左到右遍历中缀表达式的每个数字和符号,若是数字就输出,即成为后缀表达式的一部分;若是符号,则判断其与栈顶符号的优先级,是右括号或优先级低于找顶符号(乘除优先加减)则栈顶元素依次出找并输出,并将当前符号进栈,一直到最终输出后缀表达式为止。

    下面我们来具体看看这个过程。

    1. 初始化一空栈,用来对符号进出栈使用。

    2. 第一个字符是数字9,输出9,后面是符号“+”,进

    3. 第三个字符是“(”,依然是符号,因其只是左括号,还未配对,故进栈。

    4. 第四个字符是数字3,输出,总表达式为9 3,接着是“-”进栈。

    5. 接下来是数字1,输出,总表达式为9 3 1,后面是符号“)”,此时,我们需要去匹配此前的“(”,所以栈顶依次出栈,并输出,直到“(”出栈为止。此时左括号上方只有“-”,因此输出“-”,总的输出表达式为9 3 1 -

    6. 接着是数字3,输出,总的表达式为9 3 1 - 3 。紧接着是符号“*”,因为此时的栈顶符号为“+”号,优先级低于“*”,因此不输出,进栈。

    7. 之后是符号“+”,此时当前栈顶元素比这个“+”的优先级高,因此栈中元素出栈并输出(没有比“+”号更低的优先级,所以全部出栈),总输出表达式为 9 3 1 - 3 * +.然后将当前这个符号“+”进栈。也就是说,前6张图的栈底的“+”是指中缀表达式中开头的9后面那个“+”,而下图中的栈底(也是栈顶)的“+”是指“9+(3-1)*3+”中的最后一个“+”。

    8. 紧接着数字10,输出,总表达式变为9 3 1-3 * + 10。

    9. 最后一个数字2,输出,总的表达式为 9 3 1-3*+ 10 2

    10. 因已经到最后,所以将栈中符号全部出栈并输出。最终输出的后缀表达式结果为 9 3 1-3*+ 10 2/+

    • 从刚才的推导中你会发现,要想让计算机具有处理我们通常的标准(中缀)表达式的能力,最重要的就是两步:
    1. 将中缀表达式转化为后缀表达式(栈用来进出运算的符号)。
    2. 将后缀表达式进行运算得出结果(栈用来进出运算的数字)。

    整个过程,都充分利用了找的后进先出特性来处理,理解好它其实也就理解好了栈这个数据结构。



    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<stack>
    using namespace std;
    stack <double> stack_num; //数值栈
    stack <char>  stack_ch;   //符号栈
    char str[1000];  //表达式数组
    char number[100];   //操作数数组


    void calculate_1()
    {
        char ch;
        double num1, num2;
        ch = stack_ch.top();
        while (ch != '(')
        {
            //num1,num2分别是栈顶和次顶元素,读取后并从栈中删除
            num1 = stack_num.top();
            stack_num.pop();
            num2 = stack_num.top();
            stack_num.pop();
            switch (ch)
            {
                case '+':
                    num2+=num1;
                    break;
                case '-':
                    num2-=num1;
                    break;
                case '*':
                    num2*=num1;
                    break;
                case '/':
                    num2/=num1;
                    break;
            }
            stack_num.push(num2); //计算结果num2入栈
            stack_ch.pop();  //删除已经用过的运算符栈顶元素
            ch = stack_ch.top();  //ch获取新的栈顶元素进行循环
        }
    }
    void calculate_2()
    {
        char ch;
        double num1,num2;
        ch = stack_ch.top();
        while (ch == '*' || ch == '/')
        {
            num1 = stack_num.top();
            stack_num.pop();
            num2 = stack_num.top();
            stack_num.pop();
            switch(ch)
            {
                case '*':
                    num2*=num1;
                    break;
                case '/':
                    num2/=num1;
                    break;
            }
            stack_num.push(num2);
            stack_ch.pop();
            ch = stack_ch.top();
        }
    }
    int main()
    {
        int i,k=0;
        char str1[2]="=";
        double n;
        gets(str);
        strcat(str,str1);
        stack_ch.push('(');
        for (i=0; str[i]; i++)
        {
            if (str[i]>='0' && str[i]<='9' || str[i]=='.')
              {
                 number[k++] = str[i];
                 continue;  //一个字符一个字符的获取一个操作数
              }
            number[k] = 0;
            if (number[0] != 0)
            {
                n = atof(number);
                number[0] = 0;
                stack_num.push(n);
            }
            k = 0;
            switch (str[i])
            {
                case '+':
                    calculate_1();
                    stack_ch.push('+');
                    break;
                case '-':
                    calculate_1();
                    stack_ch.push('-');
                    break;
                case '*':
                    calculate_2();
                    stack_ch.push('*');
                    break;
                case '/':
                    calculate_2();
                    stack_ch.push('/');
                    break;
                case '(':
                    stack_ch.push('('); //左括号直接入栈
                    break;
                case ')':
                    calculate_1();  //将右括号与左括号之间的运算符都用上
                    stack_ch.pop();//右括号不栈,并将栈顶的左括号删除
                    break;
                case '=':
                    calculate_1();
                    stack_ch.pop();
                    break;
             }


        }
        printf("%.0lf",stack_num.top());
        return 0;
    }

    展开全文
  • /*中缀表达式变成后缀表达式 *中缀表达式就是我们一般所见的式子 运算符在操作数之间 * 后缀表达式 运算符在操作数后面 * 规则:数据结构 栈 * 将中缀表达式转换为后缀表达式的算法思想: ·开始扫描; ...

    /*

      所有好的简短的代码 都是我写的。

      ~          别人写的

      下面像shit一样的代码绝对绝对不是我写的 不是我写的 就是这样

     */

    /*中缀表达式变成后缀表达式
     *中缀表达式就是我们一般所见的式子 运算符在操作数之间 
     * 后缀表达式 运算符在操作数后面
     * 规则:数据结构 栈
     * 将中缀表达式转换为后缀表达式的算法思想:
       ·开始扫描;
       ·数字时,加入后缀表达式;
       ·运算符:
       a. 若为 '(',入栈;
       b. 若为 ')',则依次把栈中的的运算符加入后缀表达式中,直到出现'(',从栈中删除'      '(' ;
       c. 若为 除括号外的其他运算符, 当其优先级高于除'('以外的栈顶运算符时,直接入    栈。否则从栈顶开始,依次弹出比当前处理的运算符优先级高和优先级相等的运算符,直到一个比它优先级低的或者遇到了一个左括号为止,然后将其自身压入栈中(先出后入)。
    ·当扫描的中缀表达式结束时,栈中的的所有运算符出栈;
     * 
     * 以下 数字均以字母代替 此代码bug很多,不能马上将字母代替为数字 即使可以多位数字仍需要继续修改
     *
     * 输入:中缀表达式
     * 输出:后缀表达式
     */
    #include<stdio.h>
    #include<string.h>
    #define maxsize 100
    typedef struct stack
    {
    	char data[maxsize];
    	int top;
    }stack,*sta;
    void judge(stack *s,char c,stack *s1);//似乎需要enum
    void print(stack *s,stack *s1);
    void push(stack *s,char c);
    void pop(stack *s,char c,stack *s1);
    void construct(char *s)
    {
    	stack op,postfix;
    	postfix.top=-1;
    	op.top=-1;
    	int i;
    	int len=strlen(s);
    	for(i=0;i<len;i++)
    	{
    		if(s[i]!='+'&&s[i]!='-'&&s[i]!='*'&&s[i]!='/'&&s[i]!='('&&s[i]!=')')
    		{
    			push(&postfix,s[i]);//如果是操作数加入后缀表达式栈
    			printf("%c ",s[i]);
    		}
    		else if(s[i]=='+'||s[i]=='-'||s[i]=='*'||s[i]=='/'||s[i]=='('||s[i]==')')
    		{
    			if(s[i]=='(')
    			{
    				push(&op,s[i]);//如果是( 入操作符栈
    			}
    			else if(s[i]==')')
    			{
    				pop(&op,s[i],&postfix);
    				/*如果是)则依次把栈中运算符加入后缀表达式,直到出现(,从栈里删除(*/
    			}
    			else
    			{
    				judge(&op,s[i],&postfix);
    				/* 如果优先级高于栈顶元素则入栈,否则从栈顶开始依次弹出比当前运算符优先级高或者相等的运算符直到遇见比它优先级低的或者遇到一个左括号为止,然后将其压入栈*/
    			}
    		}
    	}
    	print(&postfix,&op);//
    }
    void judge(stack *s,char c,stack *s1)//似乎需要enum
    {
    	char op=s->data[s->top];
    	if(op=='(') push(s,c);
    	else
            	switch(c)
    		{
    			case '+':pop(s,c,s1);break;
    			case '-':pop(s,c,s1);break;
    			case '*':if(op=='+'||op=='-') push(s,c);
    				 else pop(s,c,s1);break;
    			case '/':if(op=='+'||op=='-') push(s,c);
                                     else pop(s,c,s1);break;
    		}
    }
    void print(stack *s,stack *s1)
    {
    	while(s1->top>=0)
    	{
    		printf("%c",s1->data[s1->top]);
    		s1->top--;
    	}
    	printf("\n");
    }
    void push(stack *s,char c)
    {
    	s->data[++s->top]=c;
    }
    void pop(stack *s,char c,stack *s1)
    {
    	if(c==')')
    	{
    		while(s->data[s->top]!='(')
    		{
    			push(s1,s->data[s->top]);
    			printf("%c ",s->data[s->top]);
    			s->top--;
    		}
    		s->data[s->top--];
    	}
    	else// c 为 + - 没有用的op 或者 c为 * / op为* /都没用
    	{
    		if(s->top!=-1)
    		{
    		if(c=='+'||c=='-'||c=='*'||c=='/')
    		{
    		if(c=='+'||c=='-')
    		while(s->top>=0)
    		{
    			if(s->data[s->top]=='(') break;
    			else
    			{
    			//s->data[s->top]=in; 左值 右值 
    			push(s1,s->data[s->top]);
    			printf("%c ",s->data[s->top]);
    			s->top--;
    			}
    		}
    		else
    		{
    			while(s->top>=0)
    			{
    				if(s->data[s->top]=='('||s->data[s->top]=='+'||s->data[s->top]=='-') break;
    				else
    				{
    				push(s1,s->data[s->top]);				                        printf("%c ",s->data[s->top]);
    
    				s->top--;
    				}
    				
    			}
    		}
    		push(s,c);
    		}
    		}
    		else
    			push(s,c);
    	}	
    }
    int main()//shit 
    {
    	char s[]="a+b-a*((c+d)/e-f)+g";
    	construct(s);
    	char s1[]="a/b+(c*d-e*f)/g";
    	construct(s1);
    
    }

    输出:

    以上代码在很多地方都还可以改进,比如那些运算符匹配关系,现在没空。有空再改。

    这种像shit一样的代码真让人伤心,请赐予久久一个人类吧,每天马不停蹄地教久久。我允许他比我聪明了。

    这种像shit一样的垃圾还是让人很伤心。一波二叉树 ,线索二叉树,哈夫曼,B+,AVL即将来袭 溜了溜了

    展开全文
  • 中缀后缀表达式变表达式二叉树并且三种顺序历遍.zip
  • Java实现中缀表达式变后缀表达式一.什么是中、后缀表达式二.为什么用java三.代码随笔记 一.什么是中、后缀表达式 中缀就是咱平时常用的表达式,比如a+b ,c+d,两个数相关的运算符在数中间;同理后缀就是运算符在两...

    一.什么是中、后缀表达式

    中缀就是咱平时常用的表达式,比如a+b ,c+d,两个数相关的运算符在数中间;同理后缀就是运算符在两数之后,等价ab+,cd+

    二.为什么用java

    因为c和c++被我忘光了,敲了一下发现啥也不会,气急败坏地用java。
    参考文章:相同原理的c++实现中缀转后缀

    三.代码

    /**
         * 中缀表达式转换成后缀表达式
         * @param midExp 中缀表达式
         * @return posExp 后缀表达式
         */
    public String calculateExpression(String midExp) {
            String posExp = new String();
            List<Character> symbols = new ArrayList<>();
            List<Character> digitals = new ArrayList<>();
            char[] midExpChar = midExp.toCharArray(); //将中缀表达式转化成一个个字符
    
            for(int i=0;i<midExpChar.length;i++){
                char aChar = midExpChar[i];
                if(aChar>='a' && aChar <='z'){      //数字的处理
                    digitals.add(aChar);
                }else if(aChar=='+' || aChar=='-'){     //+-处理
                    if(symbols == null || symbols.size() == 0){ //操作符栈为空,不加会报数组越界
                        symbols.add(aChar);
                    }else{
                        while(symbols.get(symbols.size()-1)=='*' || symbols.get(symbols.size()-1)=='/'){
                            digitals.add(symbols.get(symbols.size()-1));
                            symbols.remove(symbols.size()-1);
                        }
                        symbols.add(aChar);
                    }
                }else if(aChar == '*' || aChar=='/' || aChar=='('){   //*/处理
                    symbols.add(aChar);
                }else if(aChar == ')'){
                    while(symbols.get(symbols.size()-1)!='('){
                        digitals.add(symbols.get(symbols.size()-1));
                        symbols.remove(symbols.size()-1);
                    }
                    symbols.remove(symbols.size()-1);
                }
            }
            while(symbols.size()!=0){       //处理操作符栈剩余
                digitals.add(symbols.get(symbols.size()-1));
                symbols.remove(symbols.size()-1);
            }
            posExp = digitals.toString().replace(",","");       //去掉string中的逗号
            return posExp;
        }
    

    随笔记

    又过一年,放下了很多曾经觉得无比重要的东西,得到的却是不知是好是坏的自身的改变。一个人坐在自己半年前选择的角落(另我后悔不已,好无聊),每天大部分的时间和精力用在自己的身上,一个人久了思维模式也慢慢变了,思考事情的时候都会不禁思考这事本质上对我有什么好处,不再在意很多东西。日渐接受自己的自私与无耻,日渐能够容纳不同于己的事物,能够接受自己被否定被质疑被鄙视,日渐追求简单却也对不得不做的麻烦事更有耐心,日渐渴望老婆孩子热炕头,日渐敬佩毛爷爷和张居正。。。
    其实很多的对立本质上是同一种东西,其实多数的思考都是矫情与庸人自扰,其实温柔的人才是最强大的(从外到内的强大,人都有柔软的地方,只是强大的人根本不怕你戳),其实没什么温水煮青蛙没什么堕落和上进,该干嘛干嘛,想那么多干啥。
    我也好想要规律,温暖舒适,无忧无虑的生活。此处羡慕皮皮皓1w点。可是偏偏上天让我看到了那些阳光外的东西,冥冥中给我以引导并让我产生那些思考,可能这就是让我生而为人所要做的事吧。现在的环境已经不能让我得到更多的东西了,我需要一个更高的平台,去寻找那些拥有相同思考的人,去实现我们共同的理想。
    每一个人都应该有尊严地活着,或者有尊严地死去。
    满纸荒唐言,不知道自己在写些什么,管他呢,反正不扣钱。

    展开全文
  • 中缀表达式变为后缀表达式 如图所示~~ 那么用栈怎么来表示呢??? 看图啦!!! 第一步:遇到数字直接放到后缀表达式 第二步:优先级高的入栈 第三步:每次入栈之前和栈顶运算符进行优先级比较,如果栈内高于栈外...
  • Java中缀表达式变后缀表达式源码 本程序在Eclipce 3.7下测试通过
  • 可以实现将一个以#号结束的中缀表达式转换为后缀表达式
  • 将输入的表达式中缀变后缀 后输出结果 完全用C语言实现的
  • 后缀表达式: 又叫逆波兰表达式 ,不包含括号,运算符放在两个运算对象的后面,所有的计算按运算符出现的顺序,严格从左向右进行(不再考虑运算符的优先规则,如:(2 + 1) * 3 , 即2 1 + 3 * 一个字符串表达式s...
  • 2.什么是后缀表达式后缀表达式就是根据中缀表达式转换来的,方便运算。((1+2)*5+1)/4 ==>12+5*1+4/3.要先把中缀表达式转变为后缀表达式,方便计算;为什么?方便程序编写(好像是废话);4.中缀表达式怎么转变为...
  • 程序用了两个栈实现表达式的计算 根绝算符优先级进行pop push 的到后缀表达式 并输出 然后再根绝所得的后缀表达式计算!
  • 本文档是用于中缀表达式直接求值和中缀表达式转化为后缀表达式求值,因此,并且还存在文档。
  • 中缀表达式,变后缀表达式,对你绝对绝对的有用哦,快快下载吧
  • 用JAVA 写的用JAVA 写的用JAVA 写的用JAVA 写的用JAVA 写的用JAVA 写的用JAVA 写的用JAVA 写的
  • 用c++中的堆栈实现中缀表达式变后缀表达式
  • 中缀变后缀和求后缀表达式的方法参考博客:http://blog.csdn.net/xiaoniba1024/article/details/6573452  http://blog.csdn.net/wu_lai_314/article/
  • /*中缀变后缀式思想 运算符等级 '*''/'>'+''-'>'('>')' 如果运算符栈为空,运算符入栈, 如果运算符不为‘)’,且栈顶运算符不为'(' 则比较运算符优先级,若栈顶优先级更高,则将栈顶元素移至数字栈,否则...
  • 中缀变后缀表达式

    2012-11-21 19:15:20
    中缀后缀转换表达式 运算符有+,-,*,/ 和^(指数运算),可以处理圆括号(),并假定输入的算术表达式正确。 测试输入 1 (A-(B*C+D)*E)/(F+G)# 输出 ABC*D+E*-FG+/
  • 利用栈表达式中缀变后缀,还有输入输出形式!
  • 2.0 什么是后缀表达式 就是把运算符放后面的表达式 例如 3 2+ 就是 3 + 2 3.0 中缀变后缀 例子3*(4+2)/2-5 1. 首先数字顺序不变: 3 4 2 2 5 2. 记住后缀表达式没有括号 3. 然后按优先级开始添运算符 .....
  • //存放后缀表达式 for (unsigned int i = 0; i(); i++) { char c = infix[i]; if (!((c >= 'A'&&c ) || c == '(' || c == ')' || c == '*' || c == '/' || c == '+' || c == '-')) throw c;//异常处理 ...
  • 郁闷的C小加(二)时间限制:1000 ms | 内存限制:65535 KB难度:4描述聪明的你帮助C小加解决了中缀表达式到后缀表达式的转换(详情请参考“郁闷的C小加(一)”),C小加很高兴。但C小加是个爱思考的人,他又想...
  • 郁闷的C小加(一) 时间限制:1000ms | 内存限制:65535KB 难度:3 ...我们熟悉的表达式如a+b、a+b*...同理,后缀表达式就是操作符在两个操作数之后:num1 num2 operand。ACM队的“C小加”正在郁闷怎样把一个中...
  • 对前缀表达式转后缀表达式符合以下规则 需要一个辅助的符号栈存储暂时不能确定顺序的运算符 1)后缀与前缀表达式中运算数顺序是不会的 从左往右读: 2)遇到操作数直接加入后缀表达式 3)遇到界限符'('压入符号栈...
  • 1.求中缀表达式X=A+B(C- (D+F)) /F的后缀表达式 加括号法:* 2.求中缀表达式(A+B) C (D-E/F)的后缀表达式 前缀表达式的时候在移括号的时候将运算符移到括号的左边再去括号就可以了 计算机计算前缀和后缀表达式...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 184
精华内容 73
关键字:

后缀表达式变中缀