Populate Inorder Successor for all nodes

06 Jun, 2022
Given a Binary Tree where each node has the following structure, write a function to populate the next pointer for all nodes. The next pointer for every node should be set to point to inorder successor.
C++
C
Java
Python3
C#
Javascript
class node {public:    int data;    node* left;    node* right;    node* next;}; // This code is contributed// by Shubham Singh
struct node {    int data;    struct node* left;    struct node* right;    struct node* next;}
// A binary tree nodeclass Node {    int data;    Node left, right, next;     Node(int item)    {        data = item;        left = right = next = null;    }} // This code is contributed by SUBHAMSINGH10.
class Node:    def __init__(self, data):        self.data = data        self.left = None        self.right = None        self.next = None # This code is contributed by Shubham Singh
class Node {    public int data;    public Node left, right, next;     public Node(int item)    {        data = item;        left = right = next = null;    }}Node root; // This code is contributed// by Shubham Singh
<script>class Node{     constructor(x) {        this.data = x;        this.left = null;        this.right = null;      }} // This code is contributed by Shubham Singh</script>
Initially, all next pointers have NULL values. Your function should fill these next pointers so that they point to inorder successor.
Solution (Use Reverse Inorder Traversal) Traverse the given tree in reverse inorder traversal and keep track of previously visited node. When a node is being visited, assign a previously visited node as next.
C++
Java
Python3
C#
Javascript
// C++ program to populate inorder// traversal of all nodes#include <bits/stdc++.h>using namespace std; class node {public:    int data;    node* left;    node* right;    node* next;}; /* Set next of p and all descendants of pby traversing them in reverse Inorder */void populateNext(node* p){    // The first visited node will be the    // rightmost node next of the rightmost    // node will be NULL    static node* next = NULL;     if (p) {        // First set the next pointer        // in right subtree        populateNext(p->right);         // Set the next as previously visited        // node in reverse Inorder        p->next = next;         // Change the prev for subsequent node        next = p;         // Finally, set the next pointer in        // left subtree        populateNext(p->left);    }} /* UTILITY FUNCTIONS *//* Helper function that allocates a newnode with the given data and NULL leftand right pointers. */node* newnode(int data){    node* Node = new node();    Node->data = data;    Node->left = NULL;    Node->right = NULL;    Node->next = NULL;     return (Node);} // Driver Codeint main(){     /* Constructed binary tree is            10            / \        8 12        /    3    */    node* root = newnode(10);    root->left = newnode(8);    root->right = newnode(12);    root->left->left = newnode(3);     // Populates nextRight pointer in all nodes    populateNext(root);     // Let us see the populated values    node* ptr = root->left->left;    while (ptr) {        // -1 is printed if there is no successor        cout << "Next of " << ptr->data << " is "             << (ptr->next ? ptr->next->data : -1) << endl;        ptr = ptr->next;    }     return 0;} // This code is contributed by rathbhupendra
// Java program to populate inorder traversal of all nodes // A binary tree nodeclass Node {    int data;    Node left, right, next;     Node(int item)    {        data = item;        left = right = next = null;    }} class BinaryTree {    Node root;    static Node next = null;     /* Set next of p and all descendants of p by traversing       them in reverse Inorder */    void populateNext(Node node)    {        // The first visited node will be the rightmost node        // next of the rightmost node will be NULL        if (node != null) {            // First set the next pointer in right subtree            populateNext(node.right);             // Set the next as previously visited node in            // reverse Inorder            node.next = next;             // Change the prev for subsequent node            next = node;             // Finally, set the next pointer in left subtree            populateNext(node.left);        }    }     /* Driver program to test above functions*/    public static void main(String args[])    {        /* Constructed binary tree is            10           /   \          8      12         /        3    */        BinaryTree tree = new BinaryTree();        tree.root = new Node(10);        tree.root.left = new Node(8);        tree.root.right = new Node(12);        tree.root.left.left = new Node(3);         // Populates nextRight pointer in all nodes        tree.populateNext(tree.root);         // Let us see the populated values        Node ptr = tree.root.left.left;        while (ptr != null) {            // -1 is printed if there is no successor            int print                = ptr.next != null ? ptr.next.data : -1;            System.out.println("Next of " + ptr.data                               + " is: " + print);            ptr = ptr.next;        }    }} // This code has been contributed by Mayank Jaiswal
# Python3 program to populate# inorder traversal of all nodes # Tree node  class Node:    def __init__(self, data):        self.data = data        self.left = None        self.right = None        self.next = None  # The first visited node will be# the rightmost node next of the# rightmost node will be Nonenext = None # Set next of p and all descendants of p# by traversing them in reverse Inorder  def populateNext(p):     global next     if (p != None):         # First set the next pointer        # in right subtree        populateNext(p.right)         # Set the next as previously visited node        # in reverse Inorder        p.next = next         # Change the prev for subsequent node        next = p         # Finally, set the next pointer        # in left subtree        populateNext(p.left) # UTILITY FUNCTIONS# Helper function that allocates# a new node with the given data# and None left and right pointers.  def newnode(data):     node = Node(0)    node.data = data    node.left = None    node.right = None    node.next = None     return(node) # Driver Code  # Constructed binary tree is#         10#     / \#     8     12# /# 3root = newnode(10)root.left = newnode(8)root.right = newnode(12)root.left.left = newnode(3) # Populates nextRight pointer# in all nodesp = populateNext(root) # Let us see the populated valuesptr = root.left.leftwhile(ptr != None):     out = 0    if(ptr.next != None):        out = ptr.next.data    else:        out = -1     # -1 is printed if there is no successor    print("Next of", ptr.data, "is", out)    ptr = ptr.next # This code is contributed by Arnab Kundu
// C# program to populate inorder traversal of all nodesusing System; class BinaryTree {    // A binary tree node    class Node {        public int data;        public Node left, right, next;         public Node(int item)        {            data = item;            left = right = next = null;        }    }    Node root;    static Node next = null;     /* Set next of p and all descendants of p by traversing       them in reverse Inorder */    void populateNext(Node node)    {        // The first visited node will be the rightmost node        // next of the rightmost node will be NULL        if (node != null) {            // First set the next pointer in right subtree            populateNext(node.right);             // Set the next as previously visited node in            // reverse Inorder            node.next = next;             // Change the prev for subsequent node            next = node;             // Finally, set the next pointer in left subtree            populateNext(node.left);        }    }     /* Driver program to test above functions*/    static public void Main(String[] args)    {        /* Constructed binary tree is            10           /   \          8      12         /        3    */        BinaryTree tree = new BinaryTree();        tree.root = new Node(10);        tree.root.left = new Node(8);        tree.root.right = new Node(12);        tree.root.left.left = new Node(3);         // Populates nextRight pointer in all nodes        tree.populateNext(tree.root);         // Let us see the populated values        Node ptr = tree.root.left.left;        while (ptr != null) {            // -1 is printed if there is no successor            int print                = ptr.next != null ? ptr.next.data : -1;            Console.WriteLine("Next of " + ptr.data                              + " is: " + print);            ptr = ptr.next;        }    }} // This code has been contributed by Arnab Kundu
<script>// Javascript program to populate inorder traversal of all nodes       // A binary tree node    class Node    {             constructor(x) {            this.data = x;            this.left = null;            this.right = null;          }    }         let root;    let next = null;            /* Set next of p and all descendants of p by traversing them in       reverse Inorder */    function populateNext(node)    {        // The first visited node will be the rightmost node        // next of the rightmost node will be NULL        if (node != null)        {            // First set the next pointer in right subtree            populateNext(node.right);               // Set the next as previously visited node in reverse Inorder            node.next = next;               // Change the prev for subsequent node            next = node;               // Finally, set the next pointer in left subtree            populateNext(node.left);        }    }         /* Driver program to test above functions*/         /* Constructed binary tree is            10           /   \          8      12         /        3    */    root = new Node(10)    root.left = new Node(8)    root.right = new Node(12)    root.left.left = new Node(3)      // Populates nextRight pointer    // in all nodes    p = populateNext(root)      // Let us see the populated values    ptr = root.left.left         while (ptr != null)        {            // -1 is printed if there is no successor            let print = ptr.next != null ? ptr.next.data : -1;            document.write("Next of " + ptr.data + " is: " + print+"<br>");            ptr = ptr.next;        }         // This code is contributed by unknown2108</script>
Next of 3 is 8
Next of 8 is 10
Next of 10 is 12
Next of 12 is -1
We can avoid the use of static variables by passing reference to next as a parameter. 
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
C++
C
Java
Python3
C#
Javascript
// An implementation that doesn't use static variable // A wrapper over populateNextRecurvoid populateNext(node* root){    // The first visited node will be the rightmost node    // next of the rightmost node will be NULL    node* next = NULL;     populateNextRecur(root, &next);} /* Set next of all descendants of p bytraversing them in reverse Inorder */void populateNextRecur(node* p, node** next_ref){    if (p) {        // First set the next pointer in right subtree        populateNextRecur(p->right, next_ref);         // Set the next as previously visited        // node in reverse Inorder        p->next = *next_ref;         // Change the prev for subsequent node        *next_ref = p;         // Finally, set the next pointer in right subtree        populateNextRecur(p->left, next_ref);    }} // This is code is contributed by rathbhupendra
// An implementation that doesn't use static variable // A wrapper over populateNextRecurvoid populateNext(struct node* root){    // The first visited node will be the rightmost node    // next of the rightmost node will be NULL    struct node* next = NULL;     populateNextRecur(root, &next);} /* Set next of all descendants of p by traversing them in * reverse Inorder */void populateNextRecur(struct node* p,                       struct node** next_ref){    if (p) {        // First set the next pointer in right subtree        populateNextRecur(p->right, next_ref);         // Set the next as previously visited node in        // reverse Inorder        p->next = *next_ref;         // Change the prev for subsequent node        *next_ref = p;         // Finally, set the next pointer in right subtree        populateNextRecur(p->left, next_ref);    }}
// A wrapper over populateNextRecurvoid populateNext(Node node){     // The first visited node will be the rightmost node    // next of the rightmost node will be NULL    populateNextRecur(node, next);} /* Set next of all descendants of p by traversing them in * reverse Inorder */void populateNextRecur(Node p, Node next_ref){    if (p != null) {         // First set the next pointer in right subtree        populateNextRecur(p.right, next_ref);         // Set the next as previously visited node in        // reverse Inorder        p.next = next_ref;         // Change the prev for subsequent node        next_ref = p;         // Finally, set the next pointer in right subtree        populateNextRecur(p.left, next_ref);    }}
# A wrapper over populateNextRecurdef populateNext(node):     # The first visited node will be the rightmost node    # next of the rightmost node will be NULL    populateNextRecur(node, next) # /* Set next of all descendants of p by# traversing them in reverse Inorder */  def populateNextRecur(p, next_ref):     if (p != None):         # First set the next pointer in right subtree        populateNextRecur(p.right, next_ref)         # Set the next as previously visited node in reverse Inorder        p.next = next_ref         # Change the prev for subsequent node        next_ref = p         # Finally, set the next pointer in right subtree        populateNextRecur(p.left, next_ref) # This code is contributed by Mohit kumar 29
// A wrapper over populateNextRecurvoid populateNext(Node node){     // The first visited node will be the rightmost node    // next of the rightmost node will be NULL    populateNextRecur(node, next);} /* Set next of all descendants of p bytraversing them in reverse Inorder */void populateNextRecur(Node p, Node next_ref){    if (p != null) {         // First set the next pointer in right subtree        populateNextRecur(p.right, next_ref);         // Set the next as previously visited node in        // reverse Inorder        p.next = next_ref;         // Change the prev for subsequent node        next_ref = p;         // Finally, set the next pointer in right subtree        populateNextRecur(p.left, next_ref);    }} // This code is contributed by princiraj1992
<script>    // A wrapper over populateNextRecurfunction populateNext(node){    // The first visited node will be the rightmost node    // next of the rightmost node will be NULL    populateNextRecur(node, next);} /* Set next of all descendants of p bytraversing them in reverse Inorder */function populateNextRecur(p, next_ref){    if (p != null)    {                 // First set the next pointer in right subtree        populateNextRecur(p.right, next_ref);                 // Set the next as previously visited node in reverse Inorder        p.next = next_ref;                 // Change the prev for subsequent node        next_ref = p;                 // Finally, set the next pointer in right subtree        populateNextRecur(p.left, next_ref);    }} // This code is contributed by importantly.</script>
Time Complexity: O(n)
Approach:
Steps:
Create an array or an ArrayList.Store the inorder traversal of the binary tree into the ArrayList (nodes are to be stored).Now traverse the array and replace the next pointer of the node to the immediate right node(next element in the array which is the required inorder successor).
Create an array or an ArrayList.
Store the inorder traversal of the binary tree into the ArrayList (nodes are to be stored).
Now traverse the array and replace the next pointer of the node to the immediate right node(next element in the array which is the required inorder successor).
    list.get(i).next = list.get(i+1)
Implementation:
Java
Python3
C#
Javascript
import java.util.ArrayList; // class Nodeclass Node {    int data;    Node left, right, next;     // constructor for initializing key value and all the    // pointers    Node(int data)    {        this.data = data;        left = right = next = null;    }} public class Solution {    Node root = null;     // list to store inorder sequence    ArrayList<Node> list = new ArrayList<>();     // function for populating next pointer to inorder    // successor    void populateNext()    {         // list = [3,8,10,12]         // inorder successor of the present node is the        // immediate right node for ex: inorder successor of        // 3 is 8        for (int i = 0; i < list.size(); i++) {            // check if it is the last node            // point next of last node(right most) to null            if (i != list.size() - 1) {                list.get(i).next = list.get(i + 1);            }            else {                list.get(i).next = null;            }        }         // Let us see the populated values        Node ptr = root.left.left;        while (ptr != null) {            // -1 is printed if there is no successor            int print                = ptr.next != null ? ptr.next.data : -1;            System.out.println("Next of " + ptr.data                               + " is: " + print);            ptr = ptr.next;        }    }     // insert the inorder into a list to keep track    // of the inorder successor    void inorder(Node root)    {        if (root != null) {            inorder(root.left);            list.add(root);            inorder(root.right);        }    }     // Driver function    public static void main(String args[])    {        Solution tree = new Solution();         /*         10               /   \              8      12             /            3                */        tree.root = new Node(10);        tree.root.left = new Node(8);        tree.root.right = new Node(12);        tree.root.left.left = new Node(3);         // function calls        tree.inorder(tree.root);        tree.populateNext();    }}
# class Nodeclass Node:    def __init__(self, data):        self.data = data        self.next = None        self.right = None        self.left = None  root = None # list to store inorder sequencelist = [] # function for populating next pointer to inorder successor  def populateNext(root):     # list = [3,8,10,12]     # inorder successor of the present Node is the immediate    # right Node    # for ex: inorder successor of 3 is 8    for i in range(len(list)):         # check if it is the last Node        # point next of last Node(right most) to None        if (i != len(list) - 1):            list[i].next = list[i + 1]        else:            list[i].next = None     # Let us see the populated values    ptr = root.left.left    while (ptr != None):         # -1 is printed if there is no successor        pt = -1        if(ptr.next != None):            pt = ptr.next.data        print("Next of ", ptr.data, " is: ", pt)        ptr = ptr.next # insert the inorder into a list to keep track# of the inorder successor  def inorder(root):    if (root != None):        inorder(root.left)        list.append(root)        inorder(root.right)  # Driver functionif __name__ == '__main__':     '''     * 10 / \ 8 12 / 3     '''    root = Node(10)    root.left = Node(8)    root.right = Node(12)    root.left.left = Node(3)     # function calls    inorder(root)    populateNext(root) # This code is contributed by Rajput-Ji
using System;using System.Collections.Generic; // class Nodepublic class Node {    public         int data;    public         Node left,        right, next;     // constructor for initializing key value and all the    // pointers    public         Node(int data)    {        this.data = data;        left = right = next = null;    }} public class Solution {    Node root = null;     // list to store inorder sequence    List<Node> list = new List<Node>();     // function for populating next pointer to inorder    // successor    void populateNext()    {         // list = [3,8,10,12]         // inorder successor of the present node is the        // immediate right node for ex: inorder successor of        // 3 is 8        for (int i = 0; i < list.Count; i++) {            // check if it is the last node            // point next of last node(right most) to null            if (i != list.Count - 1) {                list[i].next = list[i + 1];            }            else {                list[i].next = null;            }        }         // Let us see the populated values        Node ptr = root.left.left;        while (ptr != null) {            // -1 is printed if there is no successor            int print                = ptr.next != null ? ptr.next.data : -1;            Console.WriteLine("Next of " + ptr.data                              + " is: " + print);            ptr = ptr.next;        }    }     // insert the inorder into a list to keep track    // of the inorder successor    void inorder(Node root)    {        if (root != null) {            inorder(root.left);            list.Add(root);            inorder(root.right);        }    }     // Driver function    public static void Main(String[] args)    {        Solution tree = new Solution();         /*         * 10 / \ 8 12 / 3         */        tree.root = new Node(10);        tree.root.left = new Node(8);        tree.root.right = new Node(12);        tree.root.left.left = new Node(3);         // function calls        tree.inorder(tree.root);        tree.populateNext();    }} // This code is contributed by gauravrajput1
<script> // class Nodeclass Node{    // constructor for initializing key value and all the    // pointers    constructor(data)    {        this.data = data;        this.left = this.right = this.next = null;    }} let root = null; // list to store inorder sequencelet list = []; // function for populating next pointer to inorder successorfunction populateNext(){    // list = [3,8,10,12]                  // inorder successor of the present node is the immediate        // right node        // for ex: inorder successor of 3 is 8        for(let i = 0; i < list.length; i++)        {            // check if it is the last node            // point next of last node(right most) to null            if(i != list.length - 1)            {                list[i].next = list[i + 1];            }            else {                list[i].next = null;            }        }                  // Let us see the populated values        let ptr = root.left.left;        while (ptr != null)        {                     // -1 is printed if there is no successor            let print = ptr.next != null ? ptr.next.data : -1;            document.write("Next of " + ptr.data + " is: " + print+"<br>");            ptr = ptr.next;        }} // insert the inorder into a list to keep track// of the inorder successorfunction inorder(root){    if(root != null)    {            inorder(root.left);            list.push(root);            inorder(root.right);        }} // Driver function /*         10               /   \              8      12             /            3                */root = new Node(10);root.left = new Node(8);root.right = new Node(12);root.left.left = new Node(3); // function callsinorder(root);populateNext(); // This code is contributed by avanitrachhadiya2155</script>
Next of 3 is: 8
Next of 8 is: 10
Next of 10 is: 12
Next of 12 is: -1
Approach – 3(Using stack)
Use a stack to store all the left elements corresponding to a node to the point that the node is the leftmost node itself. After this, store all the left of the right of the leftmost node in the stack. Then, until and unless the stack is empty, point the next of the current node to the topmost element of the stack and if the topmost element of the node has a right node, store all the left element of the right of the topmost.
C++
Java
Python3
C#
#include <iostream>#include <stack>using namespace std; struct Node {    int data;    struct Node* left;    struct Node* right;    struct Node* next;     Node(int x)    {        data = x;        left = NULL;        right = NULL;        next = NULL;    }}; Node* inorder(Node* root){    if (root->left == NULL)        return root;    inorder(root->left);} void populateNext(Node* root){    stack<Node*> s;    Node* temp = root;    while (temp->left) {        s.push(temp);        temp = temp->left;    }    Node* curr = temp;    if (curr->right) {        Node* q = curr->right;        while (q) {            s.push(q);            q = q->left;        }    }    while (!s.empty()) {        Node* inorder = s.top();        s.pop();        curr->next = inorder;        if (inorder->right) {            Node* q = inorder->right;            while (q) {                s.push(q);                q = q->left;            }        }        curr = inorder;    }} Node* newnode(int data){    Node* node = new Node(data);    return (node);} int main(){    /* Constructed binary tree is               10               / \              8  12             /            3       */    Node* root = newnode(10);    root->left = newnode(8);    root->right = newnode(12);    root->left->left = newnode(3);    populateNext(root);    Node* ptr = inorder(root);    while (ptr) {        // -1 is printed if there is no successor        cout << "Next of " << ptr->data << " is "             << (ptr->next ? ptr->next->data : -1) << endl;        ptr = ptr->next;    }     return 0;}
import java.util.*; class GFG{   static class Node {    int data;    Node left;    Node right;    Node next;     Node(int x)    {      data = x;      left = null;      right = null;      next = null;    }  };   static Node inorder(Node root)  {    if (root.left == null)      return root;    root = inorder(root.left);    return root;  }   static void populateNext(Node root)  {    Stack<Node> s = new Stack<>();    Node temp = root;    while (temp.left!=null) {      s.add(temp);      temp = temp.left;    }    Node curr = temp;    if (curr.right!=null) {      Node q = curr.right;      while (q!=null) {        s.add(q);        q = q.left;      }    }    while (!s.isEmpty()) {      Node inorder = s.peek();      s.pop();      curr.next = inorder;      if (inorder.right!=null) {        Node q = inorder.right;        while (q!=null) {          s.add(q);          q = q.left;        }      }      curr = inorder;    }  }   static Node newnode(int data)  {    Node node = new Node(data);    return (node);  }   public static void main(String[] args)  {    /* Constructed binary tree is               10               / \              8  12             /            3       */    Node root = newnode(10);    root.left = newnode(8);    root.right = newnode(12);    root.left.left = newnode(3);    populateNext(root);    Node ptr = inorder(root);    while (ptr != null)    {             // -1 is printed if there is no successor      System.out.print("Next of " +  ptr.data+ " is "                       + (ptr.next!=null ? ptr.next.data : -1) +"\n");      ptr = ptr.next;    }  }} // This code is contributed by Rajput-Ji
class GFG:    class Node:        data = 0        left = None        right = None        next = None         def __init__(self, x):            self.data = x            self.left = None            self.right = None            self.next = None     @staticmethod    def inorder(root):        if (root.left == None):            return root        root = GFG.inorder(root.left)        return root     @staticmethod    def populateNext(root):        s = []        temp = root        while (temp.left != None):            s.append(temp)            temp = temp.left        curr = temp        if (curr.right != None):            q = curr.right            while (q != None):                s.append(q)                q = q.left        while (not (len(s) == 0)):            inorder = s[-1]            s.pop()            curr.next = inorder            if (inorder.right != None):                q = inorder.right                while (q != None):                    s.append(q)                    q = q.left            curr = inorder     @staticmethod    def newnode(data):        node = GFG.Node(data)        return (node)     @staticmethod    def main(args):        # Constructed binary tree is        #               10        #               / \        #              8  12        #             /        #            3        root = GFG.newnode(10)        root.left = GFG.newnode(8)        root.right = GFG.newnode(12)        root.left.left = GFG.newnode(3)        GFG.populateNext(root)        ptr = GFG.inorder(root)        while (ptr != None):            # -1 is printed if there is no successor            print("Next of " + str(ptr.data) + " is " +                  str((ptr.next.data if ptr.next != None else -1)) + "\n", end="")            ptr = ptr.next  if __name__ == "__main__":    GFG.main([]) # This code is contributed by mukulsomukesh
using System;using System.Collections.Generic; public class GFG {     public class Node {        public int data;        public Node left;        public Node right;        public Node next;         public Node(int x) {            data = x;            left = null;            right = null;            next = null;        }    };     static Node inorder(Node root) {        if (root.left == null)            return root;        root = inorder(root.left);        return root;    }     static void populateNext(Node root) {        Stack<Node> s = new Stack<Node>();        Node temp = root;        while (temp.left != null) {            s.Push(temp);            temp = temp.left;        }        Node curr = temp;        if (curr.right != null) {            Node q = curr.right;            while (q != null) {                s.Push(q);                q = q.left;            }        }        while (s.Count!=0) {            Node inorder = s.Peek();            s.Pop();            curr.next = inorder;            if (inorder.right != null) {                Node q = inorder.right;                while (q != null) {                    s.Push(q);                    q = q.left;                }            }            curr = inorder;        }    }     static Node newnode(int data) {        Node node = new Node(data);        return (node);    }     public static void Main(String[] args) {        /*         * Constructed binary tree is 10 / \ 8 12 / 3         */        Node root = newnode(10);        root.left = newnode(8);        root.right = newnode(12);        root.left.left = newnode(3);        populateNext(root);        Node ptr = inorder(root);        while (ptr != null) {             // -1 is printed if there is no successor            Console.Write("Next of " + ptr.data + " is " + (ptr.next != null ? ptr.next.data : -1) + "\n");            ptr = ptr.next;        }    }} // This code contributed by Rajput-Ji
Next of 3 is 8
Next of 8 is 10
Next of 10 is 12
Next of 12 is -1
Complexity Analysis:
Time Complexity: O(n), where n is the number of nodes in the tree.  
Space Complexity: O(h), where h is the height of the tree. 
This approach is better because it overcomes the auxiliary stack space complexity in the recursive method and the space complexity in the arrayList method because the stack will at most store the number of elements equal to height of the tree at any given time.
andrew1234
rathbhupendra
princiraj1992
shubham_singh
Akanksha_Rai
mohit kumar 29
unknown2108
avllikhita
importantly
avanitrachhadiya2155
kalrap615
GauravRajput1
simranarora5sos
sweetyty
SHUBHAMSINGH10
simmytarika5
Rajput-Ji
sharmakavi59
mukulsomukesh
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.