满二叉树是一类二叉树，其中每个结点恰好有 0 或 2 个子结点。

返回包含 N 个结点的所有可能满二叉树的列表。 答案的每个元素都是一个可能树的根结点。

答案中每个树的每个结点都必须有 node.val=0。

你可以按任何顺序返回树的最终列表。

示例：

输入：7
输出：[[0,0,0,null,null,0,0,null,null,0,0],[0,0,0,null,null,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,null,null,null,null,0,0],[0,0,0,0,0,null,null,0,0]]
解释：

提示：

• 1 <= N <= 20

leetcode题解

这个递归代码写的很好，可以认真的学习下，注释也详细，但没有使用记忆搜索，没有超时已经很不错了，运行26ms，记忆搜索5-7ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
     public List<TreeNode> allPossibleFBT(int N) {
        List<TreeNode> list = new ArrayList<TreeNode>();
        if(N == 1)//节点数为1时，直接返回根节点
        {
            TreeNode root = new TreeNode(0);
            list.add(root);
            return list;
        }
        for(int i = 1; i < N; i+=2)
        {
            List<TreeNode> lefts = allPossibleFBT(i);//左节点数为i的所有满二叉树组合
            List<TreeNode> rights = allPossibleFBT(N - i - 1);//右节点数为N-i-1的所有满二叉树组合
            for(TreeNode l : lefts)
                for(TreeNode r : rights)
                {
                    //遍历左右子树的组合，排列出所有树
                    TreeNode root = new TreeNode(0);
                    root.left = l;
                    root.right = r;
                    list.add(root);
                }
        }

        return list;
    }

  
}

记忆搜索的代码如下，先贴自己写的，再贴官方题解

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    HashMap<Integer, List<TreeNode>> memo = new HashMap<>();
	
    public List<TreeNode> allPossibleFBT(int N) {
        if(memo.containsKey(N))
        	return memo.get(N);
        
        List<TreeNode> list = new ArrayList<>();
        if(N==1)
        	list.add(new TreeNode(0));
        else if(N%2==1) {
	        for(int x=0;x<N;x++) {
	        	int y = N - 1 - x;
	        	for(TreeNode left:allPossibleFBT(x)) {
	        		for(TreeNode right:allPossibleFBT(y)) {
	        			TreeNode node = new TreeNode(0);
	        			node.left = left;
	        			node.right = right;
	        			list.add(node);
	        		}
	        	}
	        }
        }      
        memo.put(N, list);
        
        return memo.get(N);
    }
}

class Solution {
    Map<Integer, List<TreeNode>> memo = new HashMap();

    public List<TreeNode> allPossibleFBT(int N) {
        if (!memo.containsKey(N)) {
            List<TreeNode> ans = new LinkedList();
            if (N == 1) {
                ans.add(new TreeNode(0));
            } else if (N % 2 == 1) {
                for (int x = 0; x < N; ++x) {
                    int y = N - 1 - x;
                    for (TreeNode left: allPossibleFBT(x))
                        for (TreeNode right: allPossibleFBT(y)) {
                            TreeNode bns = new TreeNode(0);
                            bns.left = left;
                            bns.right = right;
                            ans.add(bns);
                        }
                }
            }
            memo.put(N, ans);
        }

        return memo.get(N);
    }
}