leetcode - 95.Unique Binary Search Trees II

最新推荐文章于 2020-05-02 11:30:10 发布

xiedacon

最新推荐文章于 2020-05-02 11:30:10 发布

阅读量305

点赞数

分类专栏： leetcode题集文章标签： leetcode

本文链接：https://blog.csdn.net/qq_27350929/article/details/63262356

版权

leetcode题集专栏收录该内容

96 篇文章 0 订阅

订阅专栏

Unique Binary Search Trees II

Given an integer 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

Solution1:

better

  public List<TreeNode> generateTrees(int n) {
    if (n == 0)
      return new ArrayList<>();
    return generateTrees(1, n);
  }

  private List<TreeNode> generateTrees(int begin, int end) {
    List<TreeNode> tree = new ArrayList<>();
    if (begin > end) {
      tree.add(null);
      return tree;
    }
    if (begin == end) {
      tree.add(new TreeNode(begin));
      return tree;
    }

    List<TreeNode> left, right;
    for (int i = begin; i <= end; i++) {
      left = generateTrees(begin, i - 1);
      right = generateTrees(i + 1, end);

      for (TreeNode lTree : left) {
        for (TreeNode rTree : right) {
          TreeNode root = new TreeNode(i);
          root.left = lTree;
          root.right = rTree;
          tree.add(root);
        }
      }
    }

    return tree;
  }

Solution2:

  public List<TreeNode> generateTrees(int n) {
      List<TreeNode>[] result = new List[n + 1];
      result[0] = new ArrayList<TreeNode>();
      if (n == 0) {
          return result[0];
      }

      result[0].add(null);
      for (int len = 1; len <= n; len++) {
          result[len] = new ArrayList<TreeNode>();
          for (int j = 0; j < len; j++) {
              for (TreeNode nodeL : result[j]) {
                  for (TreeNode nodeR : result[len - j - 1]) {
                      TreeNode node = new TreeNode(j + 1);
                      node.left = nodeL;
                      node.right = clone(nodeR, j + 1);
                      result[len].add(node);
                  }
              }
          }
      }
      return result[n];
  }

  private TreeNode clone(TreeNode n, int offset) {
      if (n == null) {
          return null;
      }
      TreeNode node = new TreeNode(n.val + offset);
      node.left = clone(n.left, offset);
      node.right = clone(n.right, offset);
      return node;
  }