leetcode 95. 不同的二叉搜索树 II

给定一个整数 n，生成所有由 1 ... n 为节点所组成的 二叉搜索树 。

 

题解：

1.一个整数 n

2.由 1 ... n 为节点所组成的 二叉搜索树

3.注意返回所有树节点的组合，不是个数96. 不同的二叉搜索树

4.96返回数量，该题返回所有情况

 

示例：

输入：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

 

解题思路：

• 与96. 不同的二叉搜索树一样，使用一层遍历标志以i为根节点的二叉搜索树

• 递归中计算左右子树情况，并将每个节点在递归中建立连接关系，这样返回第一层的左右子树以i为整个二叉搜索树的根节点左右进行拼接

• 这样计算出所有可能的二叉树96. 不同的二叉搜索树求不同的二叉搜索树的种类直接求size()也可得到

C/C++题解：

/** * Definition for a binary tree node.

 * struct TreeNode {

 *     int val;

 *     TreeNode *left;

 *     TreeNode *right;

 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}

 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}

 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}

 * }; */

class Solution {

public:

    vector<TreeNode*> generateTrees(int start, int end) {

        if (start > end) {  return { nullptr };}

        vector<TreeNode*> allTrees;

        // 枚举可行根节点

        for (int i = start; i <= end; i++) {//以i为根节点

            // 所有可能的左子树

            vector<TreeNode*> leftTrees = generateTrees(start, i - 1);

            // 所有可能的右子树

            vector<TreeNode*> rightTrees = generateTrees(i + 1, end);

            // 左子树*右子树，组合，包括空指针

            for (auto& left : leftTrees) {//以最后一层节点生成树节点，叶子节点左右为空向上层返回

                for (auto& right : rightTrees) {//把节点连接起来

                    TreeNode* currTree = new TreeNode(i);

                    currTree->left = left;//left为左子树

                    currTree->right = right;//right为右子树

                    allTrees.push_back(currTree); }}

        }//返回到第一层左右与i即组合成完整二叉搜索树

        return allTrees; }

    vector<TreeNode*> generateTrees(int n) {

        if (!n) {  return {}; }

        vector<TreeNode*> allTree = generateTrees(1, n);

        // int currTree = new TreeNode(allTree.size());

        return allTree; }};

Debug结果：

Java题解：

/*** Definition for a binary tree node.

 * public 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;

 *     } * } */

class Solution {

    public List<TreeNode> generateTrees(int start, int end) {

        List<TreeNode> allTrees = new ArrayList<TreeNode>();

        if (start > end) {

            allTrees.add(null);

            return allTrees; }

        // 枚举可行根节点

        for (int i = start; i <= end; i++) {//以i为根节点

            // 所有可能的左子树

            List<TreeNode> leftTrees = generateTrees(start, i - 1);

            // 所有可能的右子树

            List<TreeNode> rightTrees = generateTrees(i + 1, end);

            // 左子树*右子树，组合，包括空指针

            for (TreeNode left : leftTrees) {//以最后一层节点生成树节点，叶子节点左右为空向上层返回

                for (TreeNode right : rightTrees) {//把节点连接起来

                    TreeNode currTree = new TreeNode(i);

                    currTree.left = left;//left为左子树

                    currTree.right = right;//right为右子树

                    allTrees.add(currTree);}}

        }//返回到第一层左右与i即组合成完整二叉搜索树

        return allTrees;}

    public List<TreeNode> generateTrees(int n) {

        if (n == 0) {return new ArrayList<>();  }

        List<TreeNode> allTree = generateTrees(1, n);

        // int currTree = new TreeNode(allTree.size());

        return allTree;}}

Debug结果：

Python题解：

# Definition for a binary tree node.

# class TreeNode(object):

#     def __init__(self, val=0, left=None, right=None):

#         self.val = val

#         self.left = left

#         self.right = right

class Solution(object):

    def generateTrees(self, n):

        """:type n: int:rtype: List[TreeNode] """

        def generateTrees(start, end):

            if (start > end):

                return [None,]

            allTrees = []

            # 枚举可行根节点

            for i in range(start, end+1): #以i为根节点

                # 所有可能的左子树

                leftTrees = generateTrees(start, i - 1)

                # 所有可能的右子树

                rightTrees = generateTrees(i + 1, end)

                # 左子树*右子树，组合，包括空指针

                for left in leftTrees :#以最后一层节点生成树节点，叶子节点左右为空向上层返回

                    for right in rightTrees: #把节点连接起来

                        currTree = TreeNode(i)

                        currTree.left = left #left为左子树

                        currTree.right = right #right为右子树

                        allTrees.append(currTree)

            #返回到第一层左右与i即组合成完整二叉搜索树

            return allTrees

        # if n == 0: return []

        # allTree = generateTrees(1, n)

        # currTree = len(allTree) 种类数

        return generateTrees(1, n) 

Debug结果：

更多题解移步公众号免费获取