# Flatten binary tree in order of post-order traversal

• Difficulty Level : Easy
• Last Updated : 14 Aug, 2021

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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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

 `// C++ implementation of the approach``#include ``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;``}`

## Java

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

## Python3

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

## C#

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

## Javascript

 ``
Output:
`2 4 3 6 8 7 5`

Time complexity: O(N)
Auxiliary Space: O(N).

My Personal Notes arrow_drop_up