Skip to content
Related Articles

Related Articles

Improve Article
Implementing Backward Iterator in BST
  • Difficulty Level : Easy
  • Last Updated : 04 May, 2021

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

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

Iterator traverses the BST in decreasing order. We will implement the iterator using a stack data structure.

  • 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 -> right


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)

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

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

Returns true if stack “q” is empty else returns 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++ implementation of the approach
#include <bits/stdc++.h>
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 {
    // Stack to store the nodes
    // of BST
    stack<node*> q;
    // Constructor for the class
    bstit(node* root)
        // Initializing stack
        node* curr = root;
        while (curr != NULL)
            q.push(curr), curr = curr->right;
    // Function to return
    // current element iterator
    // is pointing to
    node* curr()
    // Function to iterate to previous
    // element of BST
    void prev()
        node* curr =>left;
        while (curr != NULL)
            q.push(curr), curr = curr->right;
    // Function to check if
    // stack is empty
    bool isEnd()
        return !(q.size());
// Function to test the iterator
void iterate(bstit it)
    while (!it.isEnd())
        cout << it.curr()->data << " ", it.prev();
// 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 call to test the iterator
    return 0;
8 7 6 5 4 3 2


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
Recommended Articles
Page :