1.给表达式加括弧（设计优先级）
给定一个含有数字和运算符的字符串，为表达式添加括号，改变其运算优先级以求出不同的结果。你需要给出所有可能的组合的结果。有效的运算符号包含 +, - 以及 * 。
示例 1:
输入: "2-1-1"
输出: [0, 2]
解释:
((2-1)-1) = 0
(2-(1-1)) = 2
示例 2:
输入: "2*3-4*5"
输出: [-34, -14, -10, -10, 10]
解释:
(2*(3-(4*5))) = -34
((2*3)-(4*5)) = -14
((2*(3-4))*5) = -10
(2*((3-4)*5)) = -10
(((2*3)-4)*5) = 10
解题思想：遇到运算符将表达式分为两部分，即运算符（+ - *）左边部分和右边部分，每部分的计算结果存储于List中，根据运算符（+-*）循环计算当前表达式最终结果。 对于存储于List中左右两部分的计算结果递归进行运算。
以 2 * 3 - 4 * 5 为例。
2 和 3 - 4 * 5 两部分，中间是 * 号相连。
2 * 3 和 4 * 5 两部分，中间是 - 号相连。
2 * 3 - 4 和 5 两部分，中间是 * 号相连。
有了两部分的结果，然后再通过中间的符号两两计算加入到最终的结果中即可。
比如第一种情况，2 和 3 - 4 * 5 两部分，中间是 * 号相连。
2 的解就是 [2]，3 - 4 * 5 的解就是 [-5, -17]。
把两部分解通过 * 号计算，最终结果就是 [-10, -34]。
另外两种情况也类似。
然后还需要递归出口。
如果给定的字符串只有数字，没有运算符，那结果就是给定的字符串转为数字。
比如上边的第一种情况，2 的解就是 [2]。
JAVA代码如下：
class Solution {
//解决思路：递归解法
// 遇到运算符将表达式分为两部分，即运算符（+ - *）左边部分和右边部分，对于每部分的结果再递归进行运算，每部分的计算结果存储与List中
public List<Integer> diffWaysToCompute(String input) {
List<Integer> ways = new ArrayList<>();
int len=input.length();
for(int i=0;i<len;i++){
char ch=input.charAt(i);
//如果当前字符是运算符，则将表达式分为两部分分别计算表达式左边的结果和右边的结果
if(ch=='+'||ch=='-'||ch=='*'){
List<Integer> left=diffWaysToCompute(input.substring(0,i));//subString()函数[0,i)左闭右开
List<Integer> right=diffWaysToCompute(input.substring(i+1));//从i+1到最后
for(int l:left){
for(int r:right){
if(ch=='+'){
ways.add(l+r);
}else if(ch=='-'){
ways.add(l-r);
}else{
ways.add(l*r);
}
}
}
}
}
//当传入的input表达式中没有运算符，
if(ways.size()==0)
ways.add(Integer.valueOf(input));
return ways;
}
}
2.构建不同的二叉搜索树
给定一个整数 n，生成所有由 1 ... n 为节点所组成的 二叉搜索树 。
示例：
输入：3
输出：
[
[1,null,3,2],
[3,2,null,1],
[3,1,null,null,2],
[2,1,3],
[1,null,2,null,3]
]
解释：
以上的输出对应以下 5 种不同结构的二叉搜索树：
1 3 3 2 1
\ / / / \ \
3 2 1 1 3 2
/ / \ \
2 1 2 3
提示：
0 <= n <= 8
解题思想：根据二叉搜索树的性质，根的左树所有的节点的value值小于根的value值，根的右子树所有节点的value值大于根的value值。根据传入的参数n，依次遍历n作为root，小于n的部分作为左子树节点递归构建左子树，大于n的部分做为右子树节点递归构建右子树，构建的左右子树均保存在List<TreeNode>中，最后根据构建的不同左右子树进行拼接。
JAVA代码：
import java.util.ArrayList;
import java.util.List;
/**
* Created by 高先森 on 2020/7/1.
*/
class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode() {}
TreeNode(int val) { this.val = val; }
TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
}
public class leetcode_95_biSearchTree {
public static void main(String[] args){
System.out.println(generateTrees(3));
}
public static List<TreeNode> generateTrees(int n) {
if(n<=0)
return new ArrayList<TreeNode>();
else
return createTree(1,n);
}
public static List<TreeNode> createTree(int begin,int end) {
List<TreeNode> resList=new ArrayList();
//1.递归出口正确的处理
if(begin>end) {
resList.add(null);
return resList;
}
// 错误处理
// if(begin>end)
// return new ArrayList<>();//返回一个空的ArrayList，无法提取空子树（null）
//2.构建二叉搜索树
for(int i=begin;i<=end;i++){
//2.1.建立根节点
TreeNode root;//此处如果直接是TreeNode root=new TreeNode(i)；则每次修改左右子树都是在同一个根上做变动，添加后面的树，之前保存的树也会变动
//2.2.递归构建左右子树
for(TreeNode treeNode_left:createTree(begin,i-1)){
for(TreeNode treeNode_right:createTree(i+1,end)){
root=new TreeNode(i);//必须每次新开辟一个根节点
root.left=treeNode_left;//构建左子树
root.right=treeNode_right;//构建右子树
resList.add(root);
}
}
}
return resList;
}
}