Related Articles

# Populate Inorder Successor for all nodes

• Difficulty Level : Medium
• Last Updated : 01 Jul, 2021

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

 `struct` `node``{``  ``int` `data;``  ``struct` `node* left;``  ``struct` `node* right;``  ``struct` `node* next;``}`

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

 `// C++ program to populate inorder``// traversal of all nodes``#include``using` `namespace` `std;` `class` `node``{``    ``public``:``    ``int` `data;``    ``node *left;``    ``node *right;``    ``node *next;``};` `/* Set next of p and all descendants of p``by 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 new``node with the given data and NULL left``and 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 Code``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);` `    ``// 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

 `// Java program to populate inorder traversal of all nodes`` ` `// A binary tree node``class` `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

 `# 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 None``next` `=` `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``# /``# 3``root ``=` `newnode(``10``)``root.left ``=` `newnode(``8``)``root.right ``=` `newnode(``12``)``root.left.left ``=` `newnode(``3``)` `# Populates nextRight pointer``# in all nodes``p ``=` `populateNext(root)` `# Let us see the populated values``ptr ``=` `root.left.left``while``(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#

 `// C# program to populate inorder traversal of all nodes``using` `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`

## Javascript

 ``

Output:

```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.

## C++

 `// An implementation that doesn't use static variable` `// A wrapper over populateNextRecur``void` `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 descendents of p by``traversing 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`

## C

 `// An implementation that doesn't use static variable` `// A wrapper over populateNextRecur``void` `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);``    ``}``}`

## Java

 `// A wrapper over populateNextRecur``    ``void` `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);``        ``}``    ``}`

## Python3

 `# A wrapper over populateNextRecur``def` `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`

## C#

 `    ``// A wrapper over populateNextRecur``    ``void` `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);``        ``}``    ``}` `// This code is contributed by princiraj1992`

## Javascript

 ``

Time Complexity: O(n)

Approach:

Steps:

1. Create an array or an ArrayList.
2. Store the inorder traversal of the binary tree into the ArrayList (nodes are to be stored).
3. 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

 `import` `java.util.ArrayList;` `//class Node``class` `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 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``        ``//foe ex: inorder succesoor of 3 is 8``        ``for``(``int` `i=``0``;i

## Javascript

 ``
Output
```Next of 3 is: 8
Next of 8 is: 10
Next of 10 is: 12
Next of 12 is: -1```

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up