CareerCup

/* Check for binary tree whether its binary search tree */
	private static boolean isBST(BSTNode root, int prev) {
		if(root==null)
			return true;
		if(!isBST(root.getLeft(),prev))
			return false;
		if(root.getData()<prev)
			return false;
		prev=root.getData();
		
		return isBST(root.getRight(),prev);
	}

/* check for BST */
	private static boolean isBST(BSTNode root) {
		if (root == null)
			return true;

		if (root.getLeft() != null && findMax(root.getLeft()) > root.getData())
			return false;
		if (root.getRight() != null
				&& findMin(root.getRight()) < root.getData())
			return false;

		if (!(isBST(root.getLeft())) || (!isBST(root.getRight())))
			return false;
		return true;
	}

It is simple, you can do an in-order traversal of the tree and every time you read the root, put that to an array, then you can go through the array by comparing elements which should be in ascending order.

public void checkBST(Node tree){
if(tree!=null){
checkBST(tree.left);
arrayList.put(tree.data);
checkBST(tree.right);
}
}

static boolean isBST(TreeNode root){
if(root == null)
return true;
if(root.left!=null && root.left.data > root.data ||
root.right!=null && root.right.data < root.data)
return false;
return(isBST(root.left) && isBST(root.right));

}

If you have a tree how to verify it a BST

static boolean isBST(Node root) {
if(root == null)
return false;
if(root.left != null && root.left.value < root.value) {
return true;
}
if(root.right != null && root.right.value > root.value) {
return true;
}

if((root.left != null && root.left.value > root.value)
|| (root.right != null && root.right.value > root.value)) {
return false;
}
isBST(root.left);
isBST(root.right);

return true;
}

static boolean isBST(TreeNode root){
return isBST(root,Integer.MIN_VALUE,Integer.MAX_VALUE);
}

static boolean isBST(TreeNode root,int min,int max){
if(root == null)
return true;
if(root.data<min || root.data>max)
return false;
if(root.left!=null && root.left.data > root.data ||
root.right!=null && root.right.data < root.data)
return false;
return(isBST(root.left,min,root.data) && isBST(root.right,root.data,max));
}

check every node of tree from its parent node and grandparent nodes too.when do recursive then it would have been check that grandparent node from their grandparent node.finally some point it would be checking from root value.

int isThisABST(struct node* mynode)
{
if (mynode==NULL) return(true);
if (node->left!=NULL && maxValue(mynode->left) > mynode->data) return(false);
if (node->right!=NULL && minValue(mynode->right) <= mynode->data) return(false);
if (!isThisABST(node->left) || !isThisABST(node->right)) return(false);
return(true);
}

Reference nice material

Use 2 stacks to create a queue structure
take 2 stacks...stack1 and stack2
now push the elements one by one into stack1 then pop them one by one and push them onto stack2.now on the whole push onto stack1 and pop fro stack 2,which is a queue,first in first out implemented.