# 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 varaible “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++ 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; ` `} `

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.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.