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 inorder 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 nodeclass 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
<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++
// 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
// 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
# Python3 program to populate# inorder traversal of all nodes# Tree nodeclass 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 Inorderdef 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#
// 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 |
Javascript
<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> |
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 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 |
C
// 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); }} |
Java
// 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); }} |
Python3
# 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 |
C#
// 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 |
Javascript
<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).
list.get(i).next = list.get(i+1)
Implementation:
C++
// C++ Program to populate inorder successor for all nodes#include <bits/stdc++.h>using namespace std;// class Nodeclass Node {public: int data; Node *left, *right, *next; // constructor for initializing key value and all the // pointers Node(int data) { this->data = data; left = right = next = nullptr; }};// function for populating next pointer to inorder// successorvoid populateNext(Node*& root, vector<Node*>& list){ // 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[i]->next = list[i + 1]; else list[i]->next = nullptr; } // Let us see the populated values Node* ptr = root->left->left; while (ptr) { // -1 is printed if there is no successor int print = ptr->next ? ptr->next->data : -1; cout << "Next of " << ptr->data << " is: " << print << endl; ptr = ptr->next; }}// insert the inorder into a list to keep track// of the inorder successorvoid inorder(Node* root, vector<Node*>& list){ if (root) { inorder(root->left, list); list.push_back(root); inorder(root->right, list); }}// Driver functionint main(){ /* 10 / \ 8 12 / 3 */ Node* root = new Node(10); root->left = new Node(8); root->right = new Node(12); root->left->left = new Node(3); // list to store inorder sequence vector<Node*> list; // function calls inorder(root, list); populateNext(root, list); return 0;}// This code is contributed Tapesh(tapeshdua420) |
Java
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(); }} |
Python3
# class Nodeclass Node: def __init__(self, data): self.data = data self.next = None self.right = None self.left = Noneroot = None# list to store inorder sequencelist = []# function for populating next pointer to inorder successordef 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 successordef 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 |
C#
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 |
Javascript
<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> |
Output
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++
#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;} |
Java
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 |
Python3
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.nextif __name__ == "__main__": GFG.main([])# This code is contributed by mukulsomukesh |
C#
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 |
Output
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.
Please Login to comment...