Flatten Binary Tree in order of Level Order Traversal

• Difficulty Level : Basic
• Last Updated : 17 Dec, 2021

Given a Binary Tree, the task is to flatten it in order of Level order traversal of the tree. In the flattened binary tree, the left node of all the nodes must be NULL.
Examples:

Input:
1
/   \
5     2
/ \   / \
6   4 9   3
Output: 1 5 2 6 4 9 3

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

Approach: We will solve this problem by simulating the Level order traversal of Binary Tree as follows:

1. Create a queue to store the nodes of Binary tree.
2. Create a variable “prev” and initialise it by parent node.
3. Push left and right children of parent in the queue.
4. Apply level order traversal. Lets say “curr” is front most element in queue. Then,
• If ‘curr’ is NULL, continue.
• Else push curr->left and curr->right in the queue
• Set prev = curr

Below is the implementation of the above approach:

C++

 // C++ implementation of the approach#include using namespace std; // Node of the Binary treestruct node {    int data;    node* left;    node* right;    node(int data)    {        this->data = data;        left = NULL;        right = NULL;    }}; // Function to flatten Binary tree using// level order traversalvoid flatten(node* parent){    // Queue to store nodes    // for BFS    queue q;    q.push(parent->left);    q.push(parent->right);    node* prev = parent;     // Code for BFS    while (q.size()) {                 // Size of queue        int s = q.size();        while (s--) {                         // Front most node in            // the queue            node* curr = q.front();            q.pop();             // Base case            if (curr == NULL)                continue;            prev->right = curr;            prev->left = NULL;            prev = curr;             // Pushing new elements            // in queue            q.push(curr->left);            q.push(curr->right);        }    }     prev->left = NULL;    prev->right = NULL;} // Function to print flattened// Binary Treevoid print(node* parent){    node* curr = parent;    while (curr != NULL)        cout << curr->data << " ", curr = curr->right;} // Driver codeint main(){    node* root = new node(1);    root->left = new node(5);    root->right = new node(2);    root->left->left = new node(6);    root->left->right = new node(4);    root->right->left = new node(9);    root->right->right = new node(3);     // Calling required functions    flatten(root);    print(root);         return 0;}

Java

 // Java implementation of the approachimport java.util.*; class GFG{     // Node of the Binary treestatic class node{    int data;    node left;    node right;    node(int data)    {        this.data = data;        left = null;        right = null;    }}; // Function to flatten Binary tree using// level order traversalstatic void flatten(node parent){    // Queue to store nodes    // for BFS    Queue q = new LinkedList<>();    q.add(parent.left);    q.add(parent.right);    node prev = parent;     // Code for BFS    while (q.size() > 0)    {                 // Size of queue        int s = q.size();        while (s-- > 0)        {                         // Front most node in            // the queue            node curr = q.peek();            q.remove();             // Base case            if (curr == null)                continue;            prev.right = curr;            prev.left = null;            prev = curr;             // Pushing new elements            // in queue            q.add(curr.left);            q.add(curr.right);        }    }    prev.left = null;    prev.right = null;} // Function to print flattened// Binary Treestatic void print(node parent){    node curr = parent;    while (curr != null)    {        System.out.print(curr.data + " ");        curr = curr.right;    }} // Driver codepublic static void main(String[] args){    node root = new node(1);    root.left = new node(5);    root.right = new node(2);    root.left.left = new node(6);    root.left.right = new node(4);    root.right.left = new node(9);    root.right.right = new node(3);     // Calling required functions    flatten(root);    print(root);}} // This code is contributed by Rajput-Ji

Python3

 # Python implementation of above algorithm # Utility class to create a nodeclass node:    def __init__(self, key):        self.data = key        self.left = self.right = None # Function to flatten Binary tree using# level order traversaldef flatten( parent):     # Queue to store nodes    # for BFS    q = []    q.append(parent.left)    q.append(parent.right)    prev = parent     # Code for BFS    while (len(q) > 0) :                 # Size of queue        s = len(q)        while (s > 0) :            s = s - 1                         # Front most node in            # the queue            curr = q            q.pop(0)             # Base case            if (curr == None):                continue            prev.right = curr            prev.left = None            prev = curr             # appending elements            # in queue            q.append(curr.left)            q.append(curr.right)             prev.left = None    prev.right = None # Function to print flattened# Binary Treedef print_(parent):     curr = parent    while (curr != None):        print( curr.data , end=" ")        curr = curr.right # Driver coderoot = node(1)root.left = node(5)root.right = node(2)root.left.left = node(6)root.left.right = node(4)root.right.left = node(9)root.right.right = node(3) # Calling required functionsflatten(root)print_(root)     # This code is contributed by Arnab Kundu

C#

 // C# implementation of the approachusing System;using System.Collections.Generic; class GFG{     // Node of the Binary treepublic class node{    public int data;    public node left;    public node right;    public node(int data)    {        this.data = data;        left = null;        right = null;    }}; // Function to flatten Binary tree using// level order traversalstatic void flatten(node parent){    // Queue to store nodes    // for BFS    Queue q = new Queue();    q.Enqueue(parent.left);    q.Enqueue(parent.right);    node prev = parent;     // Code for BFS    while (q.Count > 0)    {                 // Size of queue        int s = q.Count;        while (s-- > 0)        {                         // Front most node in            // the queue            node curr = q.Peek();            q.Dequeue();             // Base case            if (curr == null)                continue;            prev.right = curr;            prev.left = null;            prev = curr;             // Pushing new elements            // in queue            q.Enqueue(curr.left);            q.Enqueue(curr.right);        }    }    prev.left = null;    prev.right = null;} // Function to print flattened// Binary Treestatic void print(node parent){    node curr = parent;    while (curr != null)    {        Console.Write(curr.data + " ");        curr = curr.right;    }} // Driver codepublic static void Main(String[] args){    node root = new node(1);    root.left = new node(5);    root.right = new node(2);    root.left.left = new node(6);    root.left.right = new node(4);    root.right.left = new node(9);    root.right.right = new node(3);     // Calling required functions    flatten(root);    print(root);}} // This code is contributed by Rajput-Ji

Javascript



Output :

1 5 2 6 4 9 3

Time Complexity: O(N)
Space Complexity: O(N) where N is the size of Binary Tree.

My Personal Notes arrow_drop_up