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.
[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 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 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 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);
[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 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 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 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);
Similar Reads
Binary Tree Data Structure A Binary Tree Data Structure is a hierarchical data structure in which each node has at most two children, referred to as the left child and the right child. It is commonly used in computer science for efficient storage and retrieval of data, with various operations such as insertion, deletion, and
3 min read
Introduction to Binary Tree Binary Tree is a non-linear and hierarchical data structure where each node has at most two children referred to as the left child and the right child. The topmost node in a binary tree is called the root, and the bottom-most nodes are called leaves. Introduction to Binary TreeRepresentation of Bina
15+ min read
Properties of Binary Tree This post explores the fundamental properties of a binary tree, covering its structure, characteristics, and key relationships between nodes, edges, height, and levelsBinary tree representationNote: Height of root node is considered as 0. Properties of Binary Trees1. Maximum Nodes at Level 'l'A bina
4 min read
Applications, Advantages and Disadvantages of Binary Tree A binary tree is a tree that has at most two children for any of its nodes. There are several types of binary trees. To learn more about them please refer to the article on "Types of binary tree" Applications:General ApplicationsDOM in HTML: Binary trees help manage the hierarchical structure of web
2 min read
Binary Tree (Array implementation) Given an array that represents a tree in such a way that array indexes are values in tree nodes and array values give the parent node of that particular index (or node). The value of the root node index would always be -1 as there is no parent for root. Construct the standard linked representation o
6 min read
Maximum Depth of Binary Tree Given a binary tree, the task is to find the maximum depth of the tree. The maximum depth or height of the tree is the number of edges in the tree from the root to the deepest node.Examples:Input: Output: 2Explanation: The longest path from the root (node 12) goes through node 8 to node 5, which has
11 min read
Insertion in a Binary Tree in level order Given a binary tree and a key, the task is to insert the key into the binary tree at the first position available in level order manner.Examples:Input: key = 12 Output: Explanation: Node with value 12 is inserted into the binary tree at the first position available in level order manner.Approach:The
8 min read
Deletion in a Binary Tree Given a binary tree, the task is to delete a given node from it by making sure that the tree shrinks from the bottom (i.e. the deleted node is replaced by the bottom-most and rightmost node). This is different from BST deletion. Here we do not have any order among elements, so we replace them with t
12 min read
Enumeration of Binary Trees A Binary Tree is labeled if every node is assigned a label and a Binary Tree is unlabelled if nodes are not assigned any label. Below two are considered same unlabelled trees o o / \ / \ o o o o Below two are considered different labelled trees A C / \ / \ B C A B How many different Unlabelled Binar
3 min read
Types of Binary Tree