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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 `

## Python

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

Output:

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

My Personal Notes arrow_drop_up

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.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.