# Implementing Backward Iterator in BST

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 ``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->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 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 q;` `  ``// Constructor for the class``  ``public` `bstit(node root) {` `    ``// Initializing stack``    ``q = ``new` `Stack();``    ``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

 ``

Output:
`8 7 6 5 4 3 2`

Previous
Next