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.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s