Hi Geeks! Welcome to 100 Days of Leetcode Programming challenge.

Day 53 : Binary Search Tree Iterator

In this article, we going to see about Binary Search Tree Iterator. Let’s see the given problem.

Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST.

Calling `next()` will return the next smallest number in the BST.

Example:

```BSTIterator iterator = new BSTIterator(root);
iterator.next();    // return 3
iterator.next();    // return 7
iterator.hasNext(); // return true
iterator.next();    // return 9
iterator.hasNext(); // return true
iterator.next();    // return 15
iterator.hasNext(); // return true
iterator.next();    // return 20
iterator.hasNext(); // return false
```

Note:

1. `next()` and `hasNext()` should run in average O(1) time and uses O(h) memory, where h is the height of the tree.
2. You may assume that `next()` call will always be valid, that is, there will be at least a next smallest number in the BST when `next()` is called.

## Solution

1. Use Stack data structure to solve this problem.

Program to understand better

```/**
* Definition for a binary tree node.
* public class TreeNode {
*     public int val;
*     public TreeNode left;
*     public TreeNode right;
*     public TreeNode(int x) { val = x; }
* }
*/
public class BSTIterator {

private Stack<TreeNode> stack;

public BSTIterator(TreeNode root)
{
stack = new Stack<TreeNode>();
PushAll(root);
}

private void PushAll(TreeNode root) {
while(root != null){
stack.Push(root);
root = root.left;
}
}

/** @return the next smallest number */
public int Next() {
TreeNode tempNode = stack.Pop();
PushAll(tempNode.right);
return tempNode.val;
}

/** @return whether we have a next smallest number */
public bool HasNext() {
return stack.Count != 0;
}
}

/**
* Your BSTIterator object will be instantiated and called as such:
* BSTIterator obj = new BSTIterator(root);
* int param_1 = obj.Next();
* bool param_2 = obj.HasNext();
*/
```

### Time Complexity:

`next()` and `hasNext()` have average O(1) time.

### Space Complexity:

Since we used stack, it takes O(h) memory.