algorithm/Java
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Java.git synced 2025-07-06 17:29:31 +08:00
Code Issues Packages Projects Releases Wiki Activity

Valid BST: refactoring + added unit test (#3883)

Browse Source 
Co-authored-by: Debasish Biswas <debasishbsws.abc@gmail.com>
This commit is contained in:
Albina Gimaletdinova
2023-02-17 14:43:17 +03:00
committed by GitHub
parent d565edc69a
commit 541f490d1e
2 changed files with 72 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
src/main/java/com/thealgorithms/datastructures/trees/ValidBSTOrNot.java
View File

@ -1,45 +1,28 @@
package com.thealgorithms.datastructures.trees;
/**
* This code recursively validates whether given Binary Search Tree (BST) is balanced or not.
* Trees with only distinct values are supported.
* Key points:
* 1. According to the definition of a BST, each node in a tree must be in range [min, max],
* where 'min' and 'max' values represent the child nodes (left, right).
* 2. The smallest possible node value is Integer.MIN_VALUE, the biggest - Integer.MAX_VALUE.
*/
public class ValidBSTOrNot {
class Node {
int data;
Node left, right;
public Node(int item) {
data = item;
left = right = null;
}
}
// Root of the Binary Tree
/* can give min and max value according to your code or
can write a function to find min and max value of tree. */
/* returns true if given search tree is binary
search tree (efficient version) */
boolean isBST(Node root) {
public static boolean isBST(BinaryTree.Node root) {
return isBSTUtil(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
}
/* Returns true if the given tree is a BST and its
values are >= min and <= max. */
boolean isBSTUtil(Node node, int min, int max) {
/* an empty tree is BST */
private static boolean isBSTUtil(BinaryTree.Node node, int min, int max) {
// empty tree is a BST
if (node == null) {
return true;
}
/* false if this node violates the min/max constraints */
if (node.data < min || node.data > max) {
return false;
}
/* otherwise check the subtrees recursively
tightening the min/max constraints */
// Allow only distinct values
return (
isBSTUtil(node.left, min, node.data - 1) &&
isBSTUtil(node.right, node.data + 1, max)