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.
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 node class 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++ 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 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 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 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# 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 |
<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
Time Complexity: O(n)
Auxiliary Space : O(1)