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

**curr():**returns the pointer to current element.**prev():**iterates to the previous largest element in the Binary Search Tree.**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:

## CPP

`// 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;` `}` |

**Output:**

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