मैं एक अभ्यास के यहाँ एक द्विआधारी खोज वृक्ष मान्य के रूप में जाना साक्षात्कार में पर पढ़ें।
वास्तव में किस प्रकार काम करता है? क्या एक एक द्विआधारी खोज वृक्ष को सत्यापित करने में तलाश कर रहा होगा? मैं एक बुनियादी खोज पेड़ लिखा है, लेकिन यह अवधारणा कभी नहीं सुना।
"सत्यापित किया जा रहा" एक द्विआधारी खोज वृक्ष मतलब है कि आप जाँच लें कि यह है कि यह वास्तव में सही पर छोड़ दिया और बड़ी वस्तुओं पर सभी छोटे आइटम नहीं हैं करता है। मूलतः, यह करता है, तो एक द्विआधारी पेड़ एक द्विआधारी है देखने के लिए एक जांच है खोज पेड़।
असल में उस गलती हर कोई एक साक्षात्कार में करता है।
Leftchild के खिलाफ जाँच की जानी चाहिए (minLimitof नोड, node.value)
Rightchild के खिलाफ जाँच की जानी चाहिए (node.value, नोड के MaxLimit)
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;
}
एक अन्य समाधान (यदि अंतरिक्ष की कोई समस्या नहीं है): पेड़ की एक inorder ट्रावर्सल करो और एक सरणी में नोड मान संग्रहीत। सरणी, इसकी एक वैध BST अन्यथा नहीं क्रमबद्ध क्रम में है।
यहाँ 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)))
"यह पहली एक अपरिवर्तनीय परिभाषित करने के लिए बेहतर है यहाँ अपरिवर्तनीय है -। इन-आदेश ट्रावर्सल में BST के किसी भी दो अनुक्रमिक तत्वों सख्ती से उनकी उपस्थिति का बढते क्रम में होना चाहिए (, जैसी नहीं हो सकती हमेशा क्रम में में वृद्धि हो रही ट्रेवर्सल)। तो समाधान '<' (या '>') के लिए एक का दौरा किया पिछली बार देखे नोड और तुलना पिछले खिलाफ वर्तमान नोड याद के साथ सिर्फ एक सरल में से आदेश ट्रावर्सल हो सकता है। "
Iterative समाधान ट्रेवर्सल inorder का उपयोग कर।
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;
}
पुनरावर्ती समाधान:
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)
}
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;
}
// 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;
}
boolean isBST(Node root) {
if (root == null) { return true; }
return (isBST(root.left) && (isBST(root.right) && (root.left == null || root.left.data <= root.data) && (root.right == null || root.right.data > root.data));
}
यहाँ अतिरिक्त स्थान का उपयोग किए बिना पुनरावृत्ति समाधान है।
Node{
int value;
Node right, left
}
public boolean ValidateBST(Node root){
Node currNode = root;
Node prevNode = null;
Stack<Node> stack = new Stack<Node>();
while(true){
if(currNode != null){
stack.push(currNode);
currNode = currNode.left;
continue;
}
if(stack.empty()){
return;
}
currNode = stack.pop();
if(prevNode != null){
if(currNode.value < prevNode.value){
return false;
}
}
prevNode = currNode;
currNode = currNode.right;
}
}
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)
)
)
);
}
सबसे अच्छा समाधान मैंने पाया हे (एन) है और यह बिना किसी अतिरिक्त स्थान का उपयोग करता। यह inorder ट्रावर्सल के समान है, लेकिन इसके बजाय सरणी के लिए भंडारण और फिर जाँच है कि क्या यह सॉर्ट हो जाता है हम एक स्थिर चर लेने के लिए और जांच कर सकते हैं की, जबकि traversing सरणी सॉर्ट हो जाता है कि क्या inorder।
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;
}
यह जानने के लिए कि क्या दिया बीटी किसी भी डेटाप्रकार के लिए BST है, तो आप नीचे दिए गए दृष्टिकोण के साथ जाना की जरूरत है। 1. कॉल पुनरावर्ती क्रिया ट्रेवर्सल 2. inorder का उपयोग कर पत्ती नोड के अंत तक अपने मिनट का निर्माण और अधिकतम अपने आप को महत्व देता है।
ट्री तत्व / कम से कम एक से अधिक ऑपरेटर परिभाषित होने चाहिए।
#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;
}
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;
}
ठीक काम करता है :)
प्रत्यावर्तन आसान है, लेकिन पुनरावृत्ति दृष्टिकोण बेहतर है, वहाँ एक पुनरावृत्ति संस्करण ऊपर, लेकिन यह बहुत आवश्यक से जटिल है। यहाँ है सबसे अच्छा समाधान में c++आप कभी भी कहीं भी मिल जाएगा:
इस एल्गोरिथ्म में चलता है O(N)समय और जरूरत 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;
}
मैं Traversal BST inorder का उपयोग करें और जाँच नोड्स अंतरिक्ष के लिए आदेश बढ़ती जा रही है कि क्या करने के लिए एक समाधान लिखा था O(1)और समय O(n)। TreeNode predecessorनोड पीछे है। मुझे यकीन है कि समाधान सही है या नहीं है नहीं कर रहा हूँ। Inorder क्योंकि Traversal एक पूरे पेड़ को परिभाषित नहीं कर सकते हैं।
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;
}
बाद BST सत्यापन के जावा कार्यान्वयन, जहां हम पेड़ में से आदेश डीएफएस यात्रा कर रहा है और यह गलत रिटर्न अगर हम किसी भी संख्या जो पिछले संख्या से अधिक है मिलता है।
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;
}
}
के बाद से एक BST के नि: आदेश ट्रावर्सल एक गैर कमी अनुक्रम है, हम न्याय के लिए कि क्या एक द्विआधारी पेड़ BST है या नहीं इस संपत्ति का उपयोग कर सकते हैं। का उपयोग करते हुए मॉरिस ट्रेवर्सल और बनाए रखने के preनोड, हम में एक समाधान मिल सकता है हे (एन) समय और हे (1) अंतरिक्ष जटिलता। यहाँ मेरी कोड है
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;
}
मैं हाल ही में एक फोन साक्षात्कार में यह सवाल मिल गया और अधिक से अधिक मैं होना चाहिए इसके साथ संघर्ष किया। मैं बच्चे नोड्स में न्यूनतम और अधिकतम का ट्रैक रखने की कोशिश कर रहा था और मैं बस एक साक्षात्कार के दबाव में विभिन्न मामलों के आसपास मेरे मस्तिष्क लपेट नहीं कर सका।
जबकि गिरने सो कल रात इस बारे में सोच करने के बाद, मुझे एहसास हुआ कि यह पिछले नोड आप एक inorder ट्रावर्सल दौरान अपने द्वारा देखे गए का ट्रैक रखने के रूप में सरल है। जावा में:
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;
}
Iterative समाधान।
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;
}
यह डुप्लिकेट के लिए काम करता है।
// 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)
इस के लिए भी काम करता है int.minऔर int.maxका उपयोग कर मूल्यों 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)
से प्रेरित होकर http://www.jiuzhang.com/solutions/validate-binary-search-tree/
ट्रावर्सल और विभाजन && जीत: वहाँ दो सामान्य समाधान कर रहे हैं।
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);
}
}
यहाँ मेरी पुनरावर्ती समाधान जावास्क्रिप्ट में लिखा है
function isBST(tree) {
if (tree === null) return true;
if (tree.left != undefined && tree.left.value > tree.value) {
return false;
}
if (tree.right != undefined && tree.right.value <= tree.value) {
return false;
}
return isBST(tree.left) && isBST(tree.right);
}
जावा और या तो उप पेड़ में एक ही मूल्य के साथ नोड्स की इजाजत दी है:
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);
}
private void validateBinarySearchTree(Node node) {
if (node == null) return;
Node left = node.getLeft();
if (left != null) {
if (left.getData() < node.getData()) {
validateBinarySearchTree(left);
} else {
throw new IllegalStateException("Not a valid Binary Search tree");
}
}
Node right = node.getRight();
if (right != null) {
if (right.getData() > node.getData()) {
validateBinarySearchTree(right);
} else {
throw new IllegalStateException("Not a valid Binary Search tree");
}
}
}
यहाँ अजगर में मेरा जवाब है, यह सब कोने मामलों का समाधान किया है और अच्छी तरह से परीक्षण किया 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 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);
}
सुंदर लंबी लाइन यद्यपि।
यहाँ Sedgewick एल्गोरिथ्म वर्ग से जावा में एक समाधान है। पूर्ण BST कार्यान्वयन की जांच यहां
मैं कुछ व्याख्यात्मक टिप्पणियां जोड़ा
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);
}
iterativeसमारोह की जाँच करता है को देखते हुए पेड़ एक द्विआधारी खोज वृक्ष है iteratively या नहीं। recurseसमारोह की जाँच करता है को देखते हुए पेड़ एक द्विआधारी खोज वृक्ष है या नहीं रिकर्सिवली या नहीं। iterativeसमारोह मैं BST की जाँच के लिए BFS का उपयोग करें।recurseसमारोह मैं BST की जाँच के लिए डीएफएस का उपयोग करें।O(n)iterativeसमाधान से अधिक एक फायदा है recurseसमाधान और वह यह है कि iterativeसमाधान जल्दी रोक नहीं करता है।recurseसमारोह वैश्विक ध्वज मूल्य से जल्दी रोक के लिए अनुकूलित किया जा सकता है।और सीमा के भीतर वर्तमान नोड के मूल्य की तुलना पर चलते हैं। यदि किसी भी नोड के मूल्य श्रेणी में नहीं है तो झूठी वापसी
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)
अजगर कार्यान्वयन उदाहरण। इस उदाहरण एनोटेशन टाइप उपयोग करता है। लेकिन जब से नोड वर्ग खुद का उपयोग करता है हम मॉड्यूल की पहली पंक्ति के रूप में शामिल करने की ज़रूरत:
from __future__ import annotations
अन्यथा, आप मिल जाएगा name 'Node' is not definedत्रुटि। यह उदाहरण भी एक उदाहरण के रूप dataclass उपयोग करता है। अगर यह BST यह छोड़ दिया और सही नोड्स मूल्यों की जाँच के लिए प्रत्यावर्तन का उपयोग करता है की जाँच करें।
"""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 __name__ == "__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))