merge-bsts-to-create-single-bst

java

python

python3

mysql

mssql

oraclesql

csharp

javascript

typescript

bash

swift

kotlin

dart

golang

ruby

scala

rust

racket

erlang

elixir

pythondata

postgresql

cangjie

Algorithms

You are given <code>n</code> BST (binary search tree) root nodes for <code>n</code> separate BSTs stored in an array <code>trees</code> (0-indexed). Each BST in <code>trees</code> has at most 3 nodes, and no two roots have the same value. In one operation, you can:

<ul>
	<li>Select two distinct indices <code>i</code> and <code>j</code> such that the value stored at one of the leaves of <code>trees[i]</code> is equal to the root value of <code>trees[j]</code>.</li>
	<li>Replace the leaf node in <code>trees[i]</code> with <code>trees[j]</code>.</li>
	<li>Remove <code>trees[j]</code> from <code>trees</code>.</li>
</ul>

Return the root of the resulting BST if it is possible to form a valid BST after performing <code>n - 1</code> operations, or <code>null</code> if it is impossible to create a valid BST.

A BST (binary search tree) is a binary tree where each node satisfies the following property:

<ul>
	<li>Every node in the node&#39;s left subtree has a value&nbsp;strictly less&nbsp;than the node&#39;s value.</li>
	<li>Every node in the node&#39;s right subtree has a value&nbsp;strictly greater&nbsp;than the node&#39;s value.</li>
</ul>

A leaf is a node that has no children.

&nbsp;
Example 1:
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/08/d1.png" style="width: 450px; height: 163px;" />
<pre>
Input: trees = [[2,1],[3,2,5],[5,4]]
Output: [3,2,5,1,null,4]
Explanation:
In the first operation, pick i=1 and j=0, and merge trees[0] into trees[1].
Delete trees[0], so trees = [[3,2,5,1],[5,4]].
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/24/diagram.png" style="width: 450px; height: 181px;" />
In the second operation, pick i=0 and j=1, and merge trees[1] into trees[0].
Delete trees[1], so trees = [[3,2,5,1,null,4]].
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/24/diagram-2.png" style="width: 220px; height: 165px;" />
The resulting tree, shown above, is a valid BST, so return its root.</pre>

Example 2:
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/08/d2.png" style="width: 450px; height: 171px;" />
<pre>
Input: trees = [[5,3,8],[3,2,6]]
Output: []
Explanation:
Pick i=0 and j=1 and merge trees[1] into trees[0].
Delete trees[1], so trees = [[5,3,8,2,6]].
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/24/diagram-3.png" style="width: 240px; height: 196px;" />
The resulting tree is shown above. This is the only valid operation that can be performed, but the resulting tree is not a valid BST, so return null.
</pre>

Example 3:
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/08/d3.png" style="width: 430px; height: 168px;" />
<pre>
Input: trees = [[5,4],[3]]
Output: []
Explanation: It is impossible to perform any operations.
</pre>

&nbsp;
Constraints:

<ul>
	<li><code>n == trees.length</code></li>
	<li><code>1 &lt;= n &lt;= 5 * 104</code></li>
	<li>The number of nodes in each tree is in the range <code>[1, 3]</code>.</li>
	<li>Each node in the input may have children but no grandchildren.</li>
	<li>No two roots of <code>trees</code> have the same value.</li>
	<li>All the trees in the input are valid BSTs.</li>
	<li><code>1 &lt;= TreeNode.val &lt;= 5 * 104</code>.</li>
</ul>

canMerge

Merge BSTs to Create Single BST

Tree

Depth-First Search

Hash Table

Binary Search

Binary Tree

给你 <code>n</code> 个 二叉搜索树的根节点 ，存储在数组 <code>trees</code> 中（下标从 0 开始），对应 <code>n</code> 棵不同的二叉搜索树。<code>trees</code> 中的每棵二叉搜索树 最多有 3 个节点 ，且不存在值相同的两个根节点。在一步操作中，将会完成下述步骤：

<ul>
	<li>选择两个 不同的 下标 <code>i</code> 和 <code>j</code> ，要求满足在&nbsp;<code>trees[i]</code> 中的某个 叶节点 的值等于&nbsp;<code>trees[j]</code> 的 根节点的值 。</li>
	<li>用&nbsp;<code>trees[j]</code> 替换 <code>trees[i]</code> 中的那个叶节点。</li>
	<li>从 <code>trees</code> 中移除 <code>trees[j]</code> 。</li>
</ul>

如果在执行 <code>n - 1</code> 次操作后，能形成一棵有效的二叉搜索树，则返回结果二叉树的 根节点 ；如果无法构造一棵有效的二叉搜索树，返回 <code>null</code> 。

二叉搜索树是一种二叉树，且树中每个节点均满足下述属性：

<ul>
	<li>任意节点的左子树中的值都 严格小于&nbsp;此节点的值。</li>
	<li>任意节点的右子树中的值都 严格大于&nbsp;此节点的值。</li>
</ul>

叶节点是不含子节点的节点。

&nbsp;

示例 1：
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/08/d1.png" />
<pre>
输入：trees = [[2,1],[3,2,5],[5,4]]
输出：[3,2,5,1,null,4]
解释：
第一步操作中，选出 i=1 和 j=0 ，并将 trees[0] 合并到 trees[1] 中。
删除 trees[0] ，trees = [[3,2,5,1],[5,4]] 。
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/24/diagram.png" />
在第二步操作中，选出 i=0 和 j=1 ，将 trees[1] 合并到 trees[0] 中。
删除 trees[1] ，trees = [[3,2,5,1,null,4]] 。
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/24/diagram-2.png" />
结果树如上图所示，为一棵有效的二叉搜索树，所以返回该树的根节点。</pre>

示例 2：
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/08/d2.png" />
<pre>
输入：trees = [[5,3,8],[3,2,6]]
输出：[]
解释：
选出 i=0 和 j=1 ，然后将 trees[1] 合并到 trees[0] 中。
删除 trees[1] ，trees = [[5,3,8,2,6]] 。
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/24/diagram-3.png" />
结果树如上图所示。仅能执行一次有效的操作，但结果树不是一棵有效的二叉搜索树，所以返回 null 。
</pre>

示例 3：
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/08/d3.png" />
<pre>
输入：trees = [[5,4],[3]]
输出：[]
解释：无法执行任何操作。
</pre>

&nbsp;

提示：

<ul>
	<li><code>n == trees.length</code></li>
	<li><code>1 &lt;= n &lt;= 5 * 104</code></li>
	<li>每棵树中节点数目在范围 <code>[1, 3]</code> 内。</li>
	<li>输入数据的每个节点可能有子节点但不存在子节点的子节点</li>
	<li><code>trees</code> 中不存在两棵树根节点值相同的情况。</li>
	<li>输入中的所有树都是 有效的二叉树搜索树 。</li>
	<li><code>1 &lt;= TreeNode.val &lt;= 5 * 104</code>.</li>
</ul>