Flatten binary tree in order of post-order traversal

Given a binary tree, the task is to flatten it in order of its post-order traversal. In the flattened binary tree, the left node of all the nodes must be NULL.

Examples:

Input: 
          5 
        /   \ 
       3     7 
      / \   / \ 
     2   4 6   8
Output: 2 4 3 6 8 7 5

Input:
      1
       \
        2
         \
          3
           \
            4
             \
              5
Output: 5 4 3 2 1

A simple approach will be to recreate the Binary Tree from its post-order traversal. This will take O(N) extra space were N is the number of nodes in BST.



A better solution is to simulate post-order traversal of the given binary tree.

  1. Create a dummy node.
  2. Create variable called ‘prev’ and make it point to the dummy node.
  3. Perform post-order traversal and at each step.
    • Set prev -> right = curr
    • Set prev -> left = NULL
    • Set prev = curr

This will improve the space complexity to O(H) in the worst case as post-order traversal takes O(H) extra space.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Node of the binary tree
struct node {
    int data;
    node* left;
    node* right;
    node(int data)
    {
        this->data = data;
        left = NULL;
        right = NULL;
    }
};
  
// Function to print the flattened
// binary Tree
void print(node* parent)
{
    node* curr = parent;
    while (curr != NULL)
        cout << curr->data << " ", curr = curr->right;
}
  
// Function to perform post-order traversal
// recursively
void postorder(node* curr, node*& prev)
{
    // Base case
    if (curr == NULL)
        return;
    postorder(curr->left, prev);
    postorder(curr->right, prev);
    prev->left = NULL;
    prev->right = curr;
    prev = curr;
}
  
// Function to flatten the given binary tree
// using post order traversal
node* flatten(node* parent)
{
    // Dummy node
    node* dummy = new node(-1);
  
    // Pointer to previous element
    node* prev = dummy;
  
    // Calling post-order traversal
    postorder(parent, prev);
  
    prev->left = NULL;
    prev->right = NULL;
    node* ret = dummy->right;
  
    // Delete dummy node
    delete dummy;
    return ret;
}
  
// Driver code
int main()
{
    node* root = new node(5);
    root->left = new node(3);
    root->right = new node(7);
    root->left->left = new node(2);
    root->left->right = new node(4);
    root->right->left = new node(6);
    root->right->right = new node(8);
  
    print(flatten(root));
  
    return 0;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// Java implementation of the approach 


class GFG 


{ 


  


// Node of the binary tree 


static class node  


{ 


    int data; 


    node left; 


    node right; 


    node(int data) 


    { 


        this.data = data; 


        left = null; 


        right = null; 


    } 


}; 


static node prev; 


  


// Function to print the flattened 


// binary Tree 


static void print(node parent) 


{ 


    node curr = parent; 


    while (curr != null) 


    { 


        System.out.print(curr.data + " "); 


        curr = curr.right; 


    } 


} 


  


// Function to perform post-order traversal 


// recursively 


static void postorder(node curr) 


{ 


    // Base case 


    if (curr == null) 


        return; 


    postorder(curr.left); 


    postorder(curr.right); 


    prev.left = null; 


    prev.right = curr; 


    prev = curr; 


} 


  


// Function to flatten the given binary tree 


// using post order traversal 


static node flatten(node parent) 


{ 


    // Dummy node 


    node dummy = new node(-1); 


  


    // Pointer to previous element 


    prev = dummy; 


  


    // Calling post-order traversal 


    postorder(parent); 


  


    prev.left = null; 


    prev.right = null; 


    node ret = dummy.right; 


  


    // Delete dummy node 


    dummy = null; 


    return ret; 


} 


  


// Driver code 


public static void main(String[] args) 


{ 


    node root = new node(5); 


    root.left = new node(3); 


    root.right = new node(7); 


    root.left.left = new node(2); 


    root.left.right = new node(4); 


    root.right.left = new node(6); 


    root.right.right = new node(8); 


  


    print(flatten(root)); 


} 


}  


  


// This code is contributed by PrinciRaj1992 



















                        chevron_right







                        filter_none









Python














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python implementation of above algorithm 


  


# Utility class to create a node  


class node:  


    def __init__(self, key):  


        self.data = key  


        self.left = self.right = None


  


# Function to print the flattened 


# binary Tree 


def print_(parent): 


  


    curr = parent 


    while (curr != None): 


        print( curr.data ,end = " ") 


        curr = curr.right 


  


prev = None


  


# Function to perform post-order traversal 


# recursively 


def postorder( curr ): 


      


    global prev 


      


    # Base case 


    if (curr == None): 


        return


    postorder(curr.left) 


    postorder(curr.right) 


    prev.left = None


    prev.right = curr 


    prev = curr 


  


# Function to flatten the given binary tree 


# using post order traversal 


def flatten(parent): 


  


    global prev 


      


    # Dummy node 


    dummy = node(-1) 


  


    # Pointer to previous element 


    prev = dummy 


  


    # Calling post-order traversal 


    postorder(parent) 


  


    prev.left = None


    prev.right = None


    ret = dummy.right 


  


    return ret 


  


# Driver code 


root = node(5) 


root.left = node(3) 


root.right = node(7) 


root.left.left = node(2) 


root.left.right = node(4) 


root.right.left = node(6) 


root.right.right = node(8) 


  


print_(flatten(root)) 


  


  


# This code is contributed by Arnab Kundu 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// C# implementation of the approach 


using System; 


  


class GFG 


{ 


  


// Node of the binary tree 


public class node  


{ 


    public int data; 


    public node left; 


    public node right; 


    public node(int data) 


    { 


        this.data = data; 


        left = null; 


        right = null; 


    } 


}; 


static node prev; 


  


// Function to print the flattened 


// binary Tree 


static void print(node parent) 


{ 


    node curr = parent; 


    while (curr != null) 


    { 


        Console.Write(curr.data + " "); 


        curr = curr.right; 


    } 


} 


  


// Function to perform post-order traversal 


// recursively 


static void postorder(node curr) 


{ 


    // Base case 


    if (curr == null) 


        return; 


    postorder(curr.left); 


    postorder(curr.right); 


    prev.left = null; 


    prev.right = curr; 


    prev = curr; 


} 


  


// Function to flatten the given binary tree 


// using post order traversal 


static node flatten(node parent) 


{ 


    // Dummy node 


    node dummy = new node(-1); 


  


    // Pointer to previous element 


    prev = dummy; 


  


    // Calling post-order traversal 


    postorder(parent); 


  


    prev.left = null; 


    prev.right = null; 


    node ret = dummy.right; 


  


    // Delete dummy node 


    dummy = null; 


    return ret; 


} 


  


// Driver code 


public static void Main(String[] args) 


{ 


    node root = new node(5); 


    root.left = new node(3); 


    root.right = new node(7); 


    root.left.left = new node(2); 


    root.left.right = new node(4); 


    root.right.left = new node(6); 


    root.right.right = new node(8); 


  


    print(flatten(root)); 


} 


} 


  


// This code is contributed by Princi Singh 



















                        chevron_right







                        filter_none











Output:


2 4 3 6 8 7 5






          
          
          

          

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
DivyanshuShekhar1
Check out this Author's contributed articles.
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on  the "Improve Article" button below.