To find largest element smaller than K in a BST?

That's O(log n), which is the minimum. However, you can improve the efficiency (which seems to be the main thing these interviewers care about) and eliminate the possibility of stack overflow (tada! ) by eliminating tail recursion, turning this into a loop.

Also, your code doesn't work if the tree contains negative numbers ... if you mean non-negative integers, you should say so, but if the interviewer just said "integers" then you need slightly different code and a different API. (You could keep the same function signature but return K instead of -1 upon failure. ).

That's O(log n), which is the minimum. However, you can improve the efficiency (which seems to be the main thing these interviewers care about) and eliminate the possibility of stack overflow (tada! ) by eliminating tail recursion, turning this into a loop.

Also, your code doesn't work if the tree contains negative numbers ... if you mean non-negative integers, you should say so, but if the interviewer just said "integers" then you need slightly different code and a different API. (You could keep the same function signature but return K instead of -1 upon failure. ) BTW, since this is an interview question, implementing it by calling a library function would tell most interviewers that you are a smartass or are missing the point or don't know how to solve it.

Don't mess around with that sort of thing, just get to working on what you know the interviewer wants. Here is an implementation: // Return the greatest int data >= K ) tree = tree->left; else{ if(!tree->right ) return tree->data; tree = tree->right; } return K; // not found }.

I believe in using standard library facilities. Thus, my solution uses std::set. :-) int largest_num_smaller_than(std::set const& set, int num) { std::set::const_iterator lb(set.

Lower_bound(num)); return lb == set.begin()? -1 : *--lb; }.

I think the idea here is to record the last node after which you move to the right subtree. Therefore, the code will be (has been updated) int findNum (Node *node, int K) { Node* last_right_move = NULL; while (node) { if (Kdata) node = node->left; else { last_right_move = node; node = node->right; } } if (last_right_move) return last_right_move->data; else return NOT_FOUND; // defined previously. (-1 may conflict with negative number) }.

I suggest that you walk through the code in your local implementation of set::upper_bound for guidance. This is not the solution to your exact problem, but very close. In general in real life, most of these problems do not need to be solved in your own code.

STL can do many common tasks for you. It's useful to know how to solve them of course, hence the test.

What the first answer said, and here is the logic behind why it cannot get better than O(log n). You are looking for the largest number less than K. This is quite close to calling BST-search/get .

Although your original algorithm looks quite good, I think this would be faster: int findNum (node root, int K) { if(root == null) return -1; if(K > root. Val) { if(root. Right!

= null) return findNum(root. Right, K); else return root. Val; } return findNum(root.

Left, K); //look in left subtree }.

After you find the target value, the maximum of its left sub tree should be the largest value less than it. By maximum of the left subtree, I mean go to the left child of the target value, then go to the right child as many times as you can until you hit the bottom of the tree. EDIT: Misread the question, I thought K was guaranteed to be in the tree.

Optimizing for the == K case can save a few comparisons in that case, but cost extra comparisons for every other case. It's not worth the complication for what might not even be a savings ... in fact, it doesn't even work if a number can occur more than once in the tree, since the largest value in the left subtree of a node containing K might again be K. – Jim Balter Jun 13 at 19:29 edited, misread the question – Kik Jun 13 at 19:49.

I cant really gove you an answer,but what I can give you is a way to a solution, that is you have to find the anglde that you relate to or peaks your interest. A good paper is one that people get drawn into because it reaches them ln some way.As for me WW11 to me, I think of the holocaust and the effect it had on the survivors, their families and those who stood by and did nothing until it was too late.