精华内容
下载资源
问答
  • 该程序实现了运算表达式转换为中缀表达式、中缀表达式转换为后缀表达式及后缀表达式求值。该程序已实现加减乘除括号运算符及求余、幂指数的求解
  • 表达式2*(9+6/3-5)+4,称为中缀表达式,表示成2 9 6 3 / + 5 - * 4 +称为后缀表达式,表示成+ * 2 - + 9 / 6 3 5 4称为前缀表达式。 ·基本要求 将中缀表达式,转换为后缀表达式和前缀表达式,再分别计算转换后的...
  • 中序表达式转后序表达式,思路较为清晰,注释详细。。。
  • Lambda表达式&Stream

    千人学习 2020-12-17 21:31:55
    该课程基于最新的java14平台,由浅入深的详细讲解了Lambda表达式/Stream/函数式接口/Optional类的使用,本课程属于java技术的进阶课程。
  • 【入门基础+轻实战演示】【讲授方式轻松幽默、有趣不枯燥、案例与实操结合,与相关课程差异化】常用模块的介绍,详细剖析包括time模块,os模块等常用模块,正则表达式基础语法,常用函数,以及通过正则表达式完成...
  • cron表达式校验,验证是否是正确的cron表达式,调用的主方法是function cronValidate(cronExpression ),有需要可以看一下
  • 用dev c++写的代码,附有啰里啰嗦的注释和测试样例。太简单了不好意思要分。
  • java代码实现中缀表达式转后缀表达式,并计算结果
  • POJ2014考研试题表达式·表达式树·表达式求值答案
  • c语言实现中缀表达式转后缀表达式并求得计算结果,用顺序栈结构。 当输入者输入错误信息的时候需要报错,并说明错误的种类。
  • 生成定时表达式

    2018-07-03 14:20:53
    生成表达式corn生成表达式corn生成表达式corn生成表达式corn生成表达式corn生成表达式corn生成表达式corn生成表达式corn生成表达式corn生成表达式corn生成表达式corn生成表达式corn生成表达式corn生成表达式corn生成...
  • 正则表达式工具regexbuddy正则表达式工具regexbuddy正则表达式工具regexbuddy正则表达式工具regexbuddy正则表达式工具regexbuddy正则表达式工具regexbuddy正则表达式工具regexbuddy正则表达式工具regexbuddy正则...
  • C#入门精讲(10)正则表达式及应用

    千人学习 2018-06-20 22:47:22
    教学理念 1、把“需要工作的人”变成“工作需要的人”  2、创设“立足学生、突出项目、强化技术、提高能力”教学局面。  【课程特色】  1、课程设计循序渐进、讲解细致、通俗易懂、非常适合自主学习&...
  • Cron表达式生成器html源码

    热门讨论 2015-08-11 16:51:59
    在线Cron表达式生成器html源码 quartz任务调度 Cron表达式 在线生成
  • 表达式求值(C语言栈实现).已测试,没有任何错误和警告
  • 其中包括windows和linux文件路径的正则表达式;去除空格和斜杠转换的replaceall方法
  • C++用栈实现表达式求值,经过验收的,可以运行,没有问题
  • 将中缀表达式,转换为后缀表达式。 并由中缀表达式及后缀表达式生成二叉树,用于判断表达式是否合法。(包括表达式的逻辑判断)
  • 给定一个表达式,输出其中缀表达式,利用了栈和二叉树,是理解数据结构很好的资料
  • 前序表达式 中序表达式 后序表达式

    千次阅读 2019-04-19 19:29:50
    中序表达式: 中序表达式就是我们日常使用的表达式,由左往右阅读,结构清晰,但需要括号改变优先级,对计算机不友好 eg: (1+4)*3+10/5 前序表达式(波兰表示法Polish notation,或波兰记法): 一种逻辑、算术和...

    中序表达式:

    中序表达式就是我们日常使用的表达式,由左往右阅读,结构清晰,但需要括号改变优先级,对计算机不友好

    eg: (1+4)*3+10/5

    前序表达式(波兰表示法Polish notation,或波兰记法):

    一种逻辑算术代数表示方法,其特点是操作符置于操作数的前面,如果操作符的元数(arity)是固定的,则语法上不需要括号仍然能被无歧义地解析,不需要括号来改变优先级,未推广使用。

    eg:

    中序表达式:(1 + 4) * 3 + 10 / 5 
    
    前序表达式:  + * + 1 4 3  / 10 5 
    
    
    前序表达式的运算:
        
    eg:
        + * + 1 4 3  / 6 5 
    
    运算: + 1 4  =>   1 + 4 = 5  
          
          * 5 3  =>  5 * 3 = 15
         
    新前序: + 15 / 10 5 
        
        / 10 5  =>  10 / 5 =2
        
    新前序:  + 15 2
            
          =>  15 + 2 = 17  

     

    后序表达式(逆波兰表示法Reverse Polish notationRPN,或逆波兰记法):

    所有操作符置于操作数的后面,因此也被称为后缀表示法。逆波兰记法不需要括号来标识操作符的优先级,使用广泛。艾兹格·迪科斯彻引入了调度场算法,用于将中缀表达式转换为后缀形式。因其操作类似于火车编组场而得名。 大多数操作符优先级解析器(解析器用简单的查表操作即可实现,优先级表由开发者自己定制,在不同的应用场景中,开发者可自由改变操作符的优先级)能转换为处理后缀表达式,实际中,一般构造抽象语法树,树的后序遍历即为逆波兰记法。

    eg:

    中序表达式:(1 + 4) * 3 + 10 / 5 
    
    后序表达式: 1 4 + 3 *  10 5 / +
    
    
    后序表达式的运算:
        
    eg:
        1 4 + 3 *  10 5 / +
    
    运算: 1 4 +  =>   1 + 4 = 5  
          
          5 3 *  =>  5 * 3 = 15
         
    新后序:  15 / 10 5 + 
        
         10 5  / =>  10 / 5 =2
        
    新后序:  15 2 +
            
          =>  15 + 2 = 17  

    中序转后序(调度场算法)

    1. 创建一个队列和一个操作数栈
    2. 遇到操作数则送入队列
    3. 遇到操作符则送入栈
    4. 遇到其他运算符:加减乘除:弹出所有优先级大于或者等于该运算符的栈顶元素,然后将该运算符入栈
    5. 遇到” )“括号则将栈内从”( “到” )“的所有操作符全部取出送入队列
    6. 表达式分类完成后,先输出队列内容,再输出栈内容,前者+后者便是后序表达式

    实现代码(Java版):

    package chapter1_3;
    
    import java.util.ArrayList;
    import java.util.Scanner;
    import java.util.Stack;
    import edu.princeton.cs.algs4.Queue;
    //这个是《算法》里的队列定义包,因为Java里的queue只是一个接口,需要继承重写,这里就懒得麻烦了
    
    /**
     * @author : jeasion
     * @name
     * @comment
     *这里先把表达式转换成数组,使操作数和操作符分离,然后进行转换操作
     * @return
     */
    public class practice10 {
    	public static void main(String[] args) {
    		Scanner scanner = new Scanner(System.in);
    		System.out.print("请输入表达式:");
    		String s = scanner.next();
    		String[] num = split(s);
    		s = InfixToPostfix(num);
    		System.out.println("后序表达式:" + s);
    	}
    
    	public static String[] split(String s) {
    
    		String[] nums = s.split("\\+|\\-|\\*|\\/|\\(|\\)");
    		Queue<String> queue = new Queue<String>();
    		for (int i = 0; i < s.length(); i++) {
    			if (s.charAt(i) == '+' || s.charAt(i) == '-' || s.charAt(i) == '*' || s.charAt(i) == '/'
    					|| s.charAt(i) == '(' || s.charAt(i) == ')') {
    				queue.enqueue(s.charAt(i) + "");
    			}
    		}
    		ArrayList<String> arrayList = new ArrayList<String>();
    		String string = queue.dequeue();
    		if (string.equals("(")) {
    			arrayList.add(string);
    		} else
    			queue.enqueue(string);
    		for (int i = 0; i < nums.length; i++) {
    			if (nums[i].equals("")) {
    				continue;
    			}
    			arrayList.add(nums[i]);
    			if (!queue.isEmpty()) {
    				string = queue.dequeue();
    				arrayList.add(string);
    				if (string.equals(")")) {
    					string = queue.dequeue();
    					arrayList.add(string);
    				}
    			}
    		}
    
    		String[] res = new String[arrayList.size()];
    		for (int i = 0; i < arrayList.size(); i++) {
    			res[i] = arrayList.get(i);
    		}
    		System.out.println("表达式转字符串数组:" + arrayList.toString());
    		return res;
    	}
    
    	public static String InfixToPostfix(String[] s) {
    		Stack<String> stack = new Stack<String>();
    		Queue<String> queue = new Queue<String>();
    
    		String s1 = "";
    		for (int i = 0; i < s.length; i++) {
    
    			// 如果碰到右括号则遍历栈,并送入队列,直到碰到"("
    			if (s[i].equals(")")) {
    				s1 = stack.pop();
    				while (!s1.equals("(")) {
    					queue.enqueue(s1);
    					s1 = stack.pop();
    				}
    				continue;
    			}
    			// 如果碰到左括号则送入栈
    			if (s[i].equals("(")) {
    				stack.push(s[i]);
    				continue;
    			}
    
    			// 遇到其他运算符:加减乘除:弹出所有优先级大于或者等于该运算符的栈顶元素,然后将该运算符入栈
    			if (s[i].equals("+") || s[i].equals("-")) {// 碰到"+"或 "-"运算符,则进行栈操作
    				if (stack.isEmpty()) {// 如果栈为空,则直接入栈
    					stack.push(s[i]);
    					continue;
    				}
    				while (!stack.isEmpty() && !stack.peek().equals("(")) {
    					queue.enqueue(stack.pop());
    				}
    				stack.push(s[i]);
    				continue;
    			}
    			boolean operat = s[i].equals("*") || s[i].equals("/"); // 运算符是乘除
    			if (operat && stack.isEmpty()) {// 如果栈为空,则直接入栈
    				stack.push(s[i]);
    				continue;
    			}
    			if (operat) {// 乘除的运算符只能弹出乘除运算符
    				boolean peek = stack.peek().equals("*") || stack.peek().equals("/"); // 栈里面的运算符也是乘除
    				while (!stack.isEmpty() && peek) {
    					queue.enqueue(stack.pop());
    				}
    				stack.push(s[i]);
    				continue;
    			}
    
    			// 剩下的操作数,送入队列
    			queue.enqueue(s[i]);
    		}
    
    		String res = "";// 初始化s来接收表达式
    
    		// 接收队列的值
    		do {
    			res += queue.dequeue() + " ";
    		} while (!queue.isEmpty());
    
    		// 接受栈的值
    		do {
    			res += stack.pop() + " ";
    		} while (!stack.isEmpty());
    
    		return res;
    	}
    }

     

    展开全文
  • 用Java写的Cron表达式解析, Java swing编写的简洁界面,表达式到界面,界面到表达式,实现双重解析
  • 中缀表达式转后缀表达式

    万次阅读 多人点赞 2019-04-12 17:55:21
    因为中缀表达式便于人们的理解与计算,但是后缀表达式更方便计算机的运算(如二叉树、堆栈的方法计算),因此在读取一个中缀表达式后,我们得办法将他转化为后缀表达式。 转化方式有三种: 首先假设我们需要转化.....

    自从找完工作人就废了,幡然醒悟不行不行,得把忘记的都记下来。。。。。。

    中缀表达式就是我们正常使用的那种,例如:a+b*c

    后缀表达式就是abc*+;

    为什么要有中缀表达式和后缀表达式呢?

    因为中缀表达式便于人们的理解与计算,但是后缀表达式更方便计算机的运算(如二叉树、堆栈的方法计算),因此在读取一个中缀表达式后,我们得办法将他转化为后缀表达式。

    转化方式有三种:

    首先假设我们需要转化的中缀表达式为:

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

    第一种:基于堆栈的算法

    1. 从左到右扫描每一个字符。如果扫描到的字符是操作数(如a、b等),就直接输出这些操作数。

      c++堆栈的应用:中缀表达式转化为后缀表达式

    2. 如果扫描到的字符是一个操作符,分三种情况:

      (1)如果堆栈是空的,直接将操作符存储到堆栈中(push it)

      (2)如果该操作符的优先级大于堆栈出口的操作符,就直接将操作符存储到堆栈中(push it)

      (3)如果该操作符的优先级低于堆栈出口的操作符,就将堆栈出口的操作符导出(pop it), 直到该操作符的优先级大于堆栈顶端的操作符。将扫描到的操作符导入到堆栈中(push)。

      c++堆栈的应用:中缀表达式转化为后缀表达式

      c++堆栈的应用:中缀表达式转化为后缀表达式

    3. 如果遇到的操作符是左括号"(”,就直接将该操作符输出到堆栈当中。该操作符只有在遇到右括号“)”的时候移除。这是一个特殊符号该特殊处理。

      c++堆栈的应用:中缀表达式转化为后缀表达式

      c++堆栈的应用:中缀表达式转化为后缀表达式

      c++堆栈的应用:中缀表达式转化为后缀表达式

    4. 如果扫描到的操作符是右括号“)”,将堆栈中的操作符导出(pop)到output中输出,直到遇见左括号“(”。将堆栈中的左括号移出堆栈(pop )。继续扫描下一个字符

      c++堆栈的应用:中缀表达式转化为后缀表达式

    5. 如果输入的中缀表达式已经扫描完了,但是堆栈中仍然存在操作符的时候,我们应该讲堆栈中的操作符导出并输入到output 当中。

      c++堆栈的应用:中缀表达式转化为后缀表达式

      c++堆栈的应用:中缀表达式转化为后缀表达式

    第二种:括号法,这种真的很简单啊,好记又简单

          1:按照运算符的优先级对所有的运算单位加括号~

          式子变成拉:((a+(b*c))+(((d*e+f)*g))

           2:转换前缀与后缀表达式

          前缀:把运算符号移动到对应的括号前面

          则变成拉:++(a*(bc))*(+(*(de)f)g)

          把括号去掉:++a*bc*+*defg 前缀式子出现

          后缀:把运算符号移动到对应的括号后面

          则变成拉:((a(bc)*)+(((de)*f)+g)*)+

          把括号去掉:abc*+de*f+g *+后缀式子出现

    第三种:利用语法树

          1、将式子转化为二叉树,如下所示,图做的有点丑,懒得画了,不要介意。。。。。。

          2、通过后序遍历将其写出来,即可得到结果:abc*+de*f+g *+

    在这里补充一点,如何将表达式变成二叉树:

    表达式生成树的特点为:

        a. 叶子节点都是操作数;

        b. 非叶子节点都是运算符;

        c. 树根的运算符优先级低;

    步骤如下

    找到表达式中优先级最低的运算符作为树根(注意括号会提升内部的优先级),并将原表达式分解成左右两个表达式;

    分别对左右表达式做步骤1, 左边生成的树为树根的左子树,右边生成的树为树根的右子树;

    重复步骤1,2, 直到分解的表达式里没有运算符(只剩下数字)为止;

    注意一点:在遇到像本式中a后面的+号和c后面的+的优先级问题,在正常计算时a后面的+会先使用所以他的优先级比c后面的+优先级高。所以能得到上面的二叉树。

    后序遍历的问题看我其他的文章中有介绍。

    展开全文
  • C++程序,将后缀表达式用栈转换为前缀表达式
  • 表达式树与前中后缀表达式

    万次阅读 多人点赞 2018-10-11 21:09:03
    计算机科学中,除了栈以外,二叉树也是处理表达式的常用工具,为了处理表达式而遵循相应规则构造的树被称为表达式树。 表达式树 算数表达式是分层的递归结构,一个运算符作用于相应的运算对象,其运算对象又可以是...

    计算机科学中,除了栈以外,二叉树也是处理表达式的常用工具,为了处理表达式而遵循相应规则构造的树被称为表达式树。

    表达式树

    算数表达式是分层的递归结构,一个运算符作用于相应的运算对象,其运算对象又可以是任意复杂的表达式。树的递归结构正好用来表示这种表达式。下面只讨论二元表达式。
    二元表达式可以很自然的联系到二叉树:以基本运算对象作为叶节点中的数据;以运算符作为非叶节点中的数据,其两棵子树是它的运算对象,子树可以是基本运算对象,也可以是复杂表达式。如图是一个表达式树。
    表达式树

    前缀、中缀和后缀表达式

    中缀表达式(中缀记法)
    我们平时缩写的表达式,将运算符写在两个操作数中间的表达式,称作中缀表达式。在中缀表达式中,运算符有不同的优先级,圆括号用于改变运算顺序,这使得运算规则比较复杂,求值过程不能直接从左到右顺序进行,不利于计算机处理。

    后缀表达式
    将运算符写在两个操作数之后的表达式称作后缀表达式。后缀表达式中没有括号,并且运算符没有优先级。后缀表达式的求值过程能够严格按照从左到右的顺序进行,有利于计算机处理。

    前缀表达式
    前缀表达式是将运算符写在两个操作数之前的表达式。和后缀表达式一样,前缀表达式没有括号,运算符没有优先级,能严格按照从右到左的顺序计算。

    另外,算式表达式和表达式树的关系如下:

    • 表达式树的先根遍历:前缀表达式
    • 表达式树的中根遍历:中缀表达式
    • 表达式树的后根遍历:后缀表达式

    表达式的转换

    利用表达式树

    给定一个表达式的中缀形式:(4+1*(5-2))-6/3
    首先将每个运算加上括号,区分优先级,得到(4+(1*(5-2)))-(6/3)
    括号外的-优先级最低,作为根节点,(4+(1*(5-2)))作为左子树,(6/3)作为右子树;
    递归的转换4+(1*(5-2)),+最为根节点,4是左子树,(1*(5-2))是右子树。*是右子树的根节点,1是左子树,(5-2)是右子树。最后计算(5-2),-是根节点,5是左子树,2是右子树。得到的表达式树如文章之初给出的图。

    构造好表达式树之后,前缀表达式和中缀表达式可根据先根遍历和后根遍历得到。
    前缀表达式:- + 4 * 1 - 5 2 / 6 3
    后缀表达式:4 1 5 2 - * + 6 3 / -

    利用栈

    将中缀表达式转换为后缀表达式
    step1:初始化一个栈和一个后缀表达式字符串
    step2:从左到右依次对中缀表达式中的每个字符进行以下处理,直到表达式结束

    • 如果字符是‘(’,将其入栈
    • 如果字符是数字,添加到后缀表达式的字符串中
    • 如果字符是运算符,先将栈顶优先级不低于该运算符的运算符出栈,添加到后缀表达式中,再将该运算符入栈。注意,当‘(’在栈中时,优先级最低
    • 如果字符是‘)’,将栈顶元素出栈,添加到后缀表达式中,直到出栈的是‘(’
      step3:如果表达式结束,但栈中还有元素,将所有元素出栈,添加到后缀表达式中

    例如给定一个表达式的中缀形式:(4+1*(5-2))-6/3,栈中元素和表达式的变化如下表所示:

    扫描到的元素后缀表达式说明
    ((将(入栈,表达式空
    4(4将4加入表达式
    +( +4将+入栈
    1( +4 1将1加入表达式
    *( + *4 1将*入栈
    (( + * (4 1将(入栈
    5( + * (4 1 5将5加入表达式
    -( + * ( -4 1 5将-入栈
    2( + * ( -4 1 5 2将2 加入表达式
    )( + *4 1 5 2 --出栈,加入表达式
    )4 1 5 2 - * +*和+出栈,加入表达式,栈空
    --4 1 5 2 - * +-入栈
    6-4 1 5 2 - * + 66加入表达式
    /-/4 1 5 2 - * + 6/入栈
    3-/4 1 5 2 - * + 6 33加入表达式
    4 1 5 2 - * + 6 3 / -表达式扫描结束,将栈中元素加入表达式

    最后得到后缀表达式为4 1 5 2 - * + 6 3 / -

    将中缀表达式转换为前缀表达式
    中缀表达式转换到前缀表达的方法和转换到后缀表达式过程一致,细节上有所变化
    step1:初始化两个栈s1 和s2
    step2:从右到左依次对中缀表达式中的每个字符进行以下处理,直到表达式结束

    • 如果字符是‘)’,将其入栈
    • 如果字符是数字,添加到s2中
    • 如果字符是运算符,先将栈顶优先级不低于该运算符的运算符出栈,添加到s2中,再将该运算符入栈。当‘)’在栈中是,优先级最低
    • 如果字符是‘(’,将栈顶元素出栈,添加到s2中,直到出栈的是‘)’
      step3:如果表达式结束,但栈中还有元素,将所有元素出栈,添加s2中
      step4:将栈s2中元素依次出栈,即得到前缀表达式

    给定一个表达式的中缀形式:(4+1*(5-2))-6/3,其前缀形式为 - + 4 * 1 - 5 2 / 6 3

    表达式的计算

    中缀表达式的计算我们已经非常清楚,前缀和后缀表达式更适合计算机处理
    后缀表达式的计算
    后缀表达式没有括号,运算符的顺序即为实际运算顺序,在求值过程中,当遇到运算符时,只要取得前两个操作数就可以立即进行计算。当操作数出现时,不能立即求值,需要先保存等待运算符。对于等待中的操作数而言,后出现的先运算,所以需要一个栈辅助操作。
    后缀表达式的运算过程如下:
    step1:设置一个栈
    step2:从左到右对后缀表达式中的字符进行以下处理:
    - 如果字符是数字,现将其转化为数字,然后入栈
    - 如果字符是运算符,出栈两个值进行计算。计算结果入栈
    - 重复以上步骤,直到后缀表达式扫描结束,栈中最后一个元素就是表达式的结果。

    给定后缀表达式4 1 5 2 - * + 6 3 / -,依次将4 1 5 2 入栈,当扫描到-时,2,5出栈,计算5-2=3;将3入栈,此时栈中元素为4 1 3。接着扫描到*,3 1出栈,计算1*3=3,3入栈,栈中元素为4 3,。扫描+,3 4出栈,计算4+3=7,7入栈。接着6 3 入栈,栈中该元素为7 6 3,扫描到/,3 6出栈,计算6/3=2,2入栈,栈中元素为7 2.扫描-,2 7 出栈,计算7-2=5,5入栈。表达式扫描完毕,栈中元素为5,表达式结果为5.
    前缀表达式的计算
    前缀表达式的计算扫描顺序从右到左,其他和后缀表达式的计算完全一致。


    以上内容转载自二叉树的简单应用–表达式树,略加修改,给此文博主一个大大的赞,良心好文!!!本文以下内容为我对于这篇博文的一个补充。

    表达式树代码实现

    如何给一个表达式建立表达式树呢?方法有很多,这里只介绍一种:找到"最后计算"的运算符(它是整棵表达式树的根),然后递归处理(这也是前文介绍的方法)。下面是程序:

    const int maxn = 1000;
    int lch[maxn], rch[maxn]; char op[maxn];
    int nc = 0;		//结点数
    int build_tree(char* s, int x, int y)
    {
    	int i, cl = -1, c2 = -1, p = 0;
    	int u;
    	if(y-x == 1)		//仅一个字符,建立单独结点
    	{
    		u = ++nc;
    		lch[u] = rch[u] = 0; op[u] = s[x];
    		return u;
    	}
    	for(i = x; i < y; i++)
    	{
    		switch(s[i])
    		{
    			case '(': p++; break;
    			case ')': p--; break;
    			case '+': case '-': if(!p) c1 = i; break;
    			case '*': case '/': if(!p) c2 = i; break;
    		}
    	}
    	if(c1 < 0) c1 = c2;		//找不到括号外的加减号,就用乘除号
    	if(c1 < 0) return build_tree(s, x+1, y-1);		//整个表达式被一对括号括起来
    	u = ++nc;
    	lch[u] = build_tree(s, x, c1);
    	rch[u] = build_tree(s, c1+1, y);
    	op[u] = s[c1];
    	return u;
    }
    

    注意上述代码是如何寻找“最后一个运算符”的。代码里用了一个变量p,只有当p=0时才考虑这个运算符。为什么呢?因为括号里的运算符一定不是最后计算的,应当忽略。例如(a+b)*c中虽然有一个加号,但却是在括号里的,实际上比它优先级高的乘号才是最后计算的。由于加减和乘除号都是左结合的,最后一个运算符才是最后计算的,所以用两个变量c1和c2分别记录“最右”出现的加减号和乘除号。
    再接下来的代码就不难理解了:如果括号外有加减号,它们肯定最后计算;但如果没有加减号,就需要考虑乘除号( if(c1<0) c1 = c2 );如果全都没有,说明整个表达式外面被一对括号括起来,把它去掉后递归调用。这样,就找到了最后计算的运算符s[c1],它的左子树是区间[x, c1],右子树是区间[c1+1, y]。
    提示:建立表达式树的一种方法是每次找到最后的运算符,然后递归建树。“最后计算”的运算符是在括号外的、优先级最低的运算符。如果有多个,根据结合性来选择:左结合的(如加减乘除)选最右边;右结合的(如乘方)选最左边。根据规定,优先级相同的运算符的结合性总是相同。

    后缀表达式计算代码实现

    这个代码十分简单,只要将算法直译过来即是代码,博主比较懒,就将这个工作交给读者了,如果学校里后面有这个作业,博主会贴上代码。。


    拓展:由浅入深表达式树(一)创建表达式树

    展开全文
  • 等价表达式

    万次阅读 2021-02-23 21:34:40
    这个题目的题干中首先给出了一个代数表达式,然后列出了若干选项,每个选项也是一个代数表达式,题目的要求是判断选项中哪些代数表达式是和题干中的表达式等价的。 这个题目手算很麻烦,因为明明对计算机编程很感...

    明明进了中学之后,学到了代数表达式。有一天,他碰到一个很麻烦的选择题。这个题目的题干中首先给出了一个代数表达式,然后列出了若干选项,每个选项也是一个代数表达式,题目的要求是判断选项中哪些代数表达式是和题干中的表达式等价的。

    这个题目手算很麻烦,因为明明对计算机编程很感兴趣,所以他想是不是可以用计算机来解决这个问题。假设你是明明,能完成这个任务吗?

    这个选择题中的每个表达式都满足下面的性质:

    1.表达式只可能包含一个变量‘a’。

    2.表达式中出现的数都是正整数,而且都小于10000。

    3.表达式中可以包括四种运算‘+’(加),‘-’(减),‘’(乘),‘’(乘幂),以及小括号‘(’,‘)’。小括号的优先级最高,其次是‘’,然后是‘’,最后是‘+’和‘-’。‘+’和‘-’的优先级是相同的。相同优先级的运算从左到右进行。(注意:运算符‘+’,‘-’,‘*’,‘^’以及小括号‘(’,‘)’都是英文字符)

    4.幂指数只可能是1到10之间的正整数(包括1和10)。

    5.表达式内部,头部或者尾部都可能有一些多余的空格。

    下面是一些合理的表达式的例子:

    ((a^1) ^ 2)^3,a*a+a-a,((a+a)),9999+(a-a)*a,1 + (a -1)3,110^9……

    输入描述:
    第一行给出的是题干中的表达式。
    第二行是一个整数n(2<=n<=26),表示选项的个数。
    后面n行,每行包括一个选项中的表达式。这n个选项的标号分别是A,B,C,D……输入中的表达式的长度都不超过50个字符,而且保证选项中总有表达式和题干中的表达式是等价的。

    输出描述:
    包括一行,这一行包括一系列选项的标号,表示哪些选项是和题干中的表达式等价的。选项的标号按照字母顺序排列,而且之间没有空格。
    示例1
    输入
    ( a + 1) ^2
    3
    (a-1)^2+4*a
    a + 1+ a
    a^2 + 2 * a * 1 + 1^2 + 10 -10 +a -a
    输出
    AC

    备注:
    对于30%的数据,表达式中只可能出现两种运算符‘+’和‘-’;
    对于其它的数据,四种运算符‘+’,‘-’,‘*’,‘^’在表达式中都可能出现。
    对于全部的数据,表达式中都可能出现小括号‘(’和‘)’。

    #include <iostream>
    #include <cstring>
    #include <cstdio>
    
    #define MX 55
    #define oo 10020123
    #define MD 100000007
    
    using namespace std;
    
    typedef long long ll;
    
    ll qpw(ll x,ll t){ll ans=1;for(int i=1;i<=t;i++)ans=ans*x%MD;return ans;}
    
    ll calc(char *str,int l,int r,ll a)
    {
        int prio=0,mnpos=MX,mn=+oo,cnt=0,p[MX],num=0;
        memset(p,0x3f,sizeof(p));
        for(int i=r;i>=l;i--)
        {
            if(str[i]==')')prio+=100;
            if(str[i]=='(')prio-=100;
            if(str[i]=='^')p[i]=prio+3,cnt++;
            if(str[i]=='*')p[i]=prio+2,cnt++;
            if(str[i]=='+')p[i]=prio+1,cnt++;
            if(str[i]=='-')p[i]=prio+1,cnt++;
            if(mn>p[i])mn=p[i],mnpos=i;
        }
        if(cnt==0)
        {
            for(int i=l;i<=r;i++)if(str[i]=='a')return a;
            for(int i=l;i<=r;i++)if(isdigit(str[i]))num=num*10+str[i]-'0';
            return num;
        }
        else
        {
            if(str[mnpos]=='^')return qpw(calc(str,l,mnpos-1,a),calc(str,mnpos+1,r,a));
            if(str[mnpos]=='*')return (calc(str,l,mnpos-1,a)*calc(str,mnpos+1,r,a))%MD;
            if(str[mnpos]=='+')return (calc(str,l,mnpos-1,a)+calc(str,mnpos+1,r,a))%MD;
            if(str[mnpos]=='-')return (calc(str,l,mnpos-1,a)-calc(str,mnpos+1,r,a))%MD;
        }
        return 0;
    }
    
    int main()
    {
        int len[27],n,ans[15];
        char str[27][MX];  
    	cin.getline(str[0],MX);  
        //scanf("%[^\r]",str[0]),getchar();
        len[0]=strlen(str[0]);
        scanf("%d",&n),getchar();
        for(int i=1;i<=n;i++)
        {
        	cin.getline(str[i],MX);
            //scanf("%[^\r]",str[i]),getchar();
            len[i]=strlen(str[i]);
        }
        for(int i=0;i<=10;i++)ans[i]=calc(str[0],0,len[0]-1,i-5);
        for(int i=1;i<=n;i++)
        {
            int f=1;
            for(int j=0;j<=10;j++)
                if(ans[j]!=calc(str[i],0,len[i]-1,j-5))
                    {f=0;break;}
            if(f)printf("%c",'A'+i-1);
        }
        return 0;
    }
    
    展开全文
  • 身份证,银行卡号,手机号等的正则表达式,可以限制输入框的输入类型
  • regexBuilder 正则表达式自动生成器

    热门讨论 2015-07-09 13:34:15
    regexBuilder 正则表达式自动生成器,可自动生成正则表达式
  • C++算术表达式求值(支持函数) sin cos tan asin acos atan log sqrt cos(sin(sqrt(100*sqrt(100*10^2))))*(1.0e+5)/(1.0e-5) = 8.74513e+009
  • Jmeter的正则表达式提取参数

    万次阅读 多人点赞 2018-06-02 22:23:30
    1:Jmeter正则表达式提取器提取...表示匹配到结束为止PS:下面的正则表达式还可以写成 province:'([^']+)', 表示:[^']匹配到不是单引号 ’;+表示它内的多个字符1.3:添加Debug sampler(用Debug取样器可以方便tes...
  • 通过正则表达式生成满足条件的随机数据

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,212,444
精华内容 884,977
关键字:

表达式