[leetcode] Unique Binary Search Trees II

最新推荐文章于 2020-12-09 16:51:01 发布

转载最新推荐文章于 2020-12-09 16:51:01 发布 · 40 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/jdflyfly/p/3819345.html

本文提供了一种使用递归方法生成所有可能的唯一二叉搜索树的Java实现方案，并附带示例代码。通过枚举不同根节点来构造左右子树，最终生成包含1到n的所有唯一BST。

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

Given n, generate all structurally unique BST's (binary search trees) that store values 1...n.

For example,
Given n = 3, your program should return all 5 unique BST's shown below.

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

https://oj.leetcode.com/problems/unique-binary-search-trees-ii/

思路：要求所有的树，只能递归枚举了。

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public List<TreeNode> generateTrees(int n) {
        return generate(1, n);
    }

    private List<TreeNode> generate(int from, int to) {
        List<TreeNode> res = new ArrayList<TreeNode>();
        if (from > to) {
            res.add(null);
            return res;
        }

        List<TreeNode> left = new ArrayList<TreeNode>();
        List<TreeNode> right = new ArrayList<TreeNode>();
        for (int i = from; i <= to; i++) {
            left = generate(from, i - 1);
            right = generate(i + 1, to);

            for (int j = 0; j < left.size(); j++)
                for (int k = 0; k < right.size(); k++) {
                    TreeNode tmp = new TreeNode(i);
                    tmp.left = left.get(j);
                    tmp.right = right.get(k);
                    res.add(tmp);
                }

        }
        return res;

    }

    public static void main(String[] args) {
        System.out.println(new Solution().generateTrees(3).size());
    }

}

View Code

第三遍记录：

　　递归执行，generate(m,n)返回由m~n节点组成的树的列表，注意做右子树都有null的情况。

　　对于一个节点来看，首先先确定顶点，然后顶点的左右子树分别递归生成树集合，然后根据当前顶点，从左右子树中依次挑选一个子树组成新树。

import java.util.ArrayList;
import java.util.List;

public class Solution {

    public List<TreeNode> generateTrees(int n) {
        return generate(1, n);
    }

    private List<TreeNode> generate(int from, int to) {
        List<TreeNode> res = new ArrayList<TreeNode>();
　　　　　　//generate empty tree
        if (from > to) {
            res.add(null);
            return res;
        }
　　　　
        List<TreeNode> left = null, right = null;
　　　　　　　/enumerate root: from 'from' to 'to'
        for (int i = from; i <= to; i++) {
            left = generate(from, i - 1);
            right = generate(i + 1, to);

            for (int j = 0; j < left.size(); j++) {
                for (int k = 0; k < right.size(); k++) {
　　　　　　　　　　　　　　
                    TreeNode root = new TreeNode(i);
                    root.left = left.get(j);
                    root.right = right.get(k);
                    res.add(root);
                }
            }

        }
        return res;

    }

    public static void main(String[] args) {
        List<TreeNode> res = new Solution().generateTrees(3);
        System.out.println(res.size());
    }

}