表达式求值重点问题探讨
先从一个无比经典的问题谈起，
一、24点问题
*你有 4 张写有 1 到 9 数字的牌。你需要判断是否能通过 *，/，+，-，(，) 的运算得到 24。
output：true/false
Method:
递归执行：
（1）4选2，执行+、-、*、/之一，变为三个数字 //有4选2 有6种选法，即共4*6种情况
（2）3选2，执行+、-、*、/之一，变为二个数字
（3）2选2，执行+、-、*、/之一，变为一个数字
判断是否为24
剪枝：
（1）除法分母不为0
（2）+、*满足交换律 即上述递归执行（1）只有2*6+2*6/2 = 18种解法
代码实现
class Solution {
public boolean judgePoint24(int[] nums) {
ArrayList A = new ArrayList<Double>();
for (int v: nums) A.add((double) v);
return partition(A);
}
public boolean partition(ArrayList<Double> nums) {
if (nums.size() == 0) {
return false;
}
if (nums.size() == 1) {
return Math.abs(nums.get(0) - 24) < 1e-6;
}
for (int i = 0; i < nums.size(); i++) {
for (int j = 0; j < nums.size(); j++) {
// 选择其中任意两个进行运算
//保证这两个不相等
if (i != j) {
ArrayList<Double> nums2 = new ArrayList<>();
//对非被选中的，直接加入
for (int k = 0; k < nums.size(); k++) {
if (k != i && k!=j) {
nums2.add(nums2.get(k));
}
}
//对被选中的运算
for (int k = 0; k < 4; k++) {
if (k < 2 && j > i) {
continue;
} else if (k == 0) {
nums2.add(nums.get(i) + nums.get(j));
} else if (k == 1) {
nums2.add(nums.get(i) * nums.get(j));
} else if (k == 2) {
nums2.add(nums.get(i) - nums.get(j));
} else if (k == 3 && nums.get(j) != 0) {
nums2.add(nums.get(i) / nums.get(j));
} else {
continue;
}
if (partition(nums2)) {
return true;
}
//回退
nums2.remove(nums2.size() - 1);
}
}
}
}
return false;
}
}变形
在这里，想做个小变形，给大家感受一下，
output改成：输出所有满足要求的表达式
其实，只需要少量修改代码，即可完成。
在这里，给出代码解答
class Solution {
public List<String> judgePoint24(int[] nums) {
ArrayList A = new ArrayList<Double>();
List<String> result = new ArrayList<>();
List<String> nowRes = new ArrayList<>();
for (int v: nums) {
A.add((double) v);
nowRes.add(String.valueOf(v));
}
partition(A, nowRes, result);
return result;
}
public void partition(ArrayList<Double> nums, List<String> nowRes, List<String> result) {
if (nums.size() == 0) {
return;
}
if (nums.size() == 1) {
if (Math.abs(nums.get(0) - 24) < 1e-6) {
result.add(nowRes.get(0));
}
}
for (int i = 0; i < nums.size(); i++) {
for (int j = 0; j < nums.size(); j++) {
// 选择其中任意两个进行运算
//保证这两个不相等
if (i != j) {
ArrayList<Double> nums2 = new ArrayList<>();
ArrayList<String> nowRes2 = new ArrayList<>();
//对非被选中的，直接加入
for (int k = 0; k < nums.size(); k++) {
if (k != i && k!=j) {
nums2.add(nums.get(k));
nowRes2.add(nowRes.get(k));
}
}
//对被选中的运算
for (int k = 0; k < 4; k++) {
if (k < 2 && j > i) {
continue;
} else if (k == 0) {
nums2.add(nums.get(i) + nums.get(j));
nowRes2.add(
'(' + nowRes.get(i) + '+' + nowRes.get(j) + ')');
partition(nums2, nowRes2, result);
nums2.remove(nums2.size() - 1);
nowRes2.remove(nowRes2.size() - 1);
} else if (k == 1) {
nums2.add(nums.get(i) * nums.get(j));
nowRes2.add(
"" + nowRes.get(i) + '*' + nowRes.get(j) + "");
partition(nums2, nowRes2, result);
nums2.remove(nums2.size() - 1);
nowRes2.remove(nowRes2.size() - 1);
} else if (k == 2) {
nums2.add(nums.get(i) - nums.get(j));
nowRes2.add(
'(' + nowRes.get(i) + '-' + nowRes.get(j) + ')');
partition(nums2, nowRes2, result);
nums2.remove(nums2.size() - 1);
nowRes2.remove(nowRes2.size() - 1);
} else if (k == 3 && nums.get(j) != 0) {
nums2.add(nums.get(i) / nums.get(j));
nowRes2.add(
"" + nowRes.get(i) + '/' + nowRes.get(j) + "");
partition(nums2, nowRes2, result);
nums2.remove(nums2.size() - 1);
nowRes2.remove(nowRes2.size() - 1);
} else {
continue;
}
}
}
}
}
return;
}
}二、经典表达式求值
在这里不得不谈一些最经典、最基础的问题，在这里将从无括号四则运算、逆波兰式、栈、递归下降来做一个全面的讲解。
逆波兰算法：
核心思想是将普通的中缀表达式转换为后缀表达式。（关于表达式的理解可以去查询DS中关于二叉树的遍历的描述，这里不再赘述）
后缀表达式：运算符在两个操作数的后面。后缀表达式虽然看起来奇怪，不利于人阅读，但利于计算机处理。
1、后缀表达式（逆波兰式）求值
比较简单，直接上伪代码：
function suffixToResult：
for each element in suffix_expression
{
if(element is number)
{
stack.push(element)
}
else if(element is operator)
{
num1 = stack.pop()
num2 = stack.pop()
value = num1 + element + num2
stack.push(value)
}
return stack.pop()
}
}
2、中缀表达式转化为后缀表达式
这是算法的难点，也是重中之重
算法思想：
设置一个stack和一个linear list
其中stack临时存放运算符和左括号的
linear list存放后缀表达式
if number : list.add(number)
if (: stack.push('(')
if ): while(stack.pop == '(')
if operator:
if stack.peek() is not operator: stack.push(operator)
else :
if operator > stack.peek(): stack.push(operator)
else while(stack.peek() <= operator) stack.pop()
算法实现
class solution {
public void getVlaue(String string) {
System.out.println(suffixToResult(infixToSuffix(string)));
}
private boolean isNumber(char character) {
return character >= '0' && character <= '9';
}
private boolean isOperator(char character) {
return !isNumber(character) && character != '(' && character != ')';
}
private int priority(char character) {
if (character == '+' || character == '-') {
return 1;
} else {
return 2;
}
}
private Integer toNumber(String expr) {
int flag = 0;
//["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
if (expr.charAt(0) == '-') {
expr = expr.substring(1);
flag = 1;
}
int number = 0;
int bit = 1;
for (int i = expr.length() - 1; i >= 0; i--) {
number = number + (expr.charAt(i) - '0') * bit;
bit *= 10;
}
if (flag == 0) {
return number;
} else {
return -1 * number;
}
}
public List<String> infixToSuffix(String expr) {
Stack<Character> stack = new Stack<>();
ArrayList<String> list = new ArrayList<>();
for (int i = 0; i < expr.length(); i++) {
if (expr.charAt(i) >= '0' && expr.charAt(i) <= '9') {
String numExpr = "";
while (i < expr.length() && isNumber(expr.charAt(i))) {
numExpr = numExpr + expr.charAt(i);
i++;
}
i--;
list.add(numExpr);
} else if (expr.charAt(i) == '(') {
stack.push(expr.charAt(i));
} else if (expr.charAt(i) == ')') {
while (!stack.isEmpty() && stack.peek() != '(') {
list.add("" + stack.pop());
}
if (!stack.isEmpty()) {
stack.pop();
}
} else {
while (!stack.isEmpty() && isOperator(stack.peek())
&& priority(stack.peek()) >= priority(expr.charAt(i))) {
//System.out.println(priority(stack.peek()));
//System.out.println(priority(expr.charAt(i)));
list.add(stack.pop() + "");
}
stack.push(expr.charAt(i));
}
//System.out.println(stack);
//System.out.println(list);
//System.out.println("-----");
}
while (!stack.isEmpty()) {
list.add(stack.pop() + "");
}
return list;
}
public int suffixToResult(List<String> list) {
//System.out.println(list);
Stack<Integer> stack = new Stack<>();
for (String element : list) {
if (isNumber(element.charAt(0)) || (element.length() > 1 && isNumber(element.charAt(1)))) {
//System.out.println(toNumber(element));
stack.push(toNumber(element));
} else {
//System.out.println(stack);
Integer num1 = stack.pop();
Integer num2 = stack.pop();
Integer value = 0;
if (element.charAt(0) == '+') {
value = num2 + num1;
} else if (element.charAt(0) == '-') {
value = num2 - num1;
} else if (element.charAt(0) == '*') {
value = num2 * num1;
} else if (element.charAt(0) == '/') {
value = num2 / num1;
}
System.out.println(num2);
System.out.println(num1);
System.out.println("***" + value);
stack.push(value);
}
}
return stack.pop();
}
}递归下降算法
递归下降是编译原理中词法分析的重要方法，而利用递归下降进行表达式求值，也是一个强烈推荐的手段！！！思考简单！！逻辑清晰！！！
核心思想
递归下降分析来求表达式的值。表达式的文法如下
expr = term {+、-} term
term = factor {*、/} factor
factor = (expr) or number
其实原理就这么简单，层层递归即可
代码实现
直接上代码，一看就知
class Solution {
int cur = 0;
String str = "";
public double cal(String s) {
this.str = s;
return expression();
}
public double expression() {
double num1 = term();
double num2;
while (cur < str.length() && (str.charAt(cur) == '+' || str.charAt(cur) == '-')) {
char op = str.charAt(cur);
cur++;
num2 = term();
if (op == '+') {
num1 += num2;
} else {
num1 -= num2;
}
}
if (cur < str.length() && str.charAt(cur) == ')') {
cur++;
}
return num1;
}
public double term() {
double num1 = factor();
double num2;
while (cur < str.length() && (str.charAt(cur) == '*' || str.charAt(cur) == '/')) {
char op = str.charAt(cur);
cur++;
num2 = factor();
if (op == '*') {
num1 *= num2;
} else {
num1 /= num2;
}
}
return num1;
}
public double factor() {
double result;
if (str.charAt(cur) == '(') {
cur++;
return expression();
} else {
String string = "";
while (cur < str.length() && isNumber(str.charAt(cur)) ) {
string = string + str.charAt(cur);
cur++;
}
result = toNumber(string);
}
return result;
}
private boolean isNumber(char character) {
return character >= '0' && character <= '9';
}
private Integer toNumber(String expr) {
int flag = 0;
//["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
if (expr.charAt(0) == '-') {
expr = expr.substring(1);
flag = 1;
}
int number = 0;
int bit = 1;
for (int i = expr.length() - 1; i >= 0; i--) {
number = number + (expr.charAt(i) - '0') * bit;
bit *= 10;
}
if (flag == 0) {
return number;
} else {
return -1 * number;
}
}
}三、给表达式添加优先级
Given a string of numbers and operators, return all possible results from computing all the different possible ways to group numbers and operators. The valid operators are +, - and *.
Example 1:
Input: “2-1-1”
Output: [0, 2]
扫一扫
826
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
