Flip Binary Tree

05 Jul, 2022
AGiven a binary tree, the task is to flip the binary tree towards the right direction that is clockwise. See the below examples to see the transformation.
In the flip operation, the leftmost node becomes the root of the flipped tree and its parent becomes its right child and the right sibling becomes its left child and the same should be done for all left most nodes recursively. 
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
Below is the main rotation code of a subtree 
    root->left->left = root->right;
    root->left->right = root;
    root->left = NULL;
    root->right = NULL; 
The above code can be understood by the following diagram – 
As we are storing root->left in the flipped root, flipped subtree gets stored in each recursive call.
Implementation:
C++
Java
Python3
C#
Javascript
/*  C/C++ program to flip a binary tree */#include <bits/stdc++.h>using namespace std; /* A binary tree node structure */struct Node{    int data;    Node *left, *right;}; /* Utility function to create a new Binary   Tree Node */struct Node* newNode(int data){    struct Node *temp = new struct Node;    temp->data = data;    temp->left = temp->right = NULL;    return temp;} // method to flip the binary treeNode* flipBinaryTree(Node* root){    // Base cases    if (root == NULL)        return root;    if (root->left == NULL && root->right == NULL)        return root;     //  recursively call the same method    Node* flippedRoot = flipBinaryTree(root->left);     //  rearranging main root Node after returning    // from recursive call    root->left->left = root->right;    root->left->right = root;    root->left = root->right = NULL;     return flippedRoot;} // Iterative method to do level order traversal// line by linevoid printLevelOrder(Node *root){    // Base Case    if (root == NULL)  return;     // Create an empty queue for level order traversal    queue<Node *> q;     // Enqueue Root and initialize height    q.push(root);     while (1)    {        // nodeCount (queue size) indicates number        // of nodes at current level.        int nodeCount = q.size();        if (nodeCount == 0)            break;         // Dequeue all nodes of current level and        // Enqueue all nodes of next level        while (nodeCount > 0)        {            Node *node = q.front();            cout << node->data << " ";            q.pop();            if (node->left != NULL)                q.push(node->left);            if (node->right != NULL)                q.push(node->right);            nodeCount--;        }        cout << endl;    }} //  Driver codeint main(){    Node* root = newNode(1);    root->left = newNode(2);    root->right = newNode(3);    root->right->left = newNode(4);    root->right->right = newNode(5);     cout << "Level order traversal of given tree\n";    printLevelOrder(root);     root = flipBinaryTree(root);     cout << "\nLevel order traversal of the flipped"            " tree\n";    printLevelOrder(root);    return 0;}
/*  Java program to flip a binary tree */import java.util.Queue;import java.util.LinkedList;public class FlipTree {     // method to flip the binary tree    public static Node flipBinaryTree(Node root)    {        if (root == null)            return root;        if (root.left == null && root.right ==null)            return root;         //  recursively call the same method        Node flippedRoot=flipBinaryTree(root.left);         //  rearranging main root Node after returning        // from recursive call        root.left.left=root.right;        root.left.right=root;        root.left=root.right=null;        return flippedRoot;    }     // Iterative method to do level order traversal    // line by line    public static void printLevelOrder(Node root)    {        // Base Case        if(root==null)            return ;                 // Create an empty queue for level order traversal        Queue<Node> q=new LinkedList<>();        // Enqueue Root and initialize height        q.add(root);        while(true)        {            // nodeCount (queue size) indicates number            // of nodes at current level.            int nodeCount = q.size();            if (nodeCount == 0)                break;                         // Dequeue all nodes of current level and            // Enqueue all nodes of next level            while (nodeCount > 0)            {                Node node = q.remove();                System.out.print(node.data+" ");                if (node.left != null)                    q.add(node.left);                if (node.right != null)                    q.add(node.right);                nodeCount--;            }            System.out.println();        }    }     public static void main(String args[]) {        Node root=new Node(1);        root.left=new Node(2);        root.right=new Node(1);        root.right.left = new Node(4);        root.right.right = new Node(5);        System.out.println("Level order traversal of given tree");        printLevelOrder(root);           root = flipBinaryTree(root);        System.out.println("Level order traversal of flipped tree");        printLevelOrder(root);    }} /* A binary tree node structure */class Node{    int data;    Node left, right;    Node(int data)    {        this.data=data;    }}; //This code is contributed by Gaurav Tiwari
# Python3 program to flip# a binary tree # A binary tree nodeclass Node:         # Constructor to create    # a new node    def __init__(self, data):               self.data = data        self.right = None        self.left = None def flipBinaryTree(root):         # Base Cases    if root is None:        return root         if (root.left is None and        root.right is None):        return root     # Recursively call the    # same method    flippedRoot = flipBinaryTree(root.left)     # Rearranging main root Node    # after returning from    # recursive call    root.left.left = root.right    root.left.right = root    root.left = root.right = None     return flippedRoot # Iterative method to do the level# order traversal line by linedef printLevelOrder(root):         # Base Case    if root is None:        return         # Create an empty queue for    # level order traversal    from Queue import Queue    q = Queue()         # Enqueue root and initialize    # height    q.put(root)         while(True):         # nodeCount (queue size) indicates        # number of nodes at current level        nodeCount = q.qsize()        if nodeCount == 0:            break         # Dequeue all nodes of current        # level and Enqueue all nodes        # of next level          while nodeCount > 0:            node = q.get()            print node.data,            if node.left is not None:                q.put(node.left)            if node.right is not None:                q.put(node.right)            nodeCount -= 1         print         # Driver coderoot = Node(1)root.left = Node(2)root.right = Node(3)root.right.left = Node(4)root.right.right = Node(5) print "Level order traversal of given tree"printLevelOrder(root) root = flipBinaryTree(root) print "\nLevel order traversal of the flipped tree"printLevelOrder(root) # This code is contributed by Nikhil Kumar Singh(nickzuck_007)
// C# program to flip a binary treeusing System;using System.Collections.Generic; public class FlipTree{     // method to flip the binary tree    public static Node flipBinaryTree(Node root)    {        if (root == null)            return root;        if (root.left == null && root.right ==null)            return root;         // recursively call the same method        Node flippedRoot = flipBinaryTree(root.left);         // rearranging main root Node after returning        // from recursive call        root.left.left = root.right;        root.left.right = root;        root.left = root.right = null;        return flippedRoot;    }     // Iterative method to do level order traversal    // line by line    public static void printLevelOrder(Node root)    {        // Base Case        if(root == null)            return ;                 // Create an empty queue for level order traversal        Queue<Node> q = new Queue<Node>();                 // Enqueue Root and initialize height        q.Enqueue(root);        while(true)        {            // nodeCount (queue size) indicates number            // of nodes at current level.            int nodeCount = q.Count;            if (nodeCount == 0)                break;                         // Dequeue all nodes of current level and            // Enqueue all nodes of next level            while (nodeCount > 0)            {                Node node = q.Dequeue();                Console.Write(node.data+" ");                if (node.left != null)                    q.Enqueue(node.left);                if (node.right != null)                    q.Enqueue(node.right);                nodeCount--;            }            Console.WriteLine();        }    }     // Driver code    public static void Main(String []args)    {        Node root = new Node(1);        root.left = new Node(2);        root.right = new Node(1);        root.right.left = new Node(4);        root.right.right = new Node(5);        Console.WriteLine("Level order traversal of given tree");        printLevelOrder(root);             root = flipBinaryTree(root);        Console.WriteLine("Level order traversal of flipped tree");        printLevelOrder(root);    }} /* A binary tree node structure */public class Node{    public int data;    public Node left, right;    public Node(int data)    {        this.data = data;    }}; // This code is contributed by Princi Singh
<script>/*  Javascript program to flip a binary tree */         /* A binary tree node structure */    class Node    {                 constructor( data)        {            this.data = data;            this.left=this.right=null;        }    };         // method to flip the binary tree    function flipBinaryTree(root)    {         if (root == null)            return root;        if (root.left == null && root.right ==null)            return root;          //  recursively call the same method        let flippedRoot=flipBinaryTree(root.left);          //  rearranging main root Node after returning        // from recursive call        root.left.left=root.right;        root.left.right=root;        root.left=root.right=null;        return flippedRoot;    }         // Iterative method to do level order traversal    // line by line    function printLevelOrder(root)    {        // Base Case        if(root==null)            return ;                  // Create an empty queue for level order traversal        let q=[];        // Enqueue Root and initialize height        q.push(root);        while(true)        {            // nodeCount (queue size) indicates number            // of nodes at current level.            let nodeCount = q.length;            if (nodeCount == 0)                break;                          // Dequeue all nodes of current level and            // Enqueue all nodes of next level            while (nodeCount > 0)            {                let node = q.shift();                document.write(node.data+" ");                if (node.left != null)                    q.push(node.left);                if (node.right != null)                    q.push(node.right);                nodeCount--;            }            document.write("<br>");        }    }         let root=new Node(1);        root.left=new Node(2);        root.right=new Node(3);        root.right.left = new Node(4);        root.right.right = new Node(5);        document.write("Level order traversal of given tree<br>");        printLevelOrder(root);            root = flipBinaryTree(root);        document.write("Level order traversal of flipped tree<br>");        printLevelOrder(root);              // This code is contributed by unknown2108</script>
Level order traversal of given tree
1 
2 3 
4 5 

Level order traversal of the flipped tree
2 
3 1 
4 5 
Iterative Approach: This approach is contributed by Pal13. The iterative solution follows the same approach as the recursive one, the only thing we need to pay attention to is to save the node information that will be overwritten. 
Implementation:
C++
Java
Python3
C#
Javascript
//  C/C++ program to flip a binary tree#include <bits/stdc++.h>using namespace std; // A binary tree node structurestruct Node{    int data;    Node *left, *right;}; // Utility function to create a new Binary// Tree Nodestruct Node* newNode(int data){    struct Node *temp = new struct Node;    temp->data = data;    temp->left = temp->right = NULL;    return temp;} // method to flip the binary treeNode* flipBinaryTree(Node* root){    // Initialization of pointers    Node *curr = root;    Node *next = NULL;    Node *temp = NULL;    Node *prev = NULL;         // Iterate through all left nodes    while(curr)    {        next = curr->left;                 // Swapping nodes now, need temp to keep the previous right child                 // Making prev's right as curr's left child        curr->left = temp;                         // Storing curr's right child        temp = curr->right;                         // Making prev as curr's right child        curr->right = prev;                         prev = curr;        curr = next;    }    return prev;} // Iterative method to do level order traversal// line by linevoid printLevelOrder(Node *root){    // Base Case    if (root == NULL) return;     // Create an empty queue for level order traversal    queue<Node *> q;     // Enqueue Root and initialize height    q.push(root);     while (1)    {        // nodeCount (queue size) indicates number        // of nodes at current level.        int nodeCount = q.size();        if (nodeCount == 0)            break;         // Dequeue all nodes of current level and        // Enqueue all nodes of next level        while (nodeCount > 0)        {            Node *node = q.front();            cout << node->data << " ";            q.pop();                         if (node->left != NULL)                q.push(node->left);                         if (node->right != NULL)                q.push(node->right);            nodeCount--;        }        cout << endl;    }} // Driver codeint main(){         Node* root = newNode(1);    root->left = newNode(2);    root->right = newNode(3);    root->right->left = newNode(4);    root->right->right = newNode(5);     cout << "Level order traversal of given tree\n";    printLevelOrder(root);     root = flipBinaryTree(root);     cout << "\nLevel order traversal of the flipped"            " tree\n";    printLevelOrder(root);    return 0;} // This article is contributed by Pal13
// Java program to flip a binary treeimport java.util.*;class GFG{     // A binary tree nodestatic class Node{    int data;    Node left, right;}; // Utility function to create// a new Binary Tree Node static Node newNode(int data){    Node temp = new Node();    temp.data = data;    temp.left = temp.right = null;    return temp;} // method to flip the binary treestatic Node flipBinaryTree(Node root){    // Initialization of pointers    Node curr = root;    Node next = null;    Node temp = null;    Node prev = null;         // Iterate through all left nodes    while(curr != null)    {        next = curr.left;                 // Swapping nodes now, need        // temp to keep the previous        // right child                 // Making prev's right        // as curr's left child        curr.left = temp;                         // Storing curr's right child        temp = curr.right;                         // Making prev as curr's        // right child        curr.right = prev;                         prev = curr;        curr = next;    }    return prev;} // Iterative method to do// level order traversal// line by linestatic void printLevelOrder(Node root){    // Base Case    if (root == null) return;     // Create an empty queue for    // level order traversal    Queue<Node> q = new LinkedList<Node>();     // Enqueue Root and    // initialize height    q.add(root);     while (true)    {        // nodeCount (queue size)        // indicates number of nodes        // at current level.        int nodeCount = q.size();        if (nodeCount == 0)            break;         // Dequeue all nodes of current        // level and Enqueue all nodes        // of next level        while (nodeCount > 0)        {            Node node = q.peek();            System.out.print(node.data + " ");            q.remove();                         if (node.left != null)                q.add(node.left);                         if (node.right != null)                q.add(node.right);            nodeCount--;        }        System.out.println();    }} // Driver codepublic static void main(String args[]){    Node root = newNode(1);    root.left = newNode(2);    root.right = newNode(3);    root.right.left = newNode(4);    root.right.right = newNode(5);     System.out.print("Level order traversal " +                            "of given tree\n");    printLevelOrder(root);     root = flipBinaryTree(root);     System.out.print("\nLevel order traversal " +                        "of the flipped tree\n");    printLevelOrder(root);}} // This code is contributed// by Arnab Kundu
# Python3 program to flip# a binary treefrom collections import deque # A binary tree node structureclass Node:       def __init__(self, key):               self.data = key        self.left = None        self.right = None # method to flip the# binary treedef flipBinaryTree(root):       # Initialization of    # pointers    curr = root    next = None    temp = None    prev = None     # Iterate through all    # left nodes    while(curr):        next = curr.left         # Swapping nodes now, need temp        # to keep the previous right child         # Making prev's right as curr's        # left child        curr.left = temp         # Storing curr's right child        temp = curr.right         # Making prev as curr's right        # child        curr.right = prev         prev = curr        curr = next    return prev # Iterative method to do level# order traversal line by linedef printLevelOrder(root):       # Base Case    if (root == None):        return     # Create an empty queue for    # level order traversal    q = deque()     # Enqueue Root and initialize    # height    q.append(root)     while (1):        # nodeCount (queue size) indicates        # number of nodes at current level.        nodeCount = len(q)        if (nodeCount == 0):            break         # Dequeue all nodes of current        # level and Enqueue all nodes        # of next level        while (nodeCount > 0):            node = q.popleft()            print(node.data, end = " ")             if (node.left != None):                q.append(node.left)             if (node.right != None):                q.append(node.right)            nodeCount -= 1         print() # Driver codeif __name__ == '__main__':       root = Node(1)    root.left = Node(2)    root.right = Node(3)    root.right.left = Node(4)    root.right.right = Node(5)     print("Level order traversal of given tree")    printLevelOrder(root)     root = flipBinaryTree(root)     print("\nLevel order traversal of the flipped"          " tree")    printLevelOrder(root) # This code is contributed by Mohit Kumar 29
// C# program to flip a binary treeusing System;using System.Collections.Generic; class GFG{ // A binary tree nodepublic class Node{    public int data;    public Node left, right;} // Utility function to create// a new Binary Tree Nodepublic static Node newNode(int data){    Node temp = new Node();    temp.data = data;    temp.left = temp.right = null;    return temp;} // method to flip the binary treepublic static Node flipBinaryTree(Node root){    // Initialization of pointers    Node curr = root;    Node next = null;    Node temp = null;    Node prev = null;     // Iterate through all left nodes    while (curr != null)    {        next = curr.left;         // Swapping nodes now, need        // temp to keep the previous        // right child         // Making prev's right        // as curr's left child        curr.left = temp;         // Storing curr's right child        temp = curr.right;         // Making prev as curr's        // right child        curr.right = prev;         prev = curr;        curr = next;    }    return prev;} // Iterative method to do level// order traversal line by linepublic static void printLevelOrder(Node root){    // Base Case    if (root == null)    {        return;    }     // Create an empty queue for    // level order traversal    LinkedList<Node> q = new LinkedList<Node>();     // Enqueue Root and    // initialize height    q.AddLast(root);     while (true)    {        // nodeCount (queue size)        // indicates number of nodes        // at current level.        int nodeCount = q.Count;        if (nodeCount == 0)        {            break;        }         // Dequeue all nodes of current        // level and Enqueue all nodes        // of next level        while (nodeCount > 0)        {            Node node = q.First.Value;            Console.Write(node.data + " ");            q.RemoveFirst();             if (node.left != null)            {                q.AddLast(node.left);            }             if (node.right != null)            {                q.AddLast(node.right);            }            nodeCount--;        }        Console.WriteLine();    }} // Driver codepublic static void Main(string[] args){    Node root = newNode(1);    root.left = newNode(2);    root.right = newNode(3);    root.right.left = newNode(4);    root.right.right = newNode(5);     Console.Write("Level order traversal " +                         "of given tree\n");    printLevelOrder(root);     root = flipBinaryTree(root);     Console.Write("\nLevel order traversal " +                     "of the flipped tree\n");    printLevelOrder(root);}} // This code is contributed by Shrikant13
<script>     // JavaScript program to flip a binary tree         class Node    {        constructor(data) {           this.left = null;           this.right = null;           this.data = data;        }    }         // Utility function to create    // a new Binary Tree Node     function newNode(data)    {        let temp = new Node(data);        return temp;    }     // method to flip the binary tree    function flipBinaryTree(root)    {        // Initialization of pointers        let curr = root;        let next = null;        let temp = null;        let prev = null;         // Iterate through all left nodes        while(curr != null)        {            next = curr.left;             // Swapping nodes now, need            // temp to keep the previous            // right child             // Making prev's right            // as curr's left child            curr.left = temp;                    // Storing curr's right child            temp = curr.right;                    // Making prev as curr's            // right child            curr.right = prev;                    prev = curr;            curr = next;        }        return prev;    }     // Iterative method to do    // level order traversal    // line by line    function printLevelOrder(root)    {        // Base Case        if (root == null) return;         // Create an empty queue for        // level order traversal        let q = [];         // Enqueue Root and        // initialize height        q.push(root);         while (true)        {            // nodeCount (queue size)            // indicates number of nodes            // at current level.            let nodeCount = q.length;            if (nodeCount == 0)                break;             // Dequeue all nodes of current            // level and Enqueue all nodes            // of next level            while (nodeCount > 0)            {                let node = q[0];                document.write(node.data + " ");                q.shift();                 if (node.left != null)                    q.push(node.left);                 if (node.right != null)                    q.push(node.right);                nodeCount--;            }            document.write("</br>");        }    }         let root = newNode(1);    root.left = newNode(2);    root.right = newNode(3);    root.right.left = newNode(4);    root.right.right = newNode(5);      document.write("Level order traversal " +                            "of given tree" + "</br>");    printLevelOrder(root);      root = flipBinaryTree(root);      document.write("</br>" + "Level order traversal " +                        "of the flipped tree" + "</br>");    printLevelOrder(root); </script>
Level order traversal of given tree
1 
2 3 
4 5 

Level order traversal of the flipped tree
2 
3 1 
4 5 
Complexity Analysis: 
Time complexity: O(n) as in the worst case, depth of binary tree will be n. 
Auxiliary Space: O(1).
This article is contributed by Utkarsh Trivedi. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
andrew1234
shrikanth13
_Gaurav_Tiwari
princi singh
mohit kumar 29
unknown2108
anikakapoor
suresh07
sweetyty
hardikkoriintern
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.