# Is binary tree subtree of another binary tree

Given two binary trees s and t, find if binary tree t is subtree of binary tree s.
For example: Given binary tree s as follows,

binary tree t will be a subtree as shown.

However, if the binary tree s is as follows, then t is not a subtree of the tree s

Let’s start from the ver simple cases and build on top of them. What if one of the trees is or both of them are empty? If s and t both are empty binary trees, then of course t is subtree of s.
Other case, when s is empty and t not, then t is not subtree. Similary, when t is not empty and s is empty, then also, t is not subtree of s.

``` if(s == null && t == null){
return true;
}

if(s == null || t == null){
return false;
}
```

Now, if we start from the root of both trees, there are two possibilities: First, the root of two trees match with values. `s.val == t.val`. In this case, the problem reduces to check if left subtree of target tree is same as a left subtree of the source and if right subtree of target tree is same as the right subtree of source binary tree.

```return s.val == t.val
&& isSame(s.left,t.left)
&& isSame(s.right,t.right);
```

If everything goes fine and we hit the condition when both s and t then we know that both trees are same and one should be a subtree of other.

Second, the root of the two trees are not the same? In that case, we check if left subtree of s is same as s or right subtree of s is same as t. If one of subtree same as the target tree, we return true.

```/**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/
class Solution {
public boolean isSubtree(TreeNode s, TreeNode t) {

if(s == null && t == null){
return true;
}

if(s != null && t == null){
return false;
}

if(s == null && t != null){
return false;
}

if(s.val != t.val) {
return (isSubtree(s.left,t.left)
&& isSubtree(s.right,t.right));
}
else {
return  isSubtree(s.left,t)
|| isSubtree(s.right,t);
}
}
}
```

Above implementation will work for the below case.

but will not work for this case.

This is almost done. But there is one small mistake in it. We are relying on the inequality of the root nodes. What if the current roots are equal and some nodes in left or right subtrees do not the match? We have to come up all the way where we started with s and t to check if t is a subtree of s. That is why we have two separate functions: One to check if trees are same once their roots match and other to start afresh once we find that trees are not the same starting at a particular root. Above function actually does not start from the place where we started with s and t if node values do not match and continue down the subtree. This will return true even if roots and leaves match even if intermediate nodes do not. This is the case most of the students fail to understand.

### Binary tree is subtree of another binary tree : Implementation

```
/**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/
class IsSubtree {
public boolean isSubtree(TreeNode s, TreeNode t) {

if(s == null) return false;

if(!isSame(s,t)){
return isSubtree(s.left,t)
|| isSubtree(s.right,t);
}

return true;
}

private boolean isSame(TreeNode s, TreeNode t){

if(s == null && t == null){
return true;
}

if(s == null || t == null){
return false;
}

return s.val == t.val
&& isSame(s.left,t.left)
&& isSame(s.right,t.right);
}
}
```

The complexity of implementation to find if one binary tree is a subtree of another is O(n) where n is the number of nodes in the target tree.

You can run this code on the leetcode problem and see it passes all test cases there.
Please share if there is something wrong or missing. If you are preparing for an interview and want personalized coaching, please reach out to us at [email protected] or book a free session with us.

## Lowest common ancestor(LCA) using RMQ

We already have discussed lowest common ancestor and range minimum query. In this post, we will discuss how to use RMQ to find the lowest common ancestor of two given nodes in a binary tree or binary search tree. LCA of two nodes u and v is the node which is furthest from root and u and v are descendant of that node. For example, LCA `node(5)` and `node(9)` in below tree is `node(2)`.

In earlier solutions, we scan the whole binary tree every time we have to find LCA of two nodes. This has a complexity of `O(n)` for each query. If this query if fired frequently, this operation may become a bottleneck of the algorithm. One way to avoid processing all nodes on each query is to preprocess binary tree and store precalculated information to find LCA of any two nodes in constant time.

This pattern is very similar to a range minimum query algorithm. Can we reduce the lowest common ancestor problem to range minimum query problem?

### Reduction of lowest common ancestor problem to RMQ

Let’s revise what is RMQ: Given an array A of length n; RMQ(i,j) – returns the index of the minimum element in the subarray A[i..j].

Let’s find LCA of two nodes 5 and 8 manually in the above binary tree. We notice that LCA(u,v) is a shallowest common node (in terms of distance from root) which is visited when u and v are visited using the depth-first search of the tree. An important thing to note is that we are interested in shallowest, which is minimum depth, the node between u and v. Sounds like RMQ?

Implementation wise, the tree is traversed as Euler tour, which means we visit each node of tree, without lifting the pencil. This is very similar to a preorder traversal of a tree. At most, there can be 2n-1 nodes in Euler tour of a tree with n nodes, store this tour in an array `E[1..2n-1]`.

As algorithm requires the shallowest node, closest to root, so we store the depth of each node while doing Euler tour, so we store the depth of each node in another array D[1..2n-1].

We should maintain the value when the node was visited for the first time. Why?

E[1..2n-1] – Store the nodes visited in a Euler tour of T. Euler[i] stores ith node visited in the tour.
D[1..2n-1] – Stores level of the nodes in tour. D[i] is the level of node at Euler[i]. (level is defined to be the distance from the root).
F[1..n] – F[i] will hold value when node is first visited.

For example of this graph, we start from node(1) and do Euler tour of the binary tree.

Euler tour would be like

Depth array is like

First visit array looks like

To compute LCA(u,v): All nodes in the Euler tour between the first visits to u and v are `E[F[u]...F[v]]` (assume F[u] is less than F[v] else, swap u and v). The shallowest node in this tour is at index `RMQ D(F[u]..F[v])`, since D[i] stores the depth of node at E[i].
RMQ function will return the index of the shallowest node between u and v, thus output node will be `E[RMQ D(F[u], F[v])]` as LCA(u,v)

Let’s take an example, find the lowest common ancestor of `node(5)` and `node(8)`.

First of all, find the first visit to `node(5)` and `node(8)`. It will be F[5] which is 2 and F[8] which is 7.

Now, all the nodes which come between visit of `node(5)` and `node(8)` are in E[2..7], we have to find the shallowest node out these nodes. This can be done by applying RMQ on array D with range 3 to 6.

LCA will be E[RMQ( D(2,7)], in this case, RMQ(D[2..7]) is index 3. E[3] = 2, hence LCA(5,8) is `node(2)`.

#### Lowest common ancestor using RMQ: Implementation

```package com.company.BST;

import java.util.Arrays;

/**
* Created by sangar on 1.1.19.
*/
public class LowestCommonAncestor {

private int[] E;
private int[] D;
private int[] F;

int[][] M;

private int tourCount;

public LowestCommonAncestor(BinarySearchTree tree){
//Create Euler tour, Depth array and First Visited array
E = new int[2*tree.getSize()];
D = new int[2*tree.getSize()];
F = new int[tree.getSize() + 1];

M = new int[2 * tree.getSize()][2 * tree.getSize()];

Arrays.fill(F, -1);
getEulerTour(tree.getRoot(), E, D, F, 0);

preProcess(D);
}

public int findLowestCommonAncestor(int u, int v){
//This means node is not in tree
if(u >= F.length || v >= F.length || F[u] == -1 || F[u] == -1)
return -1 ;

return E[rmq(D, F[u], F[v])];
}

/* This function does all the preprocessing on the tree and
creates all required arrays for the algorithm.
*/
private void getEulerTour(TreeNode node, int[] E, int[] D, int[] F,
int level){
if(node == null) return;

int val = (int)node.getValue();

E[tourCount] = val; // add to tour
D[tourCount] =  level; // store depth

if(F[val] == -1) {
F[(int) node.getValue()] = tourCount;
}
tourCount++;

if(node.getLeft() != null ) {
getEulerTour(node.getLeft(), E, D, F, level + 1);

E[tourCount] = val;
D[tourCount++] = level;
}
if(node.getRight() != null ) {
getEulerTour(node.getRight(), E, D, F, level + 1);

E[tourCount] = val;
D[tourCount++] = level;
}
}

/*
This function preprocess the depth array to quickly find
RMQ which is used to find shallowest node.
*/
void preProcess(int[] D) {

for (int i = 0; i < D.length; i++)
M[i][0] = i;

for (int j = 1; 1 << j <D.length ; j++){
for (int i = 0; i + (1 << j) - 1 < D.length; i++){
if (D[M[i][j - 1]] < D[M[i + (1 << (j - 1))][j - 1]])
M[i][j] = M[i][j - 1];
else
M[i][j] = M[i + (1 << (j - 1))][j - 1];
}
}
}

private int rmq(int a[], int start, int end){
int j = (int)Math.floor(Math.log(end-start+1));

if ( a[ M[start][j] ] <= a[M[end-(1<<j)+1][j]] )
return M[start][j];

else
return M[end-(1<<j)+1][j];
}
}
```

The beauty of this algorithm is that it can be used to find LCA of any tree, not just only binary tree or BST. The complexity of the algorithm to find a lowest common ancestor using range minimum query is `(O(n), O(1))` with an additional space complexity of `O(n)`.

Please share if there is something wrong or missing. If you are preparing for an interview, please signup for free demo class to guide you through the process.

## Runway reservation system

Given an airport with a single runway, we have to design a runway reservation system of that airport. Add to details: each reservation request comes with requested landing time let’s say t. Landing can go through if there is no landing scheduled within k minutes of requested time, that means t can be added to the set of scheduling landings. K can vary and depends on external conditions. This system helps with reservations for the future landings.
Once the plane lands safely, we have to remove the plane for landing sets.

This is perfectly possible with airports with multiple runways where only one runway can be used because of weather conditions, maintenance etc. Also, one landing cannot follow another immediately due safety reasons, that’s why there has to be some minimum time before another landing takes place. We have to build this system with given constraints.

In nutshell, we have create a set of landings which are compatible with each other, i.e they do not violate the constraint put.  There are two operations to be performed on this set : insertion and removal. Insertion involves checking of constraints.

Example: let’s say below is the timeline of all the landing currently scheduled and k = 3 min

Now, if the new request comes for landing at 48.5, it should be added to the set as it does not violate the constraint of k mins. However, if a request comes for landing at 53, it cannot be added as it violates the constraint.
If a new request comes for 35, it is invalid as the request is in past.

## Reservation system: thoughts

What is the most brute force solution which comes to mind? We can store all the incoming requests in an unsorted array.  Insertion should be O(1) operation as it is at the end. However, checking the constrain that it is satisfied will take O(n) because we have to scan through the entire array.
Same is true even if we use unsorted linked list.

How about a sorted array? We can use a binary search algorithm to find the constraint, which will take O(log n) complexity. However, the insertion will still be O(n) as we have to move all the elements to the right from the position of insertion.

Sorted list solves the problem of insertion in O(1) but then search for the constraint will be O(n) complexity. It just moves the problem from one place to another.

### Reservation system using binary search tree

We have to optimize two things : first check if the new request meets the constraints, second insert the new request into the set.

Let’s think of binary search tree. To check a constraint, we have to check each node of the binary tree, but based on the relationship of the current node and the new request time, we can discard half of the tree. (Binary search tree property, where all the nodes on the left side are smaller than the root node and all the nodes on the right side are greater than the current node)

When a new request comes, we check with the root node and it does not violate the constraints, then we check if the requested time is less than the root. If yes, we go to left subtree and check there. If requested landing time is greater than the root node, we go to right subtree.
When we reach the leaf node, we add a new node with new landing time as the value of that node.

If at any given node, the constraint is violated, i.e not new landing time is within k minutes of time in the node, then we just return stating it is not possible to add new landing.

What will be complexity of checking the constraint? It will be O(h) where h is height of binary search tree. Insert is then O(1) operation.

#### Reservation system implementation

```#include<stdio.h>
#include<stdlib.h>
#include<math.h>

struct node{
int value;
struct node *left;
struct node *right;
};
typedef struct node Node;

void inoderTraversal(Node * root){
if(!root) return;

inoderTraversal(root->left);
printf("%d ", root->value);
inoderTraversal(root->right);
}

Node *createNode(int value){
Node * newNode =  (Node *)malloc(sizeof(Node));

newNode->value = value;
newNode->right= NULL;
newNode->left = NULL;

return newNode;
}

Node *addNode(Node *node, int value, int K){
if(!node)
return createNode(value);

if ( node->value + K > value && node->value - K < value ){
return node;
}
if (node->value > value)
node->left = addNode(node->left, value, K);
else
node->right = addNode(node->right, value, K);
return node;
}

/* Driver program for the function written above */
int main(){
Node *root = NULL;

//Creating a binary tree
root = addNode(root, 30, 3);
root = addNode(root, 20, 3);
root = addNode(root, 15, 3);
root = addNode(root, 25, 3);
root = addNode(root, 40, 3);
root = addNode(root, 38, 3);
root = addNode(root, 45, 3);
inoderTraversal(root);

return 0;
}

```

Let’s say a new requirement comes which is to find how many flights are scheduled till time t?

This problem can easily be solved using binary search tree, by keeping track of size of subtree at each node as shown in figure below.

While inserting a new node, update counter of all the nodes on the nodes. When query is run, just return the count of node of that time or closest and smaller than that value of t.

Please share if there is something wrong or missing. If you are preparing for an interview, please signup to receive free preparation material.

## Prune nodes not on paths with given sum

Prune nodes not on paths with given sum is a very commonly asked question in Amazon interviews. It involves two concepts in one problem. First, how to find a path with a given sum and then second, how to prune nodes from binary tree. The problem statement is:

Given a binary tree, prune nodes which are not paths with a given sum.

For example, given the below binary tree and given sum as 43, red nodes will be pruned as they are not the paths with sum 43.

### Prune nodes in a binary tree: thoughts

To solve this problem, first, understand how to find paths with a given sum in a binary tree.  To prune all nodes which are not on these paths,  get all the nodes which are not part of any path and then delete those nodes one by one. It requires two traversals of the binary tree.
Is it possible to delete a node while calculating the path with a given sum? At what point we find that this is not the path with given sum? At the leaf node.
Once we know that this leaf node is not part of the path with given sum, we can safely delete it.  What happens to this leaf node? We directly cannot delete the parent node as there may be another subtree which leads to a path with the given sum. Hence for every node, the pruning is dependent on what comes up from its subtrees processing.

At the leaf node, we return to parent false if this leaf node cannot be part of the path and delete the leaf node. At parent node, we look for return values from both the subtrees. If both subtrees return false, it means this node is not part of the path with the given sum. If one of the subtrees returns true, it means the current node is part of a path with the given sum. It should not be deleted and should return true to its parent.

#### Prune nodes from a binary tree: implementation

```#include<stdio.h>
#include<stdlib.h>
#include<math.h>

struct node{
int value;
struct node *left;
struct node *right;
};
typedef struct node Node;

#define true 1
#define false 0

int prunePath(Node *node, int sum ){

if( !node ) return true;

int subSum =  sum - node->value;
/* To check if left tree or right sub tree
contributes to total sum  */

int leftVal = false, rightVal = false;

/*Check if node is leaf node */
int isLeaf = !( node->left || node->right );

/* If node is leaf node and it is part of path with sum
= given sum return true to parent node so tha parent node is
not deleted */
if(isLeaf && !subSum )
return true;

/* If node is leaf and it not part of path with sum
equals to given sum
Return false to parent node */
else if(isLeaf && subSum ){
free(node);
return false;
}
/* If node is not leaf and there is left child
Traverse to left subtree*/
leftVal = prunePath(node->left, subSum);

/* If node is not leaf and there is right child
Traverse to right subtree*/
rightVal = prunePath(node->right, subSum);

/* This is crux of algo.
1. If both left sub tree and right sub tree cannot lead to
path with given sum,Delete the node
2. If any one sub tree can lead to path with sum equal
to given sum, do not delete the node */
if(!(leftVal || rightVal) ){
free(node);
return false;
}
if(leftVal || rightVal ){
if(leftVal)
node->right = NULL;
if(rightVal)
node->left = NULL;
return true;
}
return true ;
}

void inoderTraversal(Node * root){
if(!root)
return;

inoderTraversal(root->left);
printf("%d ", root->value);
inoderTraversal(root->right);
}
Node *createNode(int value){
Node * newNode =  (Node *)malloc(sizeof(Node));
newNode->value = value;
newNode->right= NULL;
newNode->left = NULL;

return newNode;
}
Node *addNode(Node *node, int value){
if(node == NULL){
return createNode(value);
}
else{
if (node->value > value){
node->left = addNode(node->left, value);
}
else{
node->right = addNode(node->right, value);
}
}
return node;
}

/* Driver program for the function written above */
int main(){
Node *root = NULL;
//Creating a binary tree

inoderTraversal(root);
prunePath(root, 65);

printf( "\n");
if( root ){
inoderTraversal(root);
}
return 0;
}

```

The complexity of this algorithm to prune all nodes which are not on the path with a given sum is O(n).

Please share if there is something wrong or missing. If you are preparing for interviews, please signup for free interview material.

## Print paths in a binary tree

We learned various kind of traversals of a binary tree like inorder, preorder and postorder. Paths in a binary tree problem require traversal of a binary tree too like every other problem on a binary tree. The problem statement is:

Given a binary tree, print all paths in that binary tree

What is a path in a binary tree? A path is a collection of nodes from the root to any leaf of the tree. By definition, a leaf node is a node which does not have left or right child. For example, one of the paths in the binary tree below is 10,7,9.

### Paths in a binary tree: thoughts

It is clear from the problem statement that we have to start with root and go all the way to leaf nodes. Question is do we need to start with root from each access each path in binary tree? Well, no. Paths have common nodes in them. Once we reach the end of a path (leaf node), we just move upwards one node at a time and explore other paths from the parent node. Once all paths are explored, we go one level again and explore all paths from there.

This is a typical postorder traversal of a binary tree, we finish the paths in the left subtree of a node before exploring paths on the right subtree We process the root before going into left or right subtree to check if it is the leaf node. We add the current node into the path till now. Once we have explored left and right subtree, the current node is removed from the path.

Let’s take an example and see how does it work. Below is the tree for each we have to print all the paths in it.

First of all our list of paths is empty. We have to create a current path, we start from the root node which is the `node(10)`. Add `node(10)` to the current path. As `node(10)` is not a leaf node, we move towards the left subtree.

`node(7)` is added to the current path. Also, it is not a leaf node either, so we again go down the left subtree.

`node(8)` is added to the current path and this time, it is a leaf node. We put the entire path into the list of paths or print the entire path based on how we want the output.

At this point, we take out`node(8)` from the current path and move up to node(7). As we have traversed the left subtree of,`node(7)` we will traverse right subtree of the node(7).

`node(9)` is added now to the current path. It is also a leaf node, so again, put the path in the list of paths. `node(9)` is moved out of the current path.

Now, left and right subtrees of `node(7)` have been traversed, we remove `node(7)` from the current path too.

At this point, we have only one node in the current path which is the `node(10)` We have already traversed the left subtree of it. So, we will start traversing the right subtree, next we will visit `node(15)` and add it to the current path.

`node(15)` is not a leaf node, so we move down the left subtree. node(18) is added to the current path. `node(18)` is a leaf node too. So, add the entire path to the list of paths. Remove `node(18)` from the current path.

We go next to the right subtree of the `node(15)`, which is the `node(19)`. It is added to the current path. `node(19)` is also a leaf node, so the path is added to the list of paths.

Now, the left and right subtrees of the `node(15)` are traversed, it is removed from the current path and so is the `node(10)`.

#### Print paths in a binary tree: implementation

```package com.company.BST;

import java.util.ArrayList;

/**
* Created by sangar on 21.10.18.
*/
public class PrintPathInBST {
public void printPath(BinarySearchTree tree){
ArrayList<TreeNode> path  = new ArrayList<>();
this.printPathRecursive(tree.getRoot(), path);
}

private void printPathRecursive(TreeNode root,
ArrayList<TreeNode> path){
if(root == null) return;

//If node is leaf node
if(root.getLeft() == null && root.getRight() == null){
path.forEach(node -> System.out.print(" "
+ node.getValue()));
path.remove(path.size()-1);
System.out.println();
return;
}

/*Not a leaf node, add this node to
path and continue traverse */
printPathRecursive(root.getLeft(),path);
printPathRecursive(root.getRight(), path);

//Remove the root node from the path
path.remove(path.size()-1);
}
}
```

Test cases

```package com.company.BST;

/**
* Created by sangar on 10.5.18.
*/
public class BinarySearchTreeTests {
public static void main (String[] args){
BinarySearchTree binarySearchTree = new BinarySearchTree();

binarySearchTree.insert(7);
binarySearchTree.insert(8);
binarySearchTree.insert(6);
binarySearchTree.insert(9);
binarySearchTree.insert(3);
binarySearchTree.insert(4);

binarySearchTree.printPath();
}
}
```

Tree node definition

```package com.company.BST;

/**
* Created by sangar on 21.10.18.
*/
public class TreeNode<T> {
private T value;
private TreeNode left;
private TreeNode right;

public TreeNode(T value) {
this.value = value;
this.left = null;
this.right = null;
}

public T getValue(){
return this.value;
}
public TreeNode getRight(){
return this.right;
}
public TreeNode getLeft(){
return this.left;
}

public void setValue(T value){
this.value = value;
}

public void setRight(TreeNode node){
this.right = node;
}

public void setLeft(TreeNode node){
this.left = node;
}
}

```

Complexity of above algorithm to print all paths in a binary tree is O(n).

Please share if there is something wrong or missing. If you are preparing for Amazon, Microsoft or Google interviews, please signup for interview material for free.

# Inorder predecessor in binary search tree

What is an inorder predecessor in binary tree? Inorder predecessor is the node which traversed before given node in inorder traversal of binary tree.  In binary search tree, it’s the previous big value before a node. For example, inorder predecessor of node(6) in below tree will 5 and for node(10) it’s 6.

If node is leftmost node in BST or least node, then there is no inorder predecessor for that node.

## Inorder predecessor : Thoughts

To find inorder predecessor , first thing to find is the node itself.  As we know in inorder traversal, root node is visited after left subtree.  A node can be predecessor for given node which is on right side of it.

Let’s come up with examples and see what algorithm works. First case, if given node is left most leaf node of tree, there is no inorder predecessor, in that case return NULL. For example, predecessor for node 1 is NULL.

What if node has left subtree? In that case, maximum value in left subtree will be predecessor of given node.  We can find maximum value in tree by going deep down right subtree, till right subtree is NULL, and then return the last node. For example, predecessor node(10) is 6.

What are the other cases? Another case is that node does not have left subtree but it is also not the leftmost leaf node? Then parent of given node will be inorder predecessor. While moving down the tree on right side, keep track of parent node as it may be solution. predecessor of node(12) will be 10 as that’s where we moved to right subtree last time.  Note that we change predecessor candidate only  while moving down right subtree.

### Algorithm to find inorder predecessor

1. Start with root, current = root, successor = NULL.
2. If `node.value` > `current.value`, then predecessor = current, current = current.right.
3. If `node.value` < `current.value`, current = current.left.
4. If `node.value` == `current.value` and node.left!= null, predecessor = maximum(current.left).
5. Return predecessor

### Inorder predevessor: Implementation

```#include<stdio.h>
#include<stdlib.h>

struct node{
int value;
struct node *left;
struct node *right;
};

typedef struct node Node;

/* This function return the maximum node in tree rooted at node root */
Node *findMaximum(Node *root){
if(!root)
return NULL;

while(root->right) root = root->right;
return root;
}
/* This function implements the logic described in algorithm to find inorder predecessor
of a given node */
Node *inorderPredecessor(Node *root, int K){

Node *predecessor 	= NULL;
Node *current  		= root;

if(!root)
return NULL;

while(current && current->value != K){
/* Else take left turn and no need to update predecessor pointer */
if(current->value >K){
current= current->left;
}
/* If node value is less than the node which are looking for, then go to right sub tree
Also when we move right, update the predecessor pointer to keep track of last right turn */
else{
predecessor = current;
current = current->right;
}
}
/*Once we reached at the node for which inorder predecessor is to be found,
check if it has left sub tree, if yes then find the maximum in that right sub tree and return that node
Else last right turn taken node is already stored in predecessor pointer and will be returned*/
if(current && current->left){
predecessor = findMaximum(current->left);
}
return predecessor;
}
Node * createNode(int value){
Node *newNode =  (Node *)malloc(sizeof(Node));

newNode->value = value;
newNode->right= NULL;
newNode->left = NULL;

return newNode;

}

Node * addNode(Node *node, int value){
if(node == NULL){
return createNode(value);
}
else{
if (node->value > value){
node->left = addNode(node->left, value);
}
else{
node->right = addNode(node->right, value);
}
}
return node;
}

/* Driver program for the function written above */
int main(){
Node *root = NULL;
int n = 0;
//Creating a binary tree

Node *predecessor = inorderPredecessor(root, 40);
printf("\n Inorder successor node is : %d ",predecessor ? predecessor->value: 0);

return 0;
}
```

Complexity of algorithm to find inorder predecessor will be O(logN) in almost balanced binary tree. If tree is skewed, then we have worst case complexity of O(N).

Please share if there is something wrong or missing. If you want to contribute to website and share your knowledge with thousands of learners across the world, please reach out to us at [email protected]

# Inorder successor in binary search tree

What is an inorder successor in binary tree? Inorder successor is the node which traversed next to given node in inorder traversal of binary tree.  In binary search tree, it’s the next big value after the node. For example, inorder successor of node(6) in below tree will 10 and for node(12) it’s 14.

If node is the rightmost node or in BST, the greatest node, then there is no inorder successor for that node.

## Inorder successor : Thoughts

To find inorder successor, first thing to find is the node itself.  As we know in inorder traversal, root node is visited after left subtree.  A node can be successor for given node which is on left side of it.

Let’s come up with examples and see what algorithm works. First case, if the node is right most node of tree, there is no inorder successor, in that case return NULL. For example, successor for node 16 is NULL.

What if node has right subtree? In that case, minimum value in right subtree will be successor of given node.  We can find minimum value in tree by going deep down left subtree, till left subtree is NULL, and then return the last node. For example, successor node(5) is 6.

What are the other cases? Another case is that node does not have right subtree? Then parent of given node will be inorder successor. While moving down the tree on left side, keep track of parent node as it may be the solution. Successor of node(7) will be 10 as that’s where we moved to left subtree last time.  Note that we change successor candidate only  while moving down left subtree.

### Algorithm to find inorder successor

1. Start with root, current = root, successor = NULL.
2. If `node.value` < `current.value`, then successor = current, current = current.left.
3. If `node.value` > `current.value`, current = current.right.
4. If `node.value` == `current.value` and node.right != null, successor = minimum(current.right).
5. Return successor

### Inorder successor : Implementation

```#include<stdio.h>
#include<stdlib.h>

struct node{
int value;
struct node *left;
struct node *right;
};

typedef struct node Node;

//this function finds the minimum node in given tree rooted at node root
Node * findMinimum(Node *root){
if(!root)
return NULL;
// Minimum node is left most child. hence traverse down till left most node of tree.
while(root->left) root = root->left;
// return the left most node
return root;
}
/* This function implements the logic described in algorithm to find inorder successor
of a given node */
Node *inorderSuccessor(Node *root, Node *node){

Node *successor = NULL;
Node *current  = root;
if(!root)
return NULL;

while(current->value != node->value){
/* If node value is greater than the node which are looking for, then go to left sub tree
Also when we move left, update the successor pointer to keep track of lst left turn */

if(current->value > node->value){
successor = current;
current= current->left;
}
/* Else take right turn and no need to update successor pointer */
else
current = current->right;
}
/*Once we reached at the node for which inorder successor is to be found,
check if it has right sub tree, if yes then find the minimum in that right sub tree and return taht node
Else last left turn taken node is already stored in successor pointer and will be returned*/
if(current && current->right){
successor = findMinimum(current->right);
}

return successor;
}

Node * createNode(int value){
Node *newNode =  (Node *)malloc(sizeof(Node));

newNode->value = value;
newNode->right= NULL;
newNode->left = NULL;

return newNode;

}

Node * addNode(Node *node, int value){
if(node == NULL){
return createNode(value);
}
else{
if (node->value > value){
node->left = addNode(node->left, value);
}
else{
node->right = addNode(node->right, value);
}
}
return node;
}

/* Driver program for the function written above */
int main(){
Node *root = NULL;
int n = 0;
//Creating a binary tree
Node *node = root;

Node *successor = inorderSuccessor(root, node);
printf("\n Inorder successor node is : %d ",successor ? successor->value: 0);

return 0;
}

```

Complexity of algorithm to find inorder successor will be O(logN) in almost balanced binary tree. If tree is skewed, then we have worst case complexity of O(N).

Please share if there is something wrong or missing. If you want to contribute to website and share your knowledge with thousands of learners across the world, please reach out to us at [email protected]

## Iterative postorder traversal

In last two posts, iterative inorder and iterative preorder traversal, we learned how stack can be used to replace recursion and why recursive implementation can be dangerous in production environment. In this post, let’s discuss iterative postorder traversal of binary tree which is most complex of all traversals. What is post order traversal ? A traversal where  left and right subtrees are visited before root is processed. For example, post order traversal of below tree would be : [1,6,5,12,16,14,10]

## Iterative postorder traversal  : Thoughts

Let’s look at the recursive implementation of postorder.

```    private void postOrder(Node root){
if(root == null) return;

postOrder(root.left);
postOrder(root.right);
System.out.println(root.value);

}
```

As we are going into left subtree and then directly to right subtree, without visiting root node. Can you find the similarity of structure between preorder and postorder implementation?  Can we reverse the entire preorder traversal to get post order traversal? Reverse preorder will give us right child, left child and then root node, however order expected is left child, right child and root child.
Do you remember we pushed left and right node onto stack in order where right child went before left. How about reversing that?

There is one more problem with just reversing the preorder. In preorder, a node was processed as soon as popped from stack, like root node will  be the first node to be processed. However, in postorder, root node is processed last. So, we actually need the order of processing too be reversed. What better than using a stack to store the reverse order of root nodes to processed.
All in all, we will be using two stacks, one to store left and right child, second to store processing order of nodes.

1. Create two stacks s an out and push root node onto s
2. While stack s is not empty
1. op from stack s, `current `= s.pop
2. Put `current` onto stack out.
3. Put left and right child of `current` on to stack s
3. Pop everything from out stack and process it.

### Postorder traversal with two stacks : Implementation

```package com.company.BST;

import java.util.Stack;

/**
* Created by sangar on 22.5.18.
*/
public class BinarySearchTreeTraversal {

private Node root;

public void BinarySearchTree(){
root = null;
}

public class Node {
private int value;
private Node left;
private Node right;

public Node(int value) {
this.value = value;
this.left = null;
this.right = null;
}
}

public void insert(int value){
this.root =  insertNode(this.root, value);
}

private Node insertNode(Node root, int value){
if(root == null){
//if this node is root of tree
root = new Node(value);
}
else{
if(root.value > value){
//If root is greater than value, node should be added to left subtree
root.left = insertNode(root.left, value);
}
else{
//If root is less than value, node should be added to right subtree
root.right = insertNode(root.right, value);
}
}
return root;
}
private void postOrder(Node root){
if(root == null) return;

postOrder(root.left);
postOrder(root.right);
System.out.println(root.value);
}

public void postOrderTraversal(){
postOrderIterative(root);
}

private void postOrderIterative(Node root){
Stack<Node> out = new Stack<>();
Stack<Node> s = new Stack<>();

s.push(root);

while(!s.empty()){
Node current = s.pop();

out.push(current);
if(current.left != null) s.push(current.left);
if(current.right != null) s.push(current.right);
}

while(!out.empty()){
System.out.println(out.pop().value);
}
}
}

```

Complexity of iterative implementation is O(n) with additional space complexity of O(n).

Can we avoid using two stack, and do it with one stack? Problem with root in postorder traversal is that it is visited three times, moving down from parent, coming up from left child and coming up from right child. When should be the node processed? Well, when we are coming up from right child.

How can we keep track of how the current node was reached? If we keep previous pointer, there are three cases:

1. Previous node is parent of current node, we reached node from parent node, nothing is done.
2. Previous node is left child of current node, it means we have visited left child, but still not visited right child, move to right child of current node.
3. Previous node is right child of current node, it means  we have visited left and right child of current node,  process the current node.

Let’s formulate  postorder traversal algorithm then.

1. Push root node onto stack s, set prev = null.
2. Repeat below steps till stack is not empty (!s.empty())
3. `current `= s.pop(), pop from the stack.
4. If (`prev` == null || `prev.left` == current || `prev.right` == current) then
1. If current.left != null, push `current.left` onto stack.
2. If current.right != null, push `current.right` onto stack.
3. If current.left == current.right == null, process `current`.
5. If current.left == prev, i.e. moving up left child then
1. If current.right == null, process `current`.
2. If current.right != null, push it to stack.
6. If current.right == prev i.e moving up from right child
1. process `current`.
2. prev = current, current = s.pop.

### Iterative Postorder traversal : Implementation

```package com.company.BST;

import java.util.Stack;

/**
* Created by sangar on 22.5.18.
*/
public class BinarySearchTreeTraversal {

private Node root;

public void BinarySearchTree(){
root = null;
}

public class Node {
private int value;
private Node left;
private Node right;

public Node(int value) {
this.value = value;
this.left = null;
this.right = null;
}
}

public void insert(int value){
this.root =  insertNode(this.root, value);
}

private Node insertNode(Node root, int value){
if(root == null){
//if this node is root of tree
root = new Node(value);
}
else{
if(root.value > value){
//If root is greater than value, node should be added to left subtree
root.left = insertNode(root.left, value);
}
else{
//If root is less than value, node should be added to right subtree
root.right = insertNode(root.right, value);
}
}
return root;
}

private void inorder(Node root){
if(root == null) return;

if(root.left != null) inorder(root.left);
System.out.println(root.value);
if(root.right != null) inorder(root.right);
}

private void preOrder(Node root){
if(root == null) return;

System.out.println(root.value);
preOrder(root.left);
preOrder(root.right);
}

private void postOrder(Node root){
if(root == null) return;

postOrder(root.left);
postOrder(root.right);
System.out.println(root.value);

}
public void postOrderTraversal(){
//  postOrder(root);
postOrderIterative2(root);
//postOrderIterative(root);
}

private void postOrderIterative2(Node root){
Node prev = null;
Stack<Node> s = new Stack<>();

s.push(root);

while(!s.empty()){
Node current  = s.peek();
if(prev == null || ( prev.left == current || prev.right == current )){
if(current.left != null) s.push(current.left);
else if(current.right != null) s.push(current.right);
}
else if(prev == current.left){
if(current.right != null) s.push(current.right);
}else{
System.out.println(current.value);
s.pop();
}

prev = current;
}
}

}

```

Complexity of code is O(n) again, with additional space complexity of O(n).

Please share if there is something wrong or missing. If you want to contribute and share your learning with thousands of learners across the world, please reach out to us at [email protected]

## Iterative preorder traversal

In last post Iterative inorder traversal , we learned how to do inorder traversal of binary tree without recursion or in iterative way. Today we will learn how to do iterative preorder traversal of binary tree. In preorder traversal, root node is processed before left and right subtrees. For example, preorder traversal of below tree would be [10,5,1,6,14,12,15],

We already know how to implement preorder traversal in recursive way, let’s understand how to implement it in non-recursive way.

## Thought process for preorder traversal

If we look at recursive implementation, preorder traversal is: process the root, left subtree, and then right subtree.

Once the left subtree is processed, control goes to the first node in the right subtree. To emulate this behavior in a non-recursive way, it is best to use a stack. What and when push and pop will happen on the stack?
Start with pushing the root node to stack. Traversal continues till there is at least one node onto the stack.

Pop the root node from stack,process it and push it’s right and left child on to stack. Why right child before left child? Because we want to process left subtree before right subtree. As at every node, we push it’s children onto stack, entire left subtree of node will be processed before right child is popped from the stack. Algorithm is very simple and is as follows.

1. Start with root node and push on to stack s
2. While there stack is not empty
1. Pop from stack `current ` = s.pop() and process the node.
2. Push `current.right` onto to stack.
3. Push `current.left` onto to stack.

Let’s take and example and see how it works. Given below tree, do preorder traversal on it without recursion.

Let’s start from root node(10) and push it onto stack. current = node(10).

Here loop starts, which checks if there is node onto stack. If yes, it pops that out. s.pop will return node(10), we will print it and push it’s right and left child onto stack. Preorder traversal till now : [10].

Since stack is not empty, pop from it.current= node(5). Print it and push it’s right and left child i.e node(6) and node(1) on stack.

Again, stack is not empty, pop from stack. current  = node(1). Print node. There is no right and left child for this node, so we will not push anything on the stack.

Stack is not empty yet, pop again. current= node(6). Print node. Similar to node(1), it also does not have right or left subtree, so nothing gets pushed onto stack.

However, stack is not empty yet. Pop. Current = node(14). Print node, and as there are left and right children, push them onto the stack as a right child before left child.

Stack is not empty, so pop from stack, current = node(12). Print it, as there are no children of node(12), push nothing to stack.

Pop again from the stack as it not empty. current = node(15). Print it. No children, so no need to push anything.

At this point, the stack becomes empty and we have traversed all node of the tree also.

### Implementation

``` public void preorder(TreeNode root){
Stack<TreeNode> stack = new Stack<>();

if(root == null) return ;

TreeNode currentNode = null;
/* Step 1 : Start with root */
stack.push(root);

while(!stack.isEmpty()){
/* Step 5 : Pop the node */
currentNode = stack.pop();

/* Step 2 : Print the node */
System.out.println(currentNode.getValue());

/* Step 3: Push right child first */
if(currentNode.getRight() != null){
stack.push(currentNode.getRight());
}
/* Step 4: Push left child */
if(currentNode.getLeft() != null){
stack.push(currentNode.getLeft());
}
}
}
```

The complexity of iterative implementation of preorder traversal of a binary tree is O(n) as we will be visiting each node at least once. Also, there is added space complexity of stack which is O(n).

Please share if there is something wrong or missing. If you are willing to contribute and share your knowledge with thousands of learners across the world, please reach out to us at [email protected]

## Iterative inorder traversal

One of the most common things we do on a binary tree is traversal. In Binary search tree traversals we discussed different types of traversals like inorder, preorder and postorder traversals. We implemented those traversals in a recursive way. In this post, let’s focus on the iterative implementation of inorder traversal or iterative inorder traversal without recursion.

Before the solution, what is an inorder traversal of a binary tree? In inorder traversal, visit left subtree, then root and at last right subtree. For example, for given tree, inorder traversal would be: [1,5,6,10,12,14,15]

## Inorder traversal iterative: Thoughts

As we go into discussion, one quick question: why recursive inorder implementation is not good? We know that recursion uses implicitly stack to store return address and passed parameters.  As recursion goes deep, there will be more return addresses and parameters stored on the stack, eventually filling up all the space a system has for a stack. This problem is known as stack overflow.
When a binary tree is skewed, that is when every node has only one child, a recursive implementation may lead to stack overflow, depending on the size of the tree. In production systems, we usually do not know the upfront size of data structures, it is advised to avoid recursive implementations.

What are we essentially doing in recursive implementation?  We check if the node is null, then return. If not, we move down the left subtree. When there is nothing on left subtree, we move up to the parent and then go to the right subtree.

All these steps are easy to translate in an iterative way. One thing needs to be thought of is: how to go to parent node? In inorder traversal, the last node visited before the current node is the parent node.
If we keep these nodes on some structure, where we can refer them back, things will be easy.  As we refer the most recent node added to structure first (when finding parent of the node, we have to just look at the last visited node), Stack is a great candidate for it which has last in first (LIFO) out property.

Algorithm

1. Start from the root, call it current .
2. If current is not NULL, push current on to stack.
3. Move to left child of current and go to step 2.
4. If `current`  == NULL and !stack.empty(),  `current` = s.pop.
5. Process current and set `current` = `current.right`, go to step 2.

Let’s take an example and see how this algorithm works.

We start with node(10), current = node(10). Current node is not null, put it on the stack.

As there is left child of node(10), move current = current.left, so current = node(5), which is not null, put node on to stack.

Again, move down to left child of node(5), current = current.left = node(1). Put the node on to stack.

Again move down to the left child, which in this case it is null. What to do now? As the stack is not empty, pop last node added to it. current = node(1). Process node(1). Traversal  = [1]

Move to the right child of node(1), which is null, in that case, pop from the stack and process the node, current  = node(5). Traversal = [1,5]

Move to the right child of node(5) i.e. node(6). Push on to the stack.

Move down to left subtree, which is null, so pop from stack. current = node(6), process it. Traversal = [1,5,6]

Move to right child of node(6), which is null, so pop from stack current = node(10). Process the node. Traversal = [1,5, 6,10]

Get right child of node(10), which is node(14), current = node(14), as current is not null, put it on to stack.

Again move to the left child of the current node (14), which is node(12). current = node(12) which is not null, put it onto the stack.

Get left child of current node, which is null. So pop from stack, current = node(12). Process it. Traversal = [1,5,6,10,12]

Current node = current.right, i.e null, so pop out of stack. current = node(14). Process node(14). Traversal = [1,5,6,10,12,14]

Again current = current.right which is node(15). Put it back on to the stack.

The left child of node(15) is null, so we pop from stack. current = node(15). Process node(15). Fetch right child of the current node which is again null and this time even stack is already empty. So stop processing and everything is done. Traversal = [1,5,6,10,12,14,15]

### Implementation

```#include <stdio.h>
#include<stdlib.h>
#include<math.h>

struct node{
int value;
struct node *left;
struct node *right;
};
typedef struct node Node;

#define STACK_SIZE 10

typedef struct stack{
int top;
Node *items[STACK_SIZE];
}stack;

void push(stack *ms, Node *item){
if(ms->top < STACK_SIZE-1){
ms->items[++(ms->top)] = item;
}
else {
printf("Stack is full\n");
}
}

Node * pop (stack *ms){
if(ms->top > -1 ){
return ms->items[(ms->top)--];
}
else{
printf("Stack is empty\n");
}
}
Node * peek(stack ms){
if(ms.top < 0){
printf("Stack empty\n");
return 0;
}
return ms.items[ms.top];
}
int isEmpty(stack ms){
if(ms.top < 0) return 1;
else return 0;
}

void inorderTraversalWithoutStack(Node *root){
stack ms;
ms.top = -1;
Node *currentNode  = root;
while(!isEmpty(ms) || currentNode ){
if(currentNode){
push(&ms, currentNode);
currentNode = currentNode->left;
}
else {
currentNode = pop(&ms);
printf("%d  ", currentNode->value);
currentNode = currentNode->right;
}
}
}

void inorder (Node * root){
if ( !root ) return;

inorder(root->left);
printf("%d ", root->value );
inorder(root->right);
}

Node * createNode(int value){
Node * temp =  (Node *)malloc(sizeof(Node));
temp->value = value;
temp->right= NULL;
temp->left = NULL;
return temp;
}
Node * addNode(Node *node, int value){
if(node == NULL){
return createNode(value);
}
else{
if (node->value > value){
node->left = addNode(node->left, value);
}
else{
node->right = addNode(node->right, value);
}
}
return node;
}

/* Driver program for the function written above */
int main(){
Node *root = NULL;
//Creating a binary tree