Flip Binary Tree

Last Updated : 23 Oct, 2024

Given a binary tree, the task is to flip the binary tree towards the right direction that is clockwise.

Input:

Output:

Explanation: 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 leftmost nodes recursively.

Table of Content

[Expected Approach – 1] Using Recursion – O(n) Time and O(n) Space
[Expected Approach – 2] Iterative Approach – O(n) Time and O(1) Space

[Expected Approach – 1] Using Recursion – O(n) Time and O(n) Space

The idea is to recursively flip the binary tree by swapping the left and right subtrees of each node. After flipping, the tree’s structure will be reversed, and the new root of the flipped tree will be the original leftmost leaf node.

Below is the main rotation code of a subtree:

root->left->left = root->right
root->left->right = root
root->left = NULL
root->right = NULL

Below is the implementation of the above approach:

C++

// C++ program to flip a binary tree 
// using recursion
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;
    Node(int x) {
         data = x; 
          left = right = nullptr;
    }
};

// method to flip the binary tree iteratively
Node* flipBinaryTree(Node* root) {
  
    // Base cases
    if (root == nullptr)
        return root;
    if (root->left == nullptr && root->right == nullptr)
        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 = nullptr;

    return flippedRoot;
}

// Iterative method to do level order traversal
// line by line
void printLevelOrder(Node *root) {
  
    // Base Case
    if (root == nullptr)  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 != nullptr)
                q.push(node->left);
            if (node->right != nullptr)
                q.push(node->right);
            nodeCount--;
        }
        cout << endl;
    }
}

int main() {
  
      // Make a binary tree
    //
     //        1
    //       / \
    //      2   3
    //         / \
    //        4   5 
    Node* 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);


    root = flipBinaryTree(root);
    printLevelOrder(root);
    return 0;
}

Java

// Java program to flip a binary tree
// using recursion

class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {
  
    // Method to flip the binary tree
    static Node 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 line
    static void printLevelOrder(Node root) {
      
        // Base Case
        if (root == null) return;

        // Create an empty queue for level 
          // order traversal
        java.util.Queue<Node> q = new java.util.LinkedList<>();

        // Enqueue Root and initialize height
        q.add(root);

        while (!q.isEmpty()) {
          
            // nodeCount (queue size) indicates 
              // number of nodes at current level
            int nodeCount = q.size();

            // Dequeue all nodes of current level 
              // and Enqueue all nodes of next level
            while (nodeCount > 0) {
                Node node = q.poll();
                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) {
      
        // Make a binary tree
        //
        //        1
        //       / \
        //      2   3
        //         / \
        //        4   5 
        Node 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);

        root = flipBinaryTree(root);
        printLevelOrder(root);
    }
}

Python

# Python program to flip a binary
# tree using recursion

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = 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 level order 
# traversal line by line
def printLevelOrder(root):
  
    # Base Case
    if root is None:
        return

    # Create an empty queue for 
    # level order traversal
    queue = []
    queue.append(root)

    while queue:
        nodeCount = len(queue)

        while nodeCount > 0:
            node = queue.pop(0)
            print(node.data, end=" ")
            if node.left is not None:
                queue.append(node.left)
            if node.right is not None:
                queue.append(node.right)
            nodeCount -= 1
        print()

if __name__ == "__main__":
  
    # Make a binary tree
    #
    #        1
    #       / \
    #      2   3
    #         / \
    #        4   5 
    
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.right.left = Node(4)
    root.right.right = Node(5)

    root = flipBinaryTree(root)
    printLevelOrder(root)

// C# program to flip a binary tree 
// using recursion

using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {
  
    // Method to flip the binary tree
    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
    static void PrintLevelOrder(Node root) {

        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 (q.Count > 0) {
          
            // nodeCount (queue size) indicates 
              // number of nodes at current level
            int nodeCount = q.Count;

            // 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();
        }
    }

    static void Main(string[] args) {
      
        // Make a binary tree
        //
        //        1
        //       / \
        //      2   3
        //         / \
        //        4   5 
        Node 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);
      
        root = FlipBinaryTree(root);
        PrintLevelOrder(root);
    }
}

JavaScript

// JavaScript program to flip a binary 
// tree using recursion

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        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
    const 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) {

    if (root === null) return;

    // Create an empty queue for level
    // order traversal
    const queue = [root];

    while (queue.length > 0) {
        let nodeCount = queue.length;

        while (nodeCount > 0) {
            const node = queue.shift();
            console.log(node.data + " ");
            if (node.left !== null) queue.push(node.left);
            if (node.right !== null) queue.push(node.right);
            nodeCount--;
        }
        console.log();
    }
}

// Make a binary tree
//
//        1
//       / \
//      2   3
//         / \
//        4   5 
const 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);

const flippedRoot = flipBinaryTree(root);
printLevelOrder(flippedRoot);

Output

2 
3 1 
4 5

[Expected Approach – 2] Iterative Approach – O(n) Time and O(n) Space

The iterative solution follows the same approach as the recursive one, the only thing we need to pay attention to is saving the node information that will be overwritten.

Below is the implementation of the above approach:

C++

// C++ program to flip a binary tree using
// iterative approach
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;
    Node(int x) {
         data = x; 
          left = right = nullptr;
    }
};

// Method to flip the binary tree iteratively
Node* flipBinaryTree(Node* root) {
  
    // intiliazing the pointers to do the 
      // swapping and storing states
    Node *curr = root, *next = nullptr, 
      *prev = nullptr, *ptr = nullptr;
    while (curr != nullptr) {
      
        // pointing the next pointer to the
          // current next of left
        next = curr->left;
      
        // making the right child of prev 
          // as curr left child
        curr->left = ptr;

        // storign the right child of
          // curr in temp
        ptr = curr->right;

        curr->right = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

// Iterative method to do level order traversal
// line by line
void printLevelOrder(Node *root) {
  
    // Base Case
    if (root == nullptr)  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 != nullptr)
                q.push(node->left);
            if (node->right != nullptr)
                q.push(node->right);
            nodeCount--;
        }
        cout << endl;
    }
}

int main() {
  
    // Make a binary tree
    //
     //        1
    //       / \
    //      2   3
    //         / \
    //        4   5 
    Node* 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);


    root = flipBinaryTree(root);
    printLevelOrder(root);
    return 0;
}

Java

// Java program to flip a binary tree
// using iterative approach

class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {
  
    // Method to flip the binary tree
    static Node flipBinaryTree(Node root) {
      
        // Initializing the pointers to do the 
          // swapping and storing states
        Node curr = root;
        Node next = null;
        Node prev = null;
        Node ptr = null;

        while (curr != null) {
          
            // Pointing the next pointer to
              // the current next of left
            next = curr.left;

            // Making the right child of 
             // prev as curr left child
            curr.left = ptr;

            // Storing the right child 
             // of curr in ptr
            ptr = curr.right;

            curr.right = prev;
            prev = curr;
            curr = next;
        }

        return prev;
    }

    // Iterative method to do level order
   // traversal line by line
    static void printLevelOrder(Node root) {
    
        if (root == null) return;

        // Create an empty queue for level 
       // order traversal
        java.util.Queue<Node> q = new java.util.LinkedList<>();

        // Enqueue Root and initialize 
          // height
        q.add(root);

        while (!q.isEmpty()) {
          
            // nodeCount (queue size) indicates 
              // number of nodes at current level
            int nodeCount = q.size();

            // Dequeue all nodes of current level 
              // and Enqueue all nodes of next level
            while (nodeCount > 0) {
                Node node = q.poll();
                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) {
      
        // Make a binary tree
        //
        //        1
        //       / \
        //      2   3
        //         / \
        //        4   5 
        Node 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);

        root = flipBinaryTree(root);
        printLevelOrder(root);
    }
}

Python

# Python program to flip a binary tree
# using iterative approach

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# Method to flip the binary tree
# iteratively
def flip_binary_tree(root):

    # Initializing the pointers to do
    # the swapping and storing states
    curr = root
    next = None
    prev = None
    ptr = None

    while curr is not None:

        # Pointing the next pointer to the
        # current next of left
        next = curr.left

        # Making the right child of prev
        # as curr left child
        curr.left = ptr

        # Storing the right child of
        # curr in ptr
        ptr = curr.right

        curr.right = prev
        prev = curr
        curr = next

    return prev


# Iterative method to do level order
# traversal line by line
def printLevelOrder(root):

    if root is None:
        return

    # Create an empty queue for
    # level order traversal
    queue = []
    queue.append(root)

    while queue:
        nodeCount = len(queue)

        while nodeCount > 0:
            node = queue.pop(0)
            print(node.data, end=" ")
            if node.left is not None:
                queue.append(node.left)
            if node.right is not None:
                queue.append(node.right)
            nodeCount -= 1
        print()


if __name__ == "__main__":

    # Make a binary tree
    #
    #        1
    #       / \
    #      2   3
    #         / \
    #        4   5
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.right.left = Node(4)
    root.right.right = Node(5)

    root = flip_binary_tree(root)
    printLevelOrder(root)

// C# program to flip a binary tree
// using iterative approach

using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {
  
    // Method to flip the binary tree
    static Node FlipBinaryTree(Node root) {
      
        // Initializing the pointers to 
          // do the swapping and storing states
        Node curr = root;
        Node next = null;
        Node prev = null;
        Node ptr = null;

        while (curr != null) {
          
            // Pointing the next pointer to 
              // the current next of left
            next = curr.left;

            // Making the right child of prev
              // as curr left child
            curr.left = ptr;

            // Storing the right child
              // of curr in ptr
            ptr = curr.right;

            curr.right = prev;
            prev = curr;
            curr = next;
        }

        return prev;
    }

    // Iterative method to do level order
      // traversal line by line
    static void PrintLevelOrder(Node root) {

        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 (q.Count > 0) {
          
            // nodeCount (queue size) indicates 
              // number of nodes at current level
            int nodeCount = q.Count;

            // 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();
        }
    }

    static void Main(string[] args) {
      
        // Make a binary tree
        //
        //        1
        //       / \
        //      2   3
        //         / \
        //        4   5 
        Node 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);

        root = FlipBinaryTree(root);
        PrintLevelOrder(root);
    }
}

JavaScript

// JavaScript program to flip a binary 
// tree using iterative approach

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

function flipBinaryTree(root) {

    // Initializing the pointers to do the
    // swapping and storing states
    let curr = root;
    let next = null;
    let prev = null;
    let ptr = null;

    while (curr !== null) {
    
        // Pointing the next pointer to the 
        // current next of left
        next = curr.left;

        // Making the right child of prev
        // as curr left child
        curr.left = ptr;

        // Storing the right child of 
        // curr in ptr
        ptr = curr.right;

        curr.right = prev;
        prev = curr;
        curr = next;
    }

    return prev;
}


// Iterative method to do level order
// traversal line by line
function printLevelOrder(root) {

    if (root === null) return;

    // Create an empty queue for
    // level order traversal
    const queue = [root];

    while (queue.length > 0) {
        let nodeCount = queue.length;

        while (nodeCount > 0) {
            const node = queue.shift();
            console.log(node.data + " ");
            if (node.left !== null) queue.push(node.left);
            if (node.right !== null) queue.push(node.right);
            nodeCount--;
        }
        console.log();
    }
}

// Make a binary tree
//
//        1
//       / \
//      2   3
//         / \
//        4   5 
const 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);

const flippedRoot = flipBinaryTree(root);
printLevelOrder(flippedRoot);

Output

2 
3 1 
4 5

Print root to leaf paths without using recursion

Utkarsh Trivedi

Improve

Flip Binary Tree

[Expected Approach – 1] Using Recursion – O(n) Time and O(n) Space

[Expected Approach – 2] Iterative Approach – O(n) Time and O(n) Space

Similar Reads

Types of Binary Tree

Some important Binary tree traversals

Easy problems on Binary Tree

Intermediate problems on Binary Tree

Hard problems on Binary Tree

What kind of Experience do you want to share?