Open In App

# Populate Inorder Successor for all nodes

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 in-order successor.

## C++

 `class` `node {``public``:``    ``int` `data;``    ``node* left;``    ``node* right;``    ``node* next;``};` `// This code is contributed``// by Shubham Singh`

## C

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

## Java

 `// A binary tree node``class` `Node {``    ``int` `data;``    ``Node left, right, next;` `    ``Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = next = ``null``;``    ``}``}` `// This code is contributed by SUBHAMSINGH10.`

## Python3

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

## C#

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

## Javascript

 ``

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

Time Complexity: O(n)
Auxiliary Space : O(1)