【数据结构(四)】前缀、中缀、后缀表达式(逆波兰表达式)和逆波兰计算器的代码实现(2)

文章目录

  • 1. 前缀表达式(波兰表达式)
    • 1.1. 前缀表达式的计算机求值
  • 2. 中缀表达式
  • 3. 后缀表达式(逆波兰表达式)
    • 3.1. 后缀表达式的计算机求值
    • 3.2. 逆波兰计算器的实现
  • 4. 中缀表达式 转 后缀表达式
    • 4.1. 思路分析
    • 4.2. 代码实现
  • 5. 逆波兰计算器的完整版


1. 前缀表达式(波兰表达式)

    前缀表达式又称波兰表达式,前缀表达式的运算符位于操作数之前

举例说明: (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6

1.1. 前缀表达式的计算机求值

    从右至左扫描表达式,遇到数字时,将数字压入堆栈;遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(栈顶元素 和 次顶元素),并将结果入栈;重复上述过程直到表达式最左端,最后运算得出的值即为表达式的结果。

例如:
(3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 , 针对前缀表达式求值步骤如下:
    ①从右至左扫描,将 6、5、4、3 压入堆栈
    ②遇到 + 运算符,因此弹出 3 和 4(3为栈顶元素,4为次顶元素),计算出 3 + 4 的值,得 7,再将 7 入栈
    ③接下来是 × 运算符,因此弹出 7 和 5 ,计算出 7 × 5 = 35,将35入栈
    ④最后是 - 运算符,计算出 35 - 6 的值,即 29 ,由此得出最终结果

2. 中缀表达式

    
    中缀表达式就是常见的运算表达式,如(3+4)×5-6

    中缀表达式的求值是我们人最熟悉的,但是对计算机来说却不好操作(前面我们讲的案例就能看的这个问题),因此,在计算结果时,往往会将中缀表达式转成其它表达式来操作(一般转成后缀表达式)

3. 后缀表达式(逆波兰表达式)

    后缀表达式又称逆波兰表达式,与前缀表达式相似,只是运算符位于操作数之后

举例说明:

正常表达式后缀表达式
(3+4)×5-63 4 + 5 × 6 –
a+ba b +
a+(b-c)a b c - +
a+(b-c)*da b c - d * +
a+d*(b-c)a d b c - * +
a=1+3a 1 3 + =

3.1. 后缀表达式的计算机求值

    
    从左至右扫描表达式,遇到数字时,将数字压入堆栈;遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(次顶元素 和 栈顶元素),并将结果入栈;重复上述过程直到表达式最右端,最后运算得出的值即为表达式的结果。

例如:
(3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:

    ①从左至右扫描,将3和4压入堆栈;
    ②遇到 + 运算符,因此弹出 4 和 3(4 为栈顶元素,3 为次顶元素),计算出 3 + 4 的值,得 7 ,再将 7 入栈;
    ③将 5 入栈;
    ④接下来是 × 运算符,因此弹出 5 和 7 ,计算出 7 × 5 = 35 ,将 35 入栈;
    ⑤将 6 入栈;
    ⑥最后是-运算符,计算出 35 - 6 的值,即 29 ,由此得出最终结果


3.2. 逆波兰计算器的实现

    
完成一个逆波兰计算器,要求完成如下任务:
    输入一个逆波兰表达式(后缀表达式),使用(Stack), 计算其结果
    支持小括号多位数整数(因为这里主要讲的是数据结构,因此计算器进行简化,只支持对整数的计算)

    
思路分析: 3.2. 小节已给出
    
代码实现:

package stack;import java.util.ArrayList;
import java.util.List;
import java.util.Stack;public class PolandNotation {public static void main(String[] args) {// 定义一个逆波兰表达式// (3+4)×5-6 --> "3 4 + 5 × 6 -"// 为了方便,逆波兰表达式的数字和符号使用 空格 隔开String suffixExpression = "3 4 + 5 * 6 -";// 思路// 1.先将"3 4 + 5 × 6 -"放到ArrayList中// 2.将ArrayList传递给一个方法,利用栈,完成计算List<String> rpnList = getListString(suffixExpression);System.out.println("rpnList=" + rpnList);int res = calculate(rpnList);System.out.println("计算的结果是=" + res);}// 将一个逆波兰表达式,依次将数据和运算符放入到ArrayList中public static List<String> getListString(String suffixExpression) {// 将suffixExpression分割String[] split = suffixExpression.split(" ");List<String> list = new ArrayList<String>();for (String ele : split) {list.add(ele);}return list;}// 完成对逆波兰表达式的运算/*** 1.从左至右扫描,将3和4压入堆栈;* 2.到 + 运算符,因此弹出 4 和 3(4 为栈顶元素,3 为次顶元素),计算出 3 + 4 的值,得 7 ,再将 7 入栈;* 3.将 5 入栈;* 4.接下来是 × 运算符,因此弹出 5 和 7 ,计算出 7 × 5 = 35 ,将 35 入栈;* 5.将 6 入栈;* 6.最后是-运算符,计算出 35 - 6 的值,即 29 ,由此得出最终结果*/public static int calculate(List<String> ls) {// 创建一个栈,只需要一个即可Stack<String> stack = new Stack<String>();// 遍历 lsfor (String item : ls) {// 这里使用正则表达式来取出数if (item.matches("\\d+")) {// 匹配的是多位数// 入栈stack.push(item);} else {// pop出两个数,并运算int num2 = Integer.parseInt(stack.pop());// 先pop出的数int num1 = Integer.parseInt(stack.pop());// 后pop出的数int res = 0;if (item.equals("+")) {res = num1 + num2;} else if (item.equals("-")) {res = num1 - num2;} else if (item.equals("*")) {res = num1 * num2;} else if (item.equals("/")) {res = num1 / num2;} else {throw new RuntimeException("运算符有误");}// 把res入栈stack.push("" + res);}}// 最后留在stack中的数据就是运算结果return Integer.parseInt(stack.pop());}}

运行结果:

在这里插入图片描述

注:也可以计算多位数,读者可自行测试

4. 中缀表达式 转 后缀表达式

    从前面讲的内容可以看出,后缀表达式适合计算机进行运算,但是人却不太容易写出来,尤其是表达式很长的情况下,因此在开发中,我们需要将 中缀表达式 转成 后缀表达式

4.1. 思路分析

    

具体步骤如下:

    1.初始化两个栈:运算符栈s1和储存中间结果的栈s2;
    2.从左至右扫描中缀表达式;
    3.遇到操作数时,将其压s2;
    4.遇到运算符时,比较其与s1栈顶运算符的优先级:
      (1)如果s1为空,或栈顶运算符为左括号“ ( ”,则直接将此运算符入栈;
      (2)否则,若优先级比栈顶运算符的高,也将运算符压入s1;
      (3)否则,将s1栈顶的运算符弹出并压入到s2中,再次转到 4.(1) 与s1中新的栈顶运算符相比较;

    5.遇到括号时:
      (1)如果是左括号“ ( ”,则直接压入s1
      (2) 如果是右括号“ ) ”,则依次弹出s1栈顶的运算符,并压入s2,直到遇到左括号为止,此时将这一对括号丢弃
    6.重复步骤2至5,直到表达式的最右边
    7.将s1中剩余的运算符依次弹出并压入s2
    8.依次弹出s2中的元素并输出,结果的逆序即为中缀表达式对应的后缀表达式

    
    


实例分析:
    下面,以中缀表达式:1 + ((2 + 3) * 4) - 5 为例,实现将其转成后缀表达式。

①初始化两个栈:运算符栈s1和储存中间结果的栈s2;从左至右扫描中缀表达式;
②遇到操作数时,将其压s2(首先扫描到 1

在这里插入图片描述

③遇到运算符时,比较其与s1栈顶运算符的优先级:
    (1)如果s1为空,或栈顶运算符为左括号“ ( ”,则直接将此运算符入栈(将 + 直接入s1栈,后面连续遇到两个" ( “,根据步骤5.(1),同理,直接将两个” ( "入s1栈
    
在这里插入图片描述

④遇到操作数时,将其压s2(扫描到 2

在这里插入图片描述

⑤因为下一个扫描到 + 运算符,而 " ( " 不是运算符,故直接将 + 入s1栈

在这里插入图片描述

⑥遇到操作数时,将其压s2(扫描到 3

在这里插入图片描述

⑦根据5.(2):如果是右括号“ ) ”,则依次弹出s1栈顶的运算符,并压入s2,直到遇到左括号为止,此时将这一对括号丢弃

在这里插入图片描述

⑧因为下一个扫描到 * 运算符,而 " ( " 不是运算符,故直接将 * 入s1栈;

在这里插入图片描述

接着扫描到 4 ,直接入s2栈

在这里插入图片描述

⑨根据5.(2):如果是右括号“ ) ”,则依次弹出s1栈顶的运算符,并压入s2,直到遇到左括号为止,此时将这一对括号丢弃

在这里插入图片描述

⑩下一个扫描到 - 符号,由于 - 的优先级与 + 相同,故执行 4.(3):将s1栈顶的运算符弹出并压入到s2中,再次转到 4.(1) 与s1中新的栈顶运算符相比较,由于原来的 + 入了s2栈,即s1栈为空,所以直接将 - 运算符入s1栈。

在这里插入图片描述

在这里插入图片描述

⑪下一个扫描到 5 ,入s2栈。这时已经到了表达式最右边,扫描完毕

在这里插入图片描述

⑫执行步骤7:将s1中剩余的运算符依次弹出并压入s2

在这里插入图片描述

⑬步骤8:依次弹出s2中的元素并输出,结果的逆序即为中缀表达式对应的后缀表达式

- 5 + * 4 + 3 2 1 – > 1 2 3 + 4 * + 5 -

通过图表来说明上述步骤:

在这里插入图片描述

    

4.2. 代码实现

    

package stack;import java.util.ArrayList;
import java.util.List;
import java.util.Stack;public class PolandNotation {public static void main(String[] args) {// 完成将一个中缀表达式转成后缀表达式的功能// 说明// 1.将 "1+((2+3)*4)-5" 转成 "1 2 3 + 4 * + 5 -"// 2.先将 "1+((2+3)*4)-5" -->中缀表达式对应的List// 即 "1+((2+3)*4)-5"-->ArrayList[1,+,(,(,2,+,3,),*,4,),-,5]String expression = "1+((2+3)*4)-5";List<String> infixExpressionList = toInfixExpressionList(expression);System.out.println(infixExpressionList);System.out.println("中缀表达式对应的List" + infixExpressionList);// 3.中缀表达式对应的List --> 后缀表达式对应的List// 即将ArrayList[1,+,(,(,2,+,3,),*,4,),-,5] --> ArrayList[1,2,3,+,4,*,5,-]List<String> suffixExpressionList = parseSuffixExpressionList(infixExpressionList);System.out.println("后缀表达式对应的List" + suffixExpressionList);System.out.printf("expression = %d", calculate(suffixExpressionList));}// 方法:中缀表达式对应的List --> 后缀表达式对应的Listpublic static List<String> parseSuffixExpressionList(List<String> ls) {// 定义两个栈Stack<String> s1 = new Stack<String>();// 符号栈// 说明:因为s2这个栈,再整个转换过程中,没有pop操作,而且后面我们还需要逆序输出// 此方法比较麻烦,这里就不用Stack<String>,直接使用List<String> s2// Stack<String> s2 = new Stack<String>();//存储中间结果的栈s2List<String> s2 = new ArrayList<String>();// 存储中间结果的List2// 遍历lsfor (String item : ls) {// 如果是一个数,加入s2if (item.matches("\\d+")) {s2.add(item);} else if (item.equals("(")) {s1.push(item);} else if (item.equals(")")) {// 如果是")",则依次弹出s1栈顶的运算符,并压入s2,直到遇到左括号为止,此时将这一对括号丢弃while (!s1.peek().equals("(")) {s2.add(s1.pop());}s1.pop();// 将"("弹出s1,消除小括号} else {// 当item的优先级小于s1栈顶运算符,将s1栈顶的运算符弹出并加入到s2中,再次转到(4.1)与s1中新的栈顶运算符相比较// 问题:需要一个比较优先级高低的方法while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {s2.add(s1.pop());}// 将item压入s1.push(item);}}// 将s1中剩余的运算符依次弹出并加入s2while (s1.size() != 0) {s2.add(s1.pop());}return s2;// 因为是存放到List,因此按顺序输出就是对应的后缀表达式}// 方法:将中缀表达式转成对应的Listpublic static List<String> toInfixExpressionList(String s) {// 定义一个List,存放中缀表达式 对应内容List<String> ls = new ArrayList<String>();int i = 0;// 这是一个指针,用于遍历中缀表达式字符串String str;// 对多位数的拼接char c;// 每遍历到一个字符,就放入到cdo {// 如果c是一个非数字,需要加入到lsif ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {ls.add("" + c);i++;// i需要后移} else {// 如果是一个数,需要考虑多位数str = "";// 先将str置成"";while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {str += c;// 拼接i++;}ls.add(str);}} while (i < s.length());return ls;}// 将一个逆波兰表达式,依次将数据和运算符放入到ArrayList中public static List<String> getListString(String suffixExpression) {// 将suffixExpression分割String[] split = suffixExpression.split(" ");List<String> list = new ArrayList<String>();for (String ele : split) {list.add(ele);}return list;}// 完成对逆波兰表达式的运算/*** 1.从左至右扫描,将3和4压入堆栈;* 2.到 + 运算符,因此弹出 4 和 3(4 为栈顶元素,3 为次顶元素),计算出 3 + 4 的值,得 7 ,再将 7 入栈;* 3.将 5 入栈;* 4.接下来是 × 运算符,因此弹出 5 和 7 ,计算出 7 × 5 = 35 ,将 35 入栈;* 5.将 6 入栈;* 6.最后是-运算符,计算出 35 - 6 的值,即 29 ,由此得出最终结果*/public static int calculate(List<String> ls) {// 创建一个栈,只需要一个即可Stack<String> stack = new Stack<String>();// 遍历 lsfor (String item : ls) {// 这里使用正则表达式来取出数if (item.matches("\\d+")) {// 匹配的是多位数// 入栈stack.push(item);} else {// pop出两个数,并运算int num2 = Integer.parseInt(stack.pop());// 先pop出的数int num1 = Integer.parseInt(stack.pop());// 后pop出的数int res = 0;if (item.equals("+")) {res = num1 + num2;} else if (item.equals("-")) {res = num1 - num2;} else if (item.equals("*")) {res = num1 * num2;} else if (item.equals("/")) {res = num1 / num2;} else {throw new RuntimeException("运算符有误");}// 把res入栈stack.push("" + res);}}// 最后留在stack中的数据就是运算结果return Integer.parseInt(stack.pop());}}// 编写一个类Operation,可以返回一个运算符对应的优先级
class Operation {private static int ADD = 1;private static int SUB = 2;private static int MUL = 3;private static int DIV = 4;// 写一个方法,返回对应的优先级数字public static int getValue(String operation) {int result = 0;switch (operation) {case "+":result = ADD;case "-":result = SUB;case "*":result = MUL;case "/":result = DIV;break;default:System.out.println("不存在该运算符");break;}return result;}
}

运行结果:

在这里插入图片描述

5. 逆波兰计算器的完整版

完整版的逆波兰计算器,功能包括:
    ①支持 + - * / ( )
    ②多位数,支持小数,
    ③兼容处理, 过滤任何空白字符,包括空格、制表符、换页符

逆波兰计算器完整版考虑的因素较多,但基本思路和前面一样,也是使用到:中缀表达式转后缀表达式。

代码实现:

package stack;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;
import java.util.regex.Pattern;public class ReversePolishMultiCalc {/*** 匹配 + - * / ( ) 运算符*/static final String SYMBOL = "\\+|-|\\*|/|\\(|\\)";static final String LEFT = "(";static final String RIGHT = ")";static final String ADD = "+";static final String MINUS = "-";static final String TIMES = "*";static final String DIVISION = "/";/*** 加減 + -*/static final int LEVEL_01 = 1;/*** 乘除 * /*/static final int LEVEL_02 = 2;/*** 括号*/static final int LEVEL_HIGH = Integer.MAX_VALUE;static Stack<String> stack = new Stack<>();static List<String> data = Collections.synchronizedList(new ArrayList<String>());/*** 去除所有空白符* * @param s* @return*/public static String replaceAllBlank(String s) {// \\s+ 匹配任何空白字符,包括空格、制表符、换页符等等, 等价于[ \f\n\r\t\v]return s.replaceAll("\\s+", "");}/*** 判断是不是数字 int double long float* * @param s* @return*/public static boolean isNumber(String s) {Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");return pattern.matcher(s).matches();}/*** 判断是不是运算符* * @param s* @return*/public static boolean isSymbol(String s) {return s.matches(SYMBOL);}/*** 匹配运算等级* * @param s* @return*/public static int calcLevel(String s) {if ("+".equals(s) || "-".equals(s)) {return LEVEL_01;} else if ("*".equals(s) || "/".equals(s)) {return LEVEL_02;}return LEVEL_HIGH;}/*** 匹配* * @param s* @throws Exception*/public static List<String> doMatch(String s) throws Exception {if (s == null || "".equals(s.trim()))throw new RuntimeException("data is empty");if (!isNumber(s.charAt(0) + ""))throw new RuntimeException("data illeagle,start not with a number");s = replaceAllBlank(s);String each;int start = 0;for (int i = 0; i < s.length(); i++) {if (isSymbol(s.charAt(i) + "")) {each = s.charAt(i) + "";// 栈为空,(操作符,或者 操作符优先级大于栈顶优先级 && 操作符优先级不是( )的优先级 及是 ) 不能直接入栈if (stack.isEmpty() || LEFT.equals(each)|| ((calcLevel(each) > calcLevel(stack.peek())) && calcLevel(each) < LEVEL_HIGH)) {stack.push(each);} else if (!stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek())) {// 栈非空,操作符优先级小于等于栈顶优先级时出栈入列,直到栈为空,或者遇到了(,最后操作符入栈while (!stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek())) {if (calcLevel(stack.peek()) == LEVEL_HIGH) {break;}data.add(stack.pop());}stack.push(each);} else if (RIGHT.equals(each)) {// ) 操作符,依次出栈入列直到空栈或者遇到了第一个)操作符,此时)出栈while (!stack.isEmpty() && LEVEL_HIGH >= calcLevel(stack.peek())) {if (LEVEL_HIGH == calcLevel(stack.peek())) {stack.pop();break;}data.add(stack.pop());}}start = i; // 前一个运算符的位置} else if (i == s.length() - 1 || isSymbol(s.charAt(i + 1) + "")) {each = start == 0 ? s.substring(start, i + 1) : s.substring(start + 1, i + 1);if (isNumber(each)) {data.add(each);continue;}throw new RuntimeException("data not match number");}}// 如果栈里还有元素,此时元素需要依次出栈入列,可以想象栈里剩下栈顶为/,栈底为+,应该依次出栈入列,可以直接翻转整个stack 添加到队列Collections.reverse(stack);data.addAll(new ArrayList<>(stack));System.out.println(data);return data;}/*** 算出结果* * @param list* @return*/public static Double doCalc(List<String> list) {Double d = 0d;if (list == null || list.isEmpty()) {return null;}if (list.size() == 1) {System.out.println(list);d = Double.valueOf(list.get(0));return d;}ArrayList<String> list1 = new ArrayList<>();for (int i = 0; i < list.size(); i++) {list1.add(list.get(i));if (isSymbol(list.get(i))) {Double d1 = doTheMath(list.get(i - 2), list.get(i - 1), list.get(i));list1.remove(i);list1.remove(i - 1);list1.set(i - 2, d1 + "");list1.addAll(list.subList(i + 1, list.size()));break;}}doCalc(list1);return d;}/*** 运算* * @param s1* @param s2* @param symbol* @return*/public static Double doTheMath(String s1, String s2, String symbol) {Double result;switch (symbol) {case ADD:result = Double.valueOf(s1) + Double.valueOf(s2);break;case MINUS:result = Double.valueOf(s1) - Double.valueOf(s2);break;case TIMES:result = Double.valueOf(s1) * Double.valueOf(s2);break;case DIVISION:result = Double.valueOf(s1) / Double.valueOf(s2);break;default:result = null;}return result;}public static void main(String[] args) {// String math = "9+(3-1)*3+10/2";String math = "12.8 + (2 - 3.55)*4+10/5.0";try {doCalc(doMatch(math));} catch (Exception e) {e.printStackTrace();}}}

运行结果:

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/165597.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

手写数字可视化_Python数据分析与可视化

手写数字可视化 手写数字流形学习 手写数字 手写数字无论是在数据可视化还是深度学习都是一个比较实用的案例。 数据在sklearn中&#xff0c;包含近2000份8 x 8的手写数字缩略图。 首先需要先下载数据&#xff0c;然后使用plt.imshow()对一些图形进行可视化&#xff1a; 打开c…

Mysql 锁机制分析

整体业务代码精简逻辑如下&#xff1a; Transaction public void service(Integer id) {delete(id);insert(id); }数据库实例监控&#xff1a; 当时通过分析上游问题流量限流解决后&#xff0c;后续找时间又重新分析了下问题发生的根本原因&#xff0c;现将其总结如下&#xf…

XDR 网络安全:技术和最佳实践

扩展检测和响应&#xff08;XDR&#xff09;是一种安全方法&#xff0c;它将多种保护工具集成到一个统一的集成解决方案中。它为组织提供了跨网络、端点、云工作负载和用户的广泛可见性&#xff0c;从而实现更快的威胁检测和响应。 XDR的目标是提高威胁检测的速度和准确性&…

Arduino驱动防水型SHT20温湿传感器(温湿度传感器)

目录 1、传感器特性 2、控制器和传感器连线图 3、驱动程序 SHT20防水型温湿传感器,采用新一代Sensirion湿度和温度传感器,配有4代CMOSens芯片。除了配有电容式相对湿度传感器和能隙温度传感器外,该芯片还包含一个放大器、A/D转换器、OTP内存和数字处理单元,可精确测量周…

Linux系统介绍及文件类型和权限

终端:CtrlAltT 或者桌面/文件夹右键,打开终端 切换为管理员:sudo su 退出:exit 查看内核版本号:uname -a 内核版本号含义:5 代表主版本号;13代表次版本号;0代表修订版本号;30代表修订版本的第几次微调;数字越大表示内核越新. 目录结构 /bin:存放常用命令(即二进制可执行程序…

C/C++内存管理(2):`new`和`delete`的实现原理

new和delete操作自定义类型 class Stack { public:Stack(int capacity 3):_top(0), _capacity(capacity){cout << "Stack(int capacity 3)" << endl;_a new int[capacity];}~Stack(){cout << "~Stack()" << endl;delete _a;_to…

openssl+ RSA + linux 签名开发实例(C++)

文章目录 一、opensslRSA理论基础二、openssl RSA 签名开发实例 一、opensslRSA理论基础 RSA签名是一种非对称加密算法&#xff0c;用于在信息传输过程中验证消息的完整性和真实性。以下是RSA签名的理论基础的主要知识点&#xff1a; RSA密钥对&#xff1a; RSA使用一对公钥和…

pcie-2-rj45速度优化

背景: 目前用iperf3打流传输速率达不到要求,千兆实际要求跑到800M以上: 优化方案: 1.优化defconfig: 首先编译user版本验证看是否正常 debug版本关闭CONFIG_SLUB_DEBUG_ON宏控。 2.找FAE ,通过更换驱动,或者更新驱动来优化 3.绑定大核: 以8125网卡为例,udp…

【Unity】IBeginDragHandler、IDragHandler 和 IEndDragHandler 介绍

IBeginDragHandler、IDragHandler 和 IEndDragHandler 介绍 IBeginDragHandler、IDragHandler 和 IEndDragHandler 是 Unity 引擎中的三个接口&#xff0c;用于处理 UI 元素的拖放事件。这些接口通常结合使用&#xff0c;构成了 Unity 引擎的拖放事件系统。 IBeginDragHandler…

java--权限修饰符

1.什么是权限修饰符 就是是用来限制类中的成员(成员变量、成员方法、构造器、代码块...)能够被访问的范围。 2.权限修饰符有几种&#xff1f;各自的作用是什么&#xff1f; private<缺省<protected<public(范围由小到大)

什么年代了,还不会 CI/CD 么?

目录 什么是 CI/CD&#xff1f; CI/CD 对业务有哪些好处&#xff1f; 一&#xff1a;确保卓越的代码质量 二&#xff1a;更快的发布速度 → 更快的交付 三&#xff1a;自动化降低成本 四&#xff1a;故障隔离 五&#xff1a;简化回滚 六&#xff1a;持续反馈 七&#…

设计模式——行为型模式(二)

6.8 迭代器模式 6.8.1 概述 定义:提供一个对象来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。 6.8.2 结构 迭代器模式主要包含以下角色: 抽象聚合(Aggregate)角色:定义存储、添加、删除聚合元素以及创建迭代器对象的接口。具体聚合(ConcreteAggreg…

C# Onnx PP-Vehicle 车辆分析(包含:车辆检测,识别车型和车辆颜色)

目录 效果 模型信息 mot_ppyoloe_s_36e_ppvehicle.onnx vehicle_attribute_model.onnx 项目 代码 下载 其他 C# Onnx PP-Vehicle 车辆分析&#xff08;包含&#xff1a;车辆检测&#xff0c;识别车型和车辆颜色&#xff09; 效果 模型信息 mot_ppyoloe_s_36e_ppvehi…

009 OpenCV 二值化 threshold

一、环境 本文使用环境为&#xff1a; Windows10Python 3.9.17opencv-python 4.8.0.74 二、二值化算法 2.1、概述 在机器视觉应用中&#xff0c;OpenCV的二值化函数threshold具有不可忽视的作用。主要的功能是将一幅灰度图进行二值化处理&#xff0c;以此大幅降低图像的数…

ASP.NET Core 启用CORS

浏览器的安全阻止一个域的本地页面请求另外不同域的本地页面&#xff0c;这个限制叫同源策略&#xff0c;这个安全特性用来阻止恶意站点从别的网站读取数据 例如假如我有一个页面叫A.html https://foo.example/A.html 现在页面A.html有一个ajax代码尝试读取B.html的HTML的源…

【PyQt】(自定义类)阴影遮罩

写了一个感觉有些用的小玩具。 用于给控件添加阴影遮罩(强调主控件的同时屏蔽其余控件的点击) 自定义阴影遮罩Mask&#xff1a; from PyQt5.QtCore import QPoint,QRect,Qt,QPoint,QSize from PyQt5.QtWidgets import QWidget,QLabel,QPushButton,QVBoxLayout from PyQt5.QtGu…

leetcode:合并两个有序链表

题目描述 题目链接&#xff1a;21. 合并两个有序链表 - 力扣&#xff08;LeetCode&#xff09; 题目分析 这个算法思路很简单&#xff1a;就是直接找小尾插 定义一个tail和head&#xff0c;对比两个链表结点的val&#xff0c;小的尾插到tail->next&#xff0c;如果一个链表…

每日一题:LeetCode-589.N叉树的前序遍历序列构造二叉树

每日一题系列&#xff08;day 01&#xff09; 前言&#xff1a; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f308; &#x1f50e…

企业微信身份验证

本篇主要是在上一篇获取第三方凭证基础上&#xff0c;用户通过三方网站自定义授权登录后获取用户信息&#xff0c;以实现用户绑定登录功能。 构造第三方应用授权链接 如果第三方应用需要在打开的网页里面携带用户的身份信息&#xff0c; 第一步需要构造如下的链接来获取授权c…

马养殖场建设VR模拟实训教学平台具有灵活性和复用性

为保障养殖场生物安全&#xff0c;避免疫病传播&#xff0c;学生出入养殖场受时间和地域的限制&#xff0c; 生产实习多以参观为主&#xff0c;通过畜牧企业技术人员的讲解&#xff0c;学生被动了解生产过程。为了解决畜牧养殖实训难的问题&#xff0c;借助VR技术开展畜牧养殖虚…