Open In App
Related Articles

Implementing Backward Iterator in BST

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

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.

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

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)

prev()  

  • Declare pointer variable “curr” which points to node.
  • Set curr = q.top()->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.

isEnd()  

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++

// 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 {
private:
    // Stack to store the nodes
    // of BST
    stack<node*> q;
 
public:
    // 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()
    {
        return q.top();
    }
 
    // Function to iterate to previous
    // element of BST
    void prev()
    {
        node* curr = q.top()->left;
        q.pop();
        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
    iterate(it);
 
    return 0;
}

                    

Java

// Java implementation of the approach
import java.util.*;
 
// Node of the binary tree
class 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
  public bstit(node root)
  {
 
    // Initializing stack
    q = new Stack<>();
    node curr = root;
    while (curr != null) {
      q.add(curr);
      curr = curr.right;
    }
  }
 
  // Function to return
  // current element iterator
  // is pointing to
  node curr()
  {
    return q.peek();
  }
 
  // Function to iterate to previous
  // element of BST
  void prev()
  {
    node curr = q.peek().left;
    q.pop();
    while (curr != null) {
      q.add(curr);
      curr = curr.right;
    }
  }
 
  // Function to check if
  // stack is empty
  boolean isEnd()
  {
    return (q.size() != 0);
  }
 
  // Function to test the iterator
  void iterate(bstit it)
  {
    while (it.isEnd()) {
      System.out.print(it.curr().data);
      System.out.print(" ");
      prev();
    }
 
  }
}
public class GFG
{
 
  // Driver code
  public static void main(String[] args)
  {
    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 = new bstit(root);
 
    // Function call to test the iterator
    it.iterate(it);
 
  }
}
 
// This code is contributed by Rajput-Ji

                    

Python3

# Python 3 implementation of the approach
 
# Node of the binary tree
class node:
    def __init__(self,data):
        self.data = data
        self.left = None
        self.right = None
 
# Iterator for BST
class bstit:
    # __stack to store the nodes
    # of BST
    __stack = []
    # Constructor for the class
 
    def __init__(self, root):
 
        # Initializing __stack
        curr = root
        while (curr is not None):
            self.__stack.append(curr)
            curr = curr.right
 
    # Function to return
    # current element iterator
    # is pointing to
    def curr(self):
        return self.__stack[-1]
 
    # Function to iterate to previous
    # element of BST
    def prev(self):
     
        curr = self.__stack[-1].left
        self.__stack.pop()
        while (curr != None):
            self.__stack.append(curr)
            curr = curr.right
 
    # Function to check if
    # __stack is empty
    def isEnd(self):
        return not len((self.__stack))
 
# Function to test the iterator
def iterate(it):
    while (not it.isEnd()):
        print(it.curr().data,end=" ")
        it.prev()
 
# Driver code
if __name__ == '__main__':
 
    root = node(5)
    root.left = node(3)
    root.right = node(7)
    root.left.left = node(2)
    root.left.right = node(4)
    root.right.left = node(6)
    root.right.right = node(8)
 
    # Iterator to BST
    it=bstit(root)
 
    # Function call to test the iterator
    iterate(it)
    print()
# This code is contributed by Amartya Ghosh

                    

C#

// C# implementation of the approach
using System;
using System.Collections.Generic;
 
// Node of the binary tree
public class node {
  public int data;
  public node left;
  public node right;
 
  public node(int data) {
    this.data = data;
    left = null;
    right = null;
  }
}
 
// Iterator for BST
public class bstit {
 
  // Stack to store the nodes
  // of BST
  Stack<node> q;
 
  // Constructor for the class
  public bstit(node root) {
 
    // Initializing stack
    q = new Stack<node>();
    node curr = root;
    while (curr != null) {
      q.Push(curr);
      curr = curr.right;
    }
  }
 
  // Function to return
  // current element iterator
  // is pointing to
  public node curr() {
    return q.Peek();
  }
 
  // Function to iterate to previous
  // element of BST
  public void prev() {
    node curr = q.Peek().left;
    q.Pop();
    while (curr != null) {
      q.Push(curr);
      curr = curr.right;
    }
  }
 
  // Function to check if
  // stack is empty
  public bool isEnd() {
    return (q.Count != 0);
  }
 
  // Function to test the iterator
  public void iterate(bstit it) {
    while (it.isEnd()) {
      Console.Write(it.curr().data);
      Console.Write(" ");
      prev();
    }
 
  }
}
 
public class GFG {
 
  // Driver code
  public static void Main(String[] args) {
    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 = new bstit(root);
 
    // Function call to test the iterator
    it.iterate(it);
 
  }
}
 
// This code is contributed by Rajput-Ji

                    

Javascript

<script>
 
// Javascript implementation of the approach
 
// Node of the binary tree
class node
{
    constructor(data)
    {
        this.left = null;
        this.right = null;
        this.data = data;
    }
}
 
// Stack to store the nodes
// of BST
let q = [];
 
// Constructor for the class
function bstit(root)
{
     
    // Initializing stack
    let curr = root;
     
    while (curr != null)
    {
        q.push(curr);
        curr = curr.right;
    }
}
 
// Function to return
// current element iterator
// is pointing to
function curr()
{
    return q[q.length - 1];
}
 
// Function to iterate to previous
// element of BST
function prev()
{
    let curr = q[q.length - 1].left;
    q.pop();
     
    while (curr != null)
    {
        q.push(curr);
        curr = curr.right;
    }
}
 
// Function to check if
// stack is empty
function isEnd()
{
    return (q.length == 0);
}
 
// Function to test the iterator
function iterate()
{
    while (!isEnd())
    {
        document.write(curr().data + " ");
        prev();
    }
}
 
// Driver code
let 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(root);
 
// Function call to test the iterator
iterate();
 
// This code is contributed by divyeshrabadiya07
 
</script>

                    

Output: 
8 7 6 5 4 3 2

 


Last Updated : 31 Jan, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads