CareerCup

just add a condition

(if(root->value)>vmin && root->value<vmax){
inorder(root->left);
print(root->value);
inorder(root->right);
}

If vmin < min inside tree and vmax > max in tree, you have to print them all => O(n)
But, vmax - vmin = constant (does not depend on the input size) => O(log n + ct) = O(log n).
Therefore, I don't think it is possible to print all values greater than vmin and lower than vmax in O(log n).
But if the nodes are consecutive numbers, you can find the start node and the end node in O(log n) and print the inner values in O(vmax - vmin) => O(log n + vmax - vmin).

pseudo code:

findrange(bst,min,max){
   if (bst==null) return ;
   if(min<= bst->data <= max) {
         findrange(bst->left,min,max);
         print bst->data;
         findrange(bst->right,min,max);
   }
   elseif (bst->data <min)
         findrange(bst->right,min,max);
   elseif (bst->data <max)
         findrange(bst->left,min,max);
   else
          return;
}

inorder(root)
if(root == null) return;
if(root->value > min) inorder(root->left)
if(root->value > min && root->value < max) print(root->value)
if(root->value < max) inorder(root->right)

inorder(root)
if(root == null) return;
if(root->value > min) inorder(root->left)
if(root->value > min && root->value < max) print(root->value)
if(root->value < max) inorder(root->right)

A short psuedo code

Find the Least common ancestor of (a,b)O(max(depth(a), depth(b))). The subtree rooted at this node is the smallest subtree that has to be explored. Run a dfs on the nodes, and print only those that are in the range.

A short psuedo code

Find the Least common ancestor of (a,b)O(max(depth(a), depth(b))). The subtree rooted at this node is the smallest subtree that has to be explored. Run a dfs on the nodes, and print only those that are in the range.

if(p != NULL)
{
if(p->data > min)
BSTsearch(p->left,max,min);

if(p->data <=max && p->data >=min)
cout<<" "<<p->data;

if(p->data <max)
BSTsearch(p->right,max,min);


}

{
asdf
}