Question

我在接受采访时被问到这个问题。我用天真的方法开始我的答案，找到所有的子树并检查它们中的任何一个是否是bst。在此过程中，我们将记录到目前为止看到的最大bst的大小。

有比这更好的方法吗？

Answer 1

如果你这样做怎么办：

反转图表的权重
以这种方式使用Kruskal算法。

一个。从边缘集中选择最低的边缘。

湾仅在添加该边缘并未破坏bst约束时才创建树。

℃。从边缘集中移除该边缘。

你最终可能会得到几棵树（因为当不满足bst约束时丢弃边缘可能会让你断开你的原始图形），所以只需选择一个有更多节点的树。

Answer 2

我认为你的解决方案是这样的：

for each subtree of the tree:
    if the subtree is a binary search tree:
        compute its size
        if it is the largest one found so far:
            best = subtree
return best

这是低效的，因为它对每个子树都有O（n）工作，并且最多有n个子树。

你只需走一遍整个树就可以做得更好。

// Walk the subtree at node. Find the largest subtree that is a binary search tree
// and return that tree in *result. Also return that subtree's size and the range
// of values it covers in *size, *min, and *max.
void
walk(Node *node, Node **result, size_t *size, Value *min, Value *max)
{
    Node *result0 = NULL;
    size_t size0 = 0;
    Value min0, max0;
    if (node->left)
        walk(node->left, &result0, &size0, &min0, &max0);

    Node *result1 = NULL;
    size_t size1 = 0;
    Value min1, max1;
    if (node->right)
        walk(node->right, &result1, &size1, &min1, &max1);

    // If both subtrees are search trees and node->value falls between them,
    // then node is a search tree.
    if (result0 == node->left
        && result1 == node->right
        && (node->left == NULL || max0 <= node->value)
        && (node->right == NULL || node->value <= min1))
    {
        *result = node;
        *size = size0 + 1 + size1;
        *min = node->left == NULL ? node->value : min0;
        *max = node->right == NULL ? node->value : max1;
    } else if (size0 >= size1) {
        *result = result0;
        *size = size0;
        *min = min0;
        *max = max0;
    } else {
        *result = result1;
        *size = size1;
        *min = min1;
        *max = max1;
    }
}

Node *
findLargestBinarySearchSubtree(Node *root)
{
    Node *result;
    size_t size;
    Value min, max;
    walk(root, &result, &size, &min, &max);
    return result;
}

Answer 3

此website似乎涵盖了以下问题：二叉搜索树检查。具体来说，这是C ++中解决方案的摘录

/*   
 Returns true if the given tree is a binary search tree 
 (efficient version). 
*/ 
int isBST2(struct node* node) { 
  return(isBSTUtil(node, INT_MIN, INT_MAX)); 
}
/* 
 Returns true if the given tree is a BST and its 
 values are >= min and <= max. 
*/ 
int isBSTUtil(struct node* node, int min, int max) { 
  if (node==NULL) return(true);

  // false if this node violates the min/max constraint 
  if (node->data<min || node->data>max) return(false);

  // otherwise check the subtrees recursively, 
  // tightening the min or max constraint 
  return 
    isBSTUtil(node->left, min, node->data) && 
    isBSTUtil(node->right, node->data+1, max) 
  ); 
}

Answer 4

我认为要解决O（n）的复杂性。

bool is_bst(node * cur)
{
   if (cur == NULL)
     return true;

   // if calculated before cur vertex.
   if (hash_set_bst[cur] != -1)
      return hash_set_bst[cur];

   int left_value = MIN;
   int right_value = MAX;
   if (cur -> left != NULL)
      left_value = cur -> left -> value;
   if (cur -> right != NULL)
      right_value = cur -> right -> value;

   if (cur -> value > left_value && cur -> value < right_value)
   {
      hash_set_bst[cur] = is_bst(cur->left) && is_bst(cur->right);
      return hash_set_bst[cur];
   }
   else
   {
      hash_set_bst[cur] = 0;
      is_bst(cur->left);
      is_bst(cur->right);
      return hash_set_bst[cur];
   }
}

现在，您知道每个节点是否可以启动BST。现在你需要计算子树大小，然后迭代throgh所有节点，并找出具有标志的最大大小，如果节点可以启动BST。

要计算尺寸，您可以执行以下操作：

int dfs(node * cur)
{
   if (cur == NULL) return 0;
   size[cur] = 1 + dfs(cur->left) + dfs(cur->right);
   return size[cur];
}

Answer 5

按顺序遍历二叉树，如果任何子树是BST，则遍历将产生升序，记录树的大小。当你点击一个断点时，递归按顺序遍历该树，使用断点作为root，记录它的大小。选择最大的一个。

给定二叉树，找到最大的子树，它是二叉搜索树

5 个答案: