Given a Binary Tree where each node has following structure, write a function to populate next pointer for all nodes. The next pointer for every node should be set to point to inorder successor.
struct node { int data; struct node* left; struct node* right; struct node* next; } |
chevron_right
filter_none
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 previously visited node as next.
C
// C program to populate inorder traversal of all nodes #include <stdio.h> #include <stdlib.h> struct node { int data; struct node *left; struct node *right; struct node *next; }; /* Set next of p and all descendents of p by traversing them in reverse Inorder */void populateNext(struct node* p) { // The first visited node will be the rightmost node // next of the rightmost node will be NULL static struct 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. */struct node* newnode(int data) { struct node* node = (struct node*) malloc(sizeof(struct node)); node->data = data; node->left = NULL; node->right = NULL; node->next = NULL; return(node); } /* Driver program to test above functions*/int main() { /* Constructed binary tree is 10 / \ 8 12 / 3 */ struct 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 struct node *ptr = root->left->left; while(ptr) { // -1 is printed if there is no successor printf("Next of %d is %d \n", ptr->data, ptr->next? ptr->next->data: -1); ptr = ptr->next; } return 0; } |
chevron_right
filter_none
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 descendents 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 |
chevron_right
filter_none
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 descendents 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 |
chevron_right
filter_none
We can avoid the use of static variable by passing reference to next as paramater.
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 descendents 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); } } |
chevron_right
filter_none
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 descendents 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); } } |
chevron_right
filter_none
Time Complexity: O(n)
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Recommended Posts:
- Tree Traversals (Inorder, Preorder and Postorder)
- Check sum of Covered and Uncovered nodes of Binary Tree
- Program to count leaf nodes in a binary tree
- Inorder Tree Traversal without Recursion
- Inorder Tree Traversal without recursion and without stack!
- Construct Tree from given Inorder and Preorder traversals
- Print nodes at k distance from root
- Connect nodes at same level
- Connect nodes at same level using constant extra space
- Construct Special Binary Tree from given Inorder traversal
- Difference between sums of odd level and even level nodes of a Binary Tree
- Print Postorder traversal from given Inorder and Preorder traversals
- Remove all nodes which don't lie in any path with sum>= k
- Print all nodes that don't have sibling
- Find distance between two nodes of a Binary Tree
Improved By : andrew1234