Recursive bi-sides solution - Unique Binary Search Trees II

It is a recursive solution that loop through the target number, and include all cases that each number smaller or equal to target can be a root, then left and right be recursive calls, respectively.

Results is construct based on the left and right results...

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; left = null; right = null; }
 * }
 */
public class Solution {
    public ArrayList<TreeNode> generateTrees(int n) {
        // if(n == 0){
        //     return new ArrayList<TreeNode>();
        // }
   
        return generateTreesOps(n, 0);
    }
   
    private ArrayList<TreeNode> generateTreesOps(int m, int base){
       
        ArrayList<TreeNode> results = new ArrayList<TreeNode>();
       
        if(m == 1){
            TreeNode res = new TreeNode(1 + base);
            results.add(res);
            return results;
        }
        if(m == 0){
            results.add(null);
            return results;
        }
       
        for (int i = 1; i <= m; i++) {
ArrayList<TreeNode> left = generateTreesOps(i - 1, base); //base
ArrayList<TreeNode> right = generateTreesOps(m - i, base + i);  //base + i
if (i > 1 && i < m) {
for (int j = 0; j < left.size(); j++) {
for (int k = 0; k < right.size(); k++) {
TreeNode root = new TreeNode(i + base); // + base
root.left = left.get(j);
root.right = right.get(k);
results.add(root);
}
}
}
if (i == 1) {
for (int k = 0; k < right.size(); k++) {
TreeNode root = new TreeNode(i + base); // + base
root.right = right.get(k);
results.add(root);
}
}
if (i == m) {
for (int k = 0; k < left.size(); k++) {
TreeNode root = new TreeNode(i + base); //+base
root.left = left.get(k);
results.add(root);
}
}
}
        return results;
    }
}