ツリーが二分探索ツリーかどうかを確認する
ツリーがバイナリ検索ツリーであるかどうかを確認するために、次のコードを記述しました。コードを確認してください：
はい！これでコードが編集されました。この簡単な解決策は、以下の投稿で誰かによって提案されました：
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;
}
メソッドは一度に1つのことだけを実行する必要があります。また、物事のやり方は一般的に奇妙です。 ほとんどJavaの疑似コードをあげます。申し訳ありませんが、Javaにはしばらく触れていません。お役に立てば幸いです。質問に対しても行ったコメントをご覧ください。整理してください。
そのようにあなたのisBSTを呼び出します：
public boolean isBst(BNode node)
{
return isBinarySearchTree(node , Integer.MIN_VALUE , Integer.MIN_VALUE);
}
内部的に：
public boolean isBinarySearchTree(BNode node , int min , int max)
{
if(node.data < min || node.data > max)
return false;
//Check this node!
//This algorithm doesn't recurse with null Arguments.
//When a null is found the method returns true;
//Look and you will find out.
/*
* Checking for Left SubTree
*/
boolean leftIsBst = false;
//If the Left Node Exists
if(node.left != null)
{
//and the Left Data are Smaller than the Node Data
if(node.left.data < node.data)
{
//Check if the subtree is Valid as well
leftIsBst = isBinarySearchTree(node.left , min , node.data);
}else
{
//Else if the Left data are Bigger return false;
leftIsBst = false;
}
}else //if the Left Node Doesn't Exist return true;
{
leftIsBst = true;
}
/*
* Checking for Right SubTree - Similar Logic
*/
boolean rightIsBst = false;
//If the Right Node Exists
if(node.right != null)
{
//and the Right Data are Bigger (or Equal) than the Node Data
if(node.right.data >= node.data)
{
//Check if the subtree is Valid as well
rightIsBst = isBinarySearchTree(node.right , node.data+1 , max);
}else
{
//Else if the Right data are Smaller return false;
rightIsBst = false;
}
}else //if the Right Node Doesn't Exist return true;
{
rightIsBst = true;
}
//if both are true then this means that subtrees are BST too
return (leftIsBst && rightIsBst);
}
今：各サブツリーのMinとMaxの値を検索する場合は、コンテナ（ArrayListを使用）を使用し、Node, Min, Maxのトリプレットを格納して、ルートノードと値（明らかに）。
例えば。
/*
* A Class which is used when getting subTrees Values
*/
class TreeValues
{
BNode root; //Which node those values apply for
int Min;
int Max;
TreeValues(BNode _node , _min , _max)
{
root = _node;
Min = _min;
Max = _max;
}
}
そして：
/*
* Use this as your container to store Min and Max of the whole
*/
ArrayList<TreeValues> myValues = new ArrayList<TreeValues>;
これは、指定されたノードのMinおよびMax値を見つけるメソッドです。
/*
* Method Used to get Values for one Subtree
* Returns a TreeValues Object containing that (sub-)trees values
*/
public TreeValues GetSubTreeValues(BNode node)
{
//Keep information on the data of the Subtree's Startnode
//We gonna need it later
BNode SubtreeRoot = node;
//The Min value of a BST Tree exists in the leftmost child
//and the Max in the RightMost child
int MinValue = 0;
//If there is not a Left Child
if(node.left == null)
{
//The Min Value is this node's data
MinValue = node.data;
}else
{
//Get me the Leftmost Child
while(node.left != null)
{
node = node.left;
}
MinValue = node.data;
}
//Reset the node to original value
node = SubtreeRoot; //Edit - fix
//Similarly for the Right Child.
if(node.right == null)
{
MaxValue = node.data;
}else
{
int MaxValue = 0;
//Similarly
while(node.right != null)
{
node = node.right;
}
MaxValue = node.data;
}
//Return the info.
return new TreeValues(SubtreeRoot , MinValue , MaxValue);
}
しかし、これは1つのNode=のみの値を返すので、これを使用してツリー全体を検索します。
public void GetTreeValues(BNode node)
{
//Add this node to the Container with Tree Data
myValues.add(GetSubTreeValues(node));
//Get Left Child Values, if it exists ...
if(node.left != null)
GetTreeValues(node.left);
//Similarly.
if(node.right != null)
GetTreeValues(node.right);
//Nothing is returned, we put everything to the myValues container
return;
}
このメソッドを使用すると、呼び出しは次のようになります。
if(isBinarySearchTree(root))
GetTreeValues(root);
//else ... Do Something
これはほとんどJavaです。いくつかの変更と修正で動作するはずです。良いOOの本を見つけてください、それはあなたを助けます。このソリューションはより多くのメソッドに分解される可能性があることに注意してください。
右、もう一つの簡単な解決策は、順番に訪問することです
boolean bst = isBST(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
public boolean isBST(Node root, int min, int max) {
if(root == null)
return true;
return (root.data > min &&
root.data < max &&
isBST(root.left, min, root.data) &&
isBST(root.right, root.data, max));
}
更新：このソリューションが以前に提案されたことがわかりました。この人たちについては申し訳ありませんが、多分誰かはまだ私のバージョンが便利だと思います
In-Order Traversalを使用してBSTプロパティを確認するソリューションを次に示します。ソリューションを提供する前に、重複を許可しないBSTの定義を使用しています。これは、BSTの各値が一意であることを意味します（これは単純化のためです）。
再帰的順序印刷のコード：
void printInorder(Node root) {
if(root == null) { // base case
return;
}
printInorder(root.left); // go left
System.out.print(root.data + " "); // process (print) data
printInorder(root.right); // go right
}
BSTでのこの順序トラバーサルの後、すべてのデータはソートされた昇順で印刷されます。たとえば、ツリー：
5
3 7
1 2 6 9
順番に印刷されます：
1 2 3 5 6 7 9
これで、ノードを出力する代わりに、In-Orderシーケンスの以前の値を追跡し、現在のノードの値と比較できます。現在のノードの値が前の値よりも小さい場合、これはシーケンスが昇順で並べ替えられておらず、BSTプロパティに違反していることを意味します。
たとえば、ツリー：
5
3 7
1 8 6 9
違反があります。 の右の子は8であり、これはがルートノードである場合は問題ありません。ただし、BSTでは8は9の左の子として終わり、の右の子としては終わりません。したがって、このツリーはBSTではありません。だから、この考えに従うコード：
/* wrapper that keeps track of the previous value */
class PrevWrapper {
int data = Integer.MIN_VALUE;
}
boolean isBST(Node root, PrevWrapper prev) {
/* base case: we reached null*/
if (root == null) {
return true;
}
if(!isBST(root.left, prev)) {
return false;
}
/* If previous in-order node's data is larger than
* current node's data, BST property is violated */
if (prev.data > root.data) {
return false;
}
/* set the previous in-order data to the current node's data*/
prev.data = root.data;
return isBST(root.right, prev);
}
boolean isBST(Node root) {
return isBST(root, new PrevWrapper());
}
サンプルツリーの順序トラバーサルは、ノードのチェックに失敗します5以前の順序5は8であり、これは大きいためしたがって、BSTプロパティに違反しています。
boolean isBST(TreeNode root, int max, int min) {
if (root == null) {
return true;
} else if (root.val >= max || root.val <= min) {
return false;
} else {
return isBST(root.left, root.val, min) && isBST(root.right, max, root.val);
}
}
この問題を解決する別の方法..あなたのコードと同様
二分探索木には次のプロパティがあり、左ノードのキーはルートノードキー以下でなければならず、右ノードキーはルートより大きい必要があります。
したがって、ツリー内のキーが一意ではなく、順序トラバーサルが実行された場合、同じシーケンスを生成する順序トラバーサルが2つ発生するという問題があります。1は有効なbstで、もう1つはそうではありません。これは、左側のノード= root（有効なbst）および右側のノード= root（無効なbstではない）のツリーがある場合に発生します。
これを回避するために、「訪問」されるキーがその間に入る必要がある有効な最小/最大範囲を維持する必要があり、他のノードに再帰するときにこの範囲を渡します。
#include <limits>
int min = numeric_limits<int>::min();
int max = numeric_limits<int>::max();
The calling function will pass the above min and max values initially to isBst(...)
bool isBst(node* root, int min, int max)
{
//base case
if(root == NULL)
return true;
if(root->val <= max && root->val >= min)
{
bool b1 = isBst(root->left, min, root->val);
bool b2 = isBst(root->right, root->val, max);
if(!b1 || !b2)
return false;
return true;
}
return false;
}
空のツリーの値としてINTEGER.MIN、INTEGER.MAXを返すことは、あまり意味がありません。おそらくIntegerを使用して、代わりにnullを返します。
public void inorder()
{
min=min(root);
//System.out.println(min);
inorder(root);
}
private int min(BSTNode r)
{
while (r.left != null)
{
r=r.left;
}
return r.data;
}
private void inorder(BSTNode r)
{
if (r != null)
{
inorder(r.getLeft());
System.out.println(r.getData());
if(min<=r.getData())
{
System.out.println(min+"<="+r.getData());
min=r.getData();
}
else
System.out.println("nananan");
//System.out.print(r.getData() +" ");
inorder(r.getRight());
return;
}
}
深さ優先でツリーをウォークし、各ノードの妥当性をテストします。特定のノードは、それが右側のサブツリーにあるすべての祖先ノードよりも大きく、左側のサブツリーにあるすべての祖先ノードよりも小さい場合に有効です。これらの不等式をチェックするために各祖先を追跡する代わりに、それが（そのlowerBound）より大きくなければならない最大の数と（それのupperBound）より小さくなければならない最小の数をチェックするだけです。
import Java.util.Stack;
final int MIN_INT = Integer.MIN_VALUE;
final int MAX_INT = Integer.MAX_VALUE;
public class NodeBounds {
BinaryTreeNode node;
int lowerBound;
int upperBound;
public NodeBounds(BinaryTreeNode node, int lowerBound, int upperBound) {
this.node = node;
this.lowerBound = lowerBound;
this.upperBound = upperBound;
}
}
public boolean bstChecker(BinaryTreeNode root) {
// start at the root, with an arbitrarily low lower bound
// and an arbitrarily high upper bound
Stack<NodeBounds> stack = new Stack<NodeBounds>();
stack.Push(new NodeBounds(root, MIN_INT, MAX_INT));
// depth-first traversal
while (!stack.empty()) {
NodeBounds nb = stack.pop();
BinaryTreeNode node = nb.node;
int lowerBound = nb.lowerBound;
int upperBound = nb.upperBound;
// if this node is invalid, we return false right away
if ((node.value < lowerBound) || (node.value > upperBound)) {
return false;
}
if (node.left != null) {
// this node must be less than the current node
stack.Push(new NodeBounds(node.left, lowerBound, node.value));
}
if (node.right != null) {
// this node must be greater than the current node
stack.Push(new NodeBounds(node.right, node.value, upperBound));
}
}
// if none of the nodes were invalid, return true
// (at this point we have checked all nodes)
return true;
}