Comment valider un arbre de recherche binaire?
J'ai lu ici un exercice d'interviews appelé validation d'un arbre de recherche binaire.
Comment ça marche exactement? Que rechercherait-on pour valider un arbre de recherche binaire? J'ai écrit un arbre de recherche de base, mais je n'ai jamais entendu parler de ce concept.
En fait, c’est l’erreur que tout le monde commet dans une interview.
Leftchild doit être coché (minLimitof node, node.value)
Rightchild doit être coché (node.value, MaxLimit of node)
IsValidBST(root,-infinity,infinity);
bool IsValidBST(BinaryNode node, int MIN, int MAX)
{
if(node == null)
return true;
if(node.element > MIN
&& node.element < MAX
&& IsValidBST(node.left,MIN,node.element)
&& IsValidBST(node.right,node.element,MAX))
return true;
else
return false;
}
Une autre solution (si l'espace n'est pas une contrainte): Si le tableau est dans l'ordre trié, c'est un BST valide sinon pas.
"Valider" un arbre de recherche binaire signifie que vous vérifiez qu'il a bien tous les éléments plus petits à gauche et les éléments de grande taille à droite. Il s’agit essentiellement de vérifier si une arborescence binaire est une arborescence search binaire.
La meilleure solution que j'ai trouvée est O(n) et elle n'utilise pas d'espace supplémentaire. Il est similaire à inorder traversal mais au lieu de le stocker dans un tableau, puis de vérifier s'il est trié, nous pouvons prendre une variable statique et vérifier dans l'ordre si le tableau est trié.
static struct node *prev = NULL;
bool isBST(struct node* root)
{
// traverse the tree in inorder fashion and keep track of prev node
if (root)
{
if (!isBST(root->left))
return false;
// Allows only distinct valued nodes
if (prev != NULL && root->data <= prev->data)
return false;
prev = root;
return isBST(root->right);
}
return true;
}
Solution itérative utilisant in travers order.
bool is_bst(Node *root) {
if (!root)
return true;
std::stack<Node*> stack;
bool started = false;
Node *node = root;
int prev_val;
while(true) {
if (node) {
stack.Push(node);
node = node->left();
continue;
}
if (stack.empty())
break;
node = stack.top();
stack.pop();
/* beginning of bst check */
if(!started) {
prev_val = node->val();
started = true;
} else {
if (prev_val > node->val())
return false;
prev_val = node->val();
}
/* end of bst check */
node = node->right();
}
return true;
}
Voici ma solution à Clojure:
(defstruct BST :val :left :right)
(defn in-order [bst]
(when-let [{:keys [val, left, right]} bst]
(lazy-seq
(concat (in-order left) (list val) (in-order right)))))
(defn is-strictly-sorted? [col]
(every?
(fn [[a b]] (< a b))
(partition 2 1 col)))
(defn is-valid-BST [bst]
(is-strictly-sorted? (in-order bst)))
Étant donné que la traversée dans l'ordre d'une BST est une séquence sans diminution, nous pourrions utiliser cette propriété pour déterminer si une arborescence binaire est BST ou non. En utilisant Morris traversal et en maintenant le noeud pre, nous pourrions obtenir une solution dans la complexité O(n) time et O(1) espace. Voici mon code
public boolean isValidBST(TreeNode root) {
TreeNode pre = null, cur = root, tmp;
while(cur != null) {
if(cur.left == null) {
if(pre != null && pre.val >= cur.val)
return false;
pre = cur;
cur = cur.right;
}
else {
tmp = cur.left;
while(tmp.right != null && tmp.right != cur)
tmp = tmp.right;
if(tmp.right == null) { // left child has not been visited
tmp.right = cur;
cur = cur.left;
}
else { // left child has been visited already
tmp.right = null;
if(pre != null && pre.val >= cur.val)
return false;
pre = cur;
cur = cur.right;
}
}
}
return true;
}
Voici ma réponse en python, il a tous les cas de cas abordés et bien testés dans site hackerrank
""" Node is defined as
class node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
"""
def checkBST(root):
return checkLeftSubTree(root, root.left) and checkRightSubTree(root, root.right)
def checkLeftSubTree(root, subTree):
if not subTree:
return True
else:
return root.data > subTree.data \
and checkLeftSubTree(root, subTree.left) \
and checkLeftSubTree(root, subTree.right) \
and checkLeftSubTree(subTree, subTree.left) \
and checkRightSubTree(subTree, subTree.right)
def checkRightSubTree(root, subTree):
if not subTree:
return True
else:
return root.data < subTree.data \
and checkRightSubTree(root, subTree.left) \
and checkRightSubTree(root, subTree.right) \
and checkRightSubTree(subTree, subTree.right) \
and checkLeftSubTree(subTree, subTree.left)
bool ValidateBST(Node *pCurrentNode, int nMin = INT_MIN, int nMax = INT_MAX)
{
return
(
pCurrentNode == NULL
)
||
(
(
!pCurrentNode->pLeftNode ||
(
pCurrentNode->pLeftNode->value < pCurrentNode->value &&
pCurrentNode->pLeftNode->value < nMax &&
ValidateBST(pCurrentNode->pLeftNode, nMin, pCurrentNode->value)
)
)
&&
(
!pCurrentNode->pRightNode ||
(
pCurrentNode->pRightNode->value > pCurrentNode->value &&
pCurrentNode->pRightNode->value > nMin &&
ValidateBST(pCurrentNode->pRightNode, pCurrentNode->value, nMax)
)
)
);
}
J'ai récemment eu cette question lors d'un entretien téléphonique et je me suis débattu avec ce problème plus que je n'aurais dû. J'essayais de garder une trace des minimums et des maximums dans les nœuds enfants et je ne pouvais tout simplement pas comprendre les différents cas sous la pression d'une interview.
Après y avoir réfléchi en tombant endormi la nuit dernière, je me suis rendu compte que c’était aussi simple que de garder trace du dernier nœud que vous avez visité lors d’une traversée en ordre. En Java:
public <T extends Comparable<T>> boolean isBst(TreeNode<T> root) {
return isBst(root, null);
}
private <T extends Comparable<T>> boolean isBst(TreeNode<T> node, TreeNode<T> prev) {
if (node == null)
return true;
if (isBst(node.left, prev) && (prev == null || prev.compareTo(node) < 0 ))
return isBst(node.right, node);
return false;
}
"Il est préférable de définir d'abord un invariant. Ici, l'invariant est - deux éléments séquentiels quelconques de la BST dans le parcours dans l'ordre doivent être dans un ordre strictement croissant de leur apparence La solution peut donc consister en une simple traversée dans l’ordre, avec mémorisation du dernier nœud visité et comparaison du nœud actuel avec le dernier nœud visité avec "<" (ou ">") "
En Java et en autorisant les nœuds avec la même valeur dans l’un ou l’autre des sous-arbres:
public boolean isValid(Node node) {
return isValid(node, Integer.MIN_VALUE, Integer.MAX_VALUE);
}
private boolean isValid(Node node, int minLimit, int maxLimit) {
if (node == null)
return true;
return minLimit <= node.value && node.value <= maxLimit
&& isValid(node.left, minLimit, node.value)
&& isValid(node.right, node.value, maxLimit);
}
bool BinarySearchTree::validate() {
int minVal = -1;
int maxVal = -1;
return ValidateImpl(root, minVal, maxVal);
}
bool BinarySearchTree::ValidateImpl(Node *currRoot, int &minVal, int &maxVal)
{
int leftMin = -1;
int leftMax = -1;
int rightMin = -1;
int rightMax = -1;
if (currRoot == NULL) return true;
if (currRoot->left) {
if (currRoot->left->value < currRoot->value) {
if (!ValidateImpl(currRoot->left, leftMin, leftMax)) return false;
if (leftMax != currRoot->left->value && currRoot->value < leftMax) return false;
}
else
return false;
} else {
leftMin = leftMax = currRoot->value;
}
if (currRoot->right) {
if (currRoot->right->value > currRoot->value) {
if(!ValidateImpl(currRoot->right, rightMin, rightMax)) return false;
if (rightMin != currRoot->right->value && currRoot->value > rightMin) return false;
}
else return false;
} else {
rightMin = rightMax = currRoot->value;
}
minVal = leftMin < rightMin ? leftMin : rightMin;
maxVal = leftMax > rightMax ? leftMax : rightMax;
return true;
}
Bon mot
bool is_bst(Node *root, int from, int to) {
return (root == NULL) ? true :
root->val >= from && root->val <= to &&
is_bst(root->left, from, root->val) &&
is_bst(root->right, root->val, to);
}
Jolie longue file cependant.
La récursivité est facile mais l'approche itérative est préférable. Il existe une version itérative ci-dessus, mais elle est bien trop complexe que nécessaire. Voici la meilleure solution dans c++ que vous trouverez jamais:
Cet algorithme s'exécute dans le temps O(N) et nécessite un espace O(lgN).
struct TreeNode
{
int value;
TreeNode* left;
TreeNode* right;
};
bool isBST(TreeNode* root) {
vector<TreeNode*> stack;
TreeNode* prev = nullptr;
while (root || stack.size()) {
if (root) {
stack.Push_back(root);
root = root->left;
} else {
if (prev && stack.back()->value <= prev->value)
return false;
prev = stack.back();
root = prev->right;
stack.pop_back();
}
}
return true;
}
Voici l'implémentation Java de la validation BST, où nous parcourons l'arborescence dans l'ordre DFS et renvoie false si nous obtenons un nombre supérieur au dernier.
static class BSTValidator {
private boolean lastNumberInitialized = false;
private int lastNumber = -1;
boolean isValidBST(TreeNode node) {
if (node.left != null && !isValidBST(node.left)) return false;
// In-order visiting should never see number less than previous
// in valid BST.
if (lastNumberInitialized && (lastNumber > node.getData())) return false;
if (!lastNumberInitialized) lastNumberInitialized = true;
lastNumber = node.getData();
if (node.right != null && !isValidBST(node.right)) return false;
return true;
}
}
Solution récursive:
isBinary(root)
{
if root == null
return true
else if( root.left == NULL and root.right == NULL)
return true
else if(root.left == NULL)
if(root.right.element > root.element)
rerturn isBInary(root.right)
else if (root.left.element < root.element)
return isBinary(root.left)
else
return isBInary(root.left) and isBinary(root.right)
}
Inspiré par http://www.jiuzhang.com/solutions/validate-binary-search-tree/
Il existe deux solutions générales: traversal et divide && conquer.
public class validateBinarySearchTree {
public boolean isValidBST(TreeNode root) {
return isBSTTraversal(root) && isBSTDivideAndConquer(root);
}
// Solution 1: Traversal
// The inorder sequence of a BST is a sorted ascending list
private int lastValue = 0; // the init value of it doesn't matter.
private boolean firstNode = true;
public boolean isBSTTraversal(TreeNode root) {
if (root == null) {
return true;
}
if (!isValidBST(root.left)) {
return false;
}
// firstNode is needed because of if firstNode is Integer.MIN_VALUE,
// even if we set lastValue to Integer.MIN_VALUE, it will still return false
if (!firstNode && lastValue >= root.val) {
return false;
}
firstNode = false;
lastValue = root.val;
if (!isValidBST(root.right)) {
return false;
}
return true;
}
// Solution 2: divide && conquer
private class Result {
int min;
int max;
boolean isBST;
Result(int min, int max, boolean isBST) {
this.min = min;
this.max = max;
this.isBST = isBST;
}
}
public boolean isBSTDivideAndConquer(TreeNode root) {
return isBSTHelper(root).isBST;
}
public Result isBSTHelper(TreeNode root) {
// For leaf node's left or right
if (root == null) {
// we set min to Integer.MAX_VALUE and max to Integer.MIN_VALUE
// because of in the previous level which is the leaf level,
// we want to set the min or max to that leaf node's val (in the last return line)
return new Result(Integer.MAX_VALUE, Integer.MIN_VALUE, true);
}
Result left = isBSTHelper(root.left);
Result right = isBSTHelper(root.right);
if (!left.isBST || !right.isBST) {
return new Result(0,0, false);
}
// For non-leaf node
if (root.left != null && left.max >= root.val
&& root.right != null && right.min <= root.val) {
return new Result(0, 0, false);
}
return new Result(Math.min(left.min, root.val),
Math.max(right.max, root.val), true);
}
}
bool isBST(struct node* root)
{
static struct node *prev = NULL;
// traverse the tree in inorder fashion and keep track of prev node
if (root)
{
if (!isBST(root->left))
return false;
// Allows only distinct valued nodes
if (prev != NULL && root->data <= prev->data)
return false;
prev = root;
return isBST(root->right);
}
return true;
}
Fonctionne bien :)
Solution itérative.
private static boolean checkBst(bst node) {
Stack<bst> s = new Stack<bst>();
bst temp;
while(node!=null){
s.Push(node);
node=node.left;
}
while (!s.isEmpty()){
node = s.pop();
System.out.println(node.val);
temp = node;
if(node.right!=null){
node = node.right;
while(node!=null)
{
//Checking if the current value is lesser than the previous value and ancestor.
if(node.val < temp.val)
return false;
if(!s.isEmpty())
if(node.val>s.peek().val)
return false;
s.Push(node);
if(node!=null)
node=node.left;
}
}
}
return true;
}
Exemple d'implémentation Python. Cet exemple utilise des annotations de type. Cependant, étant donné que la classe Node s’utilise elle-même, nous devons inclure la première ligne du module:
from __future__ import annotations
Sinon, vous obtiendrez une erreur name 'Node' is not defined. Cet exemple utilise également dataclass comme exemple. Pour vérifier si c'est BST, il utilise la récursivité pour vérifier les valeurs des noeuds gauche et droit.
"""Checks if Binary Search Tree (BST) is balanced"""
from __future__ import annotations
import sys
from dataclasses import dataclass
MAX_KEY = sys.maxsize
MIN_KEY = -sys.maxsize - 1
@dataclass
class Node:
value: int
left: Node
right: Node
@property
def is_leaf(self) -> bool:
"""Check if node is a leaf"""
return not self.left and not self.right
def is_bst(node: Node, min_value: int, max_value: int) -> bool:
if node.value < min_value or max_value < node.value:
return False
Elif node.is_leaf:
return True
return is_bst(node.left, min_value, node.value) and is_bst(
node.right, node.value, max_value
)
if __== "__main__":
node5 = Node(5, None, None)
node25 = Node(25, None, None)
node40 = Node(40, None, None)
node10 = Node(10, None, None)
# balanced tree
node30 = Node(30, node25, node40)
root = Node(20, node10, node30)
print(is_bst(root, MIN_KEY, MAX_KEY))
# unbalanced tree
node30 = Node(30, node5, node40)
root = Node(20, node10, node30)
print(is_bst(root, MIN_KEY, MAX_KEY))
- La fonction
iterativevérifie itérativement si une arborescence donnée est une arborescence de recherche binaire. - La fonction
recursevérifie récursivement si une arborescence donnée est une arborescence de recherche binaire ou non. - Dans la fonction
iterative, j'utilise bfs pour vérifier BST. - Dans la fonction
recurse, j'utilise dfs pour vérifier BST. - Les deux solutions ont une complexité temporelle de
O(n) - La solution
iterativea un avantage sur la solutionrecurseet c'est la solutioniterativequi arrête tôt. - Même la fonction
recursepeut être optimisée pour un arrêt rapide par valeur d'indicateur global. - L'idée des deux solutions est que l'enfant de gauche doit être compris dans la plage de -infinity par rapport à la valeur de son nœud parent, qui est le nœud racine.
- Le bon enfant doit être compris entre + infini et la valeur de son nœud parent qui est le nœud racine
Et continuez en comparant la valeur du nœud actuel dans la plage. Si la valeur d'un nœud n'est pas dans la plage, renvoyer False
class Solution: def isValidBST(self, root): """ :type root: TreeNode :rtype: bool """ return self.iterative(root) # return self.recurse(root, float("inf"), float("-inf")) def iterative(self, root): if not root: return True level = [[root, -float("inf"), float("inf")]] while level: next_level = [] for element in level: node, min_val, max_val = element if min_val<node.val<max_val: if node.left: next_level.append([node.left, min_val, node.val]) if node.right: next_level.append([node.right, node.val, max_val]) else: return False level = next_level return True def recurse(self, root, maxi, mini): if root is None: return True if root.val < mini or root.val > maxi: return False return self.recurse(root.left, root.val-1, mini) and self.recurse(root.right, maxi, root.val+1)
Voici une solution en Java de la classe d'algorithmes de sedgewick . Vérifiez l'implémentation complète de BST ici
J'ai ajouté quelques commentaires explicatifs
private boolean isBST() {
return isBST(root, null, null);
}
private boolean isBST(Node x, Key min, Key max) {
if (x == null) return true;
// when checking right subtree min is key of x's parent
if (min != null && x.key.compareTo(min) <= 0) return false;
// when checking left subtree, max is key of x's parent
if (max != null && x.key.compareTo(max) >= 0) return false;
// check left subtree and right subtree
return isBST(x.left, min, x.key) && isBST(x.right, x.key, max);
}
J'ai écrit une solution à utiliser dans l'ordre Traversal BST et vérifier si les nœuds sont Ordre croissant pour l'espace O(1) AND time O(n). TreeNode predecessor est prev noeud. Je ne suis pas sûr que la solution soit juste ou pas. Parce que l'inorder Traversal ne peut pas définir un arbre entier.
public boolean isValidBST(TreeNode root, TreeNode predecessor) {
boolean left = true, right = true;
if (root.left != null) {
left = isValidBST(root.left, predecessor);
}
if (!left)
return false;
if (predecessor.val > root.val)
return false;
predecessor.val = root.val;
if (root.right != null) {
right = isValidBST(root.right, predecessor);
}
if (!right)
return false;
return true;
}
// using inorder traverse based Impl
bool BinarySearchTree::validate() {
int val = -1;
return ValidateImpl(root, val);
}
// inorder traverse based Impl
bool BinarySearchTree::ValidateImpl(Node *currRoot, int &val) {
if (currRoot == NULL) return true;
if (currRoot->left) {
if (currRoot->left->value > currRoot->value) return false;
if(!ValidateImpl(currRoot->left, val)) return false;
}
if (val > currRoot->value) return false;
val = currRoot->value;
if (currRoot->right) {
if (currRoot->right->value < currRoot->value) return false;
if(!ValidateImpl(currRoot->right, val)) return false;
}
return true;
}
Cela fonctionne pour les doublons.
// time O(n), space O(logn)
// pseudocode
is-bst(node, min = int.min, max = int.max):
if node == null:
return true
if node.value <= min || max < node.value:
return false
return is-bst(node.left, min, node.value)
&& is-bst(node.right, node.value, max)
Cela fonctionne même pour les valeurs int.min et int.max en utilisant les types Nullable.
// time O(n), space O(logn)
// pseudocode
is-bst(node, min = null, max = null):
if node == null:
return true
if min != null && node.value <= min
return false
if max != null && max < node.value:
return false
return is-bst(node.left, min, node.value)
&& is-bst(node.right, node.value, max)
Pour savoir si BT correspond à BST pour un type de données, vous devez utiliser l'approche ci-dessous . appelez la fonction récursive jusqu'à la fin du nœud feuille à l'aide de la commande in ordre traversal Construisez vos valeurs min et max vous-même.
L'élément d'arbre doit avoir moins de/plus grand que défini par l'opérateur.
#define MIN (FirstVal, SecondVal) ((FirstVal) < (SecondVal)) ? (FirstVal):(SecondVal)
#define MAX (FirstVal, SecondVal) ((FirstVal) > (SecondVal)) ? (FirstVal):(SecondVal)
template <class T>
bool IsValidBST (treeNode &root)
{
T min, max;
return IsValidBST (root, &min, &max);
}
template <class T>
bool IsValidBST (treeNode *root, T *MIN , T *MAX)
{
T leftMin, leftMax, rightMin, rightMax;
bool isValidBST;
if (root->leftNode == NULL && root->rightNode == NULL)
{
*MIN = root->element;
*MAX = root->element;
return true;
}
isValidBST = IsValidBST (root->leftNode, &leftMin, &leftMax);
if (isValidBST)
isValidBST = IsValidBST (root->rightNode, &rightMin, &rightMax);
if (isValidBST)
{
*MIN = MIN (leftMIN, rightMIN);
*Max = MAX (rightMax, leftMax);
}
return isValidBST;
}