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

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