Skip to content
Related Articles
Implementing Forward Iterator in BST
• Difficulty Level : Hard
• Last Updated : 19 May, 2021

Given a Binary search tree, the task is to implement forward iterator on it with the following functions.

1. curr(): returns the pointer to current element.
2. next(): iterates to the next smallest element in the Binary Search Tree.
3. isEnd(): returns true if there no node left to traverse else false.

Iterator traverses the BST in sorted order(increasing). We will implement the iterator using a stack data structure.
Initialisation:

• We will create a stack named “q” to store the nodes of BST.
• Create a variable “curr” and initialise it with pointer to root.
• While “curr” is not NULL
• Push “curr” in the stack ‘q’.
• Set curr = curr -> left

curr()

Returns the value at the top of the stack ‘q’.
Note: It might throw segmentation fault if the stack is empty.

Time Complexity: O(1)

next()

• Declare pointer variable “curr” which points to node.
• Set curr = q.top()->right.
• Pop top most element of stack.
• While “curr” is not NULL
• Push “curr” in the stack ‘q’.
• Set curr = curr -> left.

Time Complexity: O(1) on average of all calls. Can be O(h) for a single call in the worst case.

isEnd()

Returns true if stack “q” is empty else return false.

Time Complexity: O(1)
Worst Case space complexity for this implementation of iterators is O(h). It should be noticed that
iterator points to the top-most element of the stack.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Node of the binary tree``struct` `node {``    ``int` `data;``    ``node* left;``    ``node* right;``    ``node(``int` `data)``    ``{``        ``this``->data = data;``        ``left = NULL;``        ``right = NULL;``    ``}``};` `// Iterator for BST``class` `bstit {``private``:``    ``// Stack to store the nodes``    ``// of BST``    ``stack q;` `public``:``    ``// Constructor for the class``    ``bstit(node* root)``    ``{``        ``// Initializing stack``        ``node* curr = root;``        ``while` `(curr != NULL)``            ``q.push(curr), curr = curr->left;``    ``}` `    ``// Function to return``    ``// current element iterator``    ``// is pointing to``    ``node* curr()``    ``{``        ``return` `q.top();``    ``}` `    ``// Function to iterate to next``    ``// element of BST``    ``void` `next()``    ``{``        ``node* curr = q.top()->right;``        ``q.pop();``        ``while` `(curr != NULL)``            ``q.push(curr), curr = curr->left;``    ``}` `    ``// Function to check if``    ``// stack is empty``    ``bool` `isEnd()``    ``{``        ``return` `!(q.size());``    ``}``};` `// Function to iterator to every element``// using iterator``void` `iterate(bstit it)``{``    ``while` `(!it.isEnd())``        ``cout << it.curr()->data << ``" "``, it.next();``}` `// Driver code``int` `main()``{``    ``node* root = ``new` `node(5);``    ``root->left = ``new` `node(3);``    ``root->right = ``new` `node(7);``    ``root->left->left = ``new` `node(2);``    ``root->left->right = ``new` `node(4);``    ``root->right->left = ``new` `node(6);``    ``root->right->right = ``new` `node(8);` `    ``// Iterator to BST``    ``bstit it(root);` `    ``// Function to test iterator``    ``iterate(it);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `// Node of the binary tree``class` `TreeNode``{``    ``int` `val;``    ``TreeNode left;``    ``TreeNode right;``    ``TreeNode(``int` `x)``    ``{``        ``val = x;``    ``}``}` `// Iterator for BST``class` `BSTIterator{` `// Stack to store the nodes``// of BST``Stack s;` `// Constructor for the class``public` `BSTIterator(TreeNode root)``{``    ` `    ``// Initializing stack``    ``s = ``new` `Stack<>();``    ``TreeNode curr = root;``    ` `    ``while` `(curr != ``null``)``    ``{``        ``s.push(curr);``        ``curr = curr.left;``    ``}``}` `// Function to return``// current element iterator``// is pointing to``TreeNode curr()``{``    ``return` `s.peek();``}` `// Function to iterate to next``// element of BST``public` `void` `next()``{``    ``TreeNode temp = s.peek().right;``    ``s.pop();``    ` `    ``while` `(temp != ``null``)``    ``{``        ``s.push(temp);``        ``temp = temp.left;``    ``}``}` `// Function to check if``// stack is empty``public` `boolean` `isEnd()``{``    ``return` `!s.isEmpty();``}` `// Function to iterator to every element``// using iterator``void` `iterate()``{``    ``while` `(isEnd())``    ``{``        ``System.out.print(curr().val + ``" "``);``        ``next();``    ``}``}``}` `class` `BinaryTree{``    ` `TreeNode root;` `// Driver code``public` `static` `void` `main(String args[])``{``    ` `    ``// Let us construct a tree shown in``    ``// the above figure``    ``BinaryTree tree = ``new` `BinaryTree();``    ``tree.root = ``new` `TreeNode(``5``);``    ``tree.root.left = ``new` `TreeNode(``3``);``    ``tree.root.right = ``new` `TreeNode(``7``);``    ``tree.root.left.left = ``new` `TreeNode(``2``);``    ``tree.root.left.right = ``new` `TreeNode(``4``);``    ``tree.root.right.left = ``new` `TreeNode(``6``);``    ``tree.root.right.right = ``new` `TreeNode(``8``);` `    ``// Iterator to BST``    ``BSTIterator it = ``new` `BSTIterator(tree.root);` `    ``// Function to test iterator``    ``it.iterate();``}``}` `// This code is contributed by nobody_cares`
Output:
`2 3 4 5 6 7 8`

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up