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

题目来源

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

题目描述

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 n) {

    }
};

题目解析

递归

问题：如何去构造一颗平衡二叉搜索树呢？

这个问题可以转换为：

• 给定一个有序序列[1, n]，如何去构建一颗平衡二叉搜索树呢？

我们知道，构造一颗二叉树的思路基本上都是这样的：

• 先取出一个根节点，然后去递归的去构造左右子树

怎么保证得到了一个平衡二叉搜索树呢？

• 二叉搜索树应该[左边的值 < 跟 < 右边的值]
• 同时左右子树尽可能平衡（节点数尽可能相等）

所以，

• 应该选择中间的值作为根节点，这样就能满足上面的要求了

class test{
    TreeNode *helper(int start, int end){
        if(start > end){
            return NULL;
        }
        
        int mid = start + (end - start) / 2;
        TreeNode *root = new TreeNode(mid);
        root->left = helper(start, mid - 1);
        root->right = helper(mid + 1, end);
        return root;
    }
public:
    TreeNode * createBinaryTree(int n){
        return helper(1, n);
    }
};

问题：如果我们只要求得到二叉搜索树，但是不要求平衡呢？

• 也就是说，我们只需要保证二叉搜索树的特性：[左边的值 < 根节点 < 右边的值]
• 我们可以将[1, n]当做一个整体， 然后需要将其中的每一个数字都选择作为根节点，其划分开了左右两个子区间，然后分别调用递归函数，接下来要做的就是从这两个数组中每次各取一个节点，当作当前根结点的左右子结点，然后将根结点加入结果 res 数组中即可，参见代码如下：

下面代码，表示以i为根点，构造出来的二叉搜索树

class Solution {
    std::vector<TreeNode *> helper(int start, int end){
        if(start > end){
            return {};
        }
        
        std::vector<TreeNode *>res;
        for (int i = start; i <= end; ++i) {
            auto  left = helper(start, i - 1);
            auto right = helper(i + 1, end);
            for(auto a : left){
                for(auto b : right){
                    TreeNode *node = new TreeNode(i);
                    node->left = a;
                    node->right = b;
                    res.push_back(node);
                }
            }
        }
        return res;
    }
public:
    vector<TreeNode*> generateTrees(int n) {
        if (n == 0) return {};
        return helper(1, n);
    }
};

备忘录

我们可以使用记忆数组来优化，保存计算过的中间结果，从而避免重复集合。如下：

class Solution {
    std::vector<TreeNode *> helper(int start, int end,  vector<vector<vector<TreeNode*>>>& memo){
        if(start > end){
            return {};
        }
        
        // memo[i][j] 表示在区间 [i, j] 范围内可以生成的所有 BST 的根结点
        if(memo[start - 1][end - 1].empty() == false){
            return memo[start - 1][end - 1];
        }
        
        std::vector<TreeNode *>res;
        for (int i = start; i <= end; ++i) {
            auto  left = helper(start, i - 1, memo);
            auto right = helper(i + 1, end, memo);
            for(auto a : left){
                for(auto b : right){
                    TreeNode *node = new TreeNode(i);
                    node->left = a;
                    node->right = b;
                    res.push_back(node);
                }
            }
        }
        return memo[start - 1][end - 1] = res;
    }
public:
    vector<TreeNode*> generateTrees(int n) {
        if (n == 0) return {};
        vector<vector<vector<TreeNode*>>> memo(n, vector<vector<TreeNode*>>(n));
        return helper(1, n, memo);
    }
};

类似题目

题目	思路
leetcode：96. 可以生成多少种不同的二叉搜索树 Unique Binary Search Trees
leetcode：95. 生成的不同的二叉搜索树 II Unique Binary Search Trees II
leetcode：241. 为运算表达式设计优先级 Different Ways to Add Parentheses
leetcode：面试题 08.14. 布尔运算
leetcode：494.数组中添加加减运算符得到指定值的所有方法
leetcode：282. 给表达式添加运算符 Expression Add Operators
leetcode：224. 基本计算器 Basic Calculator
leetcode：301. 删除无效的括号 Remove Invalid Parentheses
leetcode：32. 最长有效括号 Longest Valid Parentheses