95. Unique Binary Search Trees II

最新推荐文章于 2022-01-13 04:43:51 发布

zeroQiaoba

最新推荐文章于 2022-01-13 04:43:51 发布

阅读量229

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode

本文链接：https://blog.youkuaiyun.com/zeroQiaoba/article/details/62088665

leetcode 专栏收录该内容

429 篇文章

订阅专栏

本文介绍了一种使用递归方法生成所有可能的不同形态二叉搜索树的算法，并通过返回一系列二叉树节点指针的方式实现了这一过程。讨论了如何克服树存储上的挑战，并提供了一个具体的实现案例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这是最开始的想法，可以建树，但是树建的不全。。。。==

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:

    //depth=1;
    TreeNode* buildTree(int left,int right,int depth,vector<TreeNode*> result)
    {
        if(left>right)
            return NULL;
        else if(left==right)
        {
            TreeNode* root=new TreeNode(left);
            return root;
        }
        else
        {
            for(int i=left;i<=right;i++)
            {
                TreeNode* root=new TreeNode(i);
                root->left=buildTree(left,i-1,depth+1,result);
                root->right=buildTree(i+1,right,depth+1,result);
                if(depth==1)
                    result.push_back(root);
                else
                    return root;
            }
            if(depth==1)
                return NULL;
        }
    }


    vector<TreeNode*> generateTrees(int n) {

        vector<TreeNode*> result;
        buildTree(1,n,1,result);

        return result;
    }
};

艰难AC了，可怕，还是卡在树的存储上，尝试了各种方法，最终还是采用了返回vector类型的TreeNode 指针，而不是单一TreeNode指针的方法。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:

    //depth=1;
    vector<TreeNode*> buildTree(int left,int right)
    {
        if(left>right)
        {
            vector<TreeNode*> result;
            TreeNode* root=NULL;
            result.push_back(root);
            return result;
        }
        else if(left==right)
        {
            vector<TreeNode*> result;
            TreeNode* root=new TreeNode(left);
            result.push_back(root);
            return result;
        }
        else
        {
            vector<TreeNode*> result;
            for(int rootVal=left;rootVal<=right;rootVal++)
            {
                vector<TreeNode*> rootLeft=buildTree(left,rootVal-1);
                vector<TreeNode*> rootRight=buildTree(rootVal+1,right);

                for(int i=0;i<rootLeft.size();i++)
                {
                    for(int j=0;j<rootRight.size();j++)
                    {
                        TreeNode* root=new TreeNode(rootVal);
                        root->left=rootLeft[i];
                        root->right=rootRight[j];
                        result.push_back(root);
                    }
                }
            }
            return result;
        }
    }


    vector<TreeNode*> generateTrees(int n) {

        if(n==0)
        {
            vector<TreeNode*> result;
            return result;
        }

        return buildTree(1,n);
    }
};