Given a binary tree and integer value k, the task is to swap sibling nodes of every k’th level where k >= 1.
Examples:
Input : k = 2 and Root of below tree 1 Level 1 / \ 2 3 Level 2 / / \ 4 7 8 Level 3 Output : Root of the following modified tree 1 / \ 3 2 / \ / 7 8 4 Explanation : We need to swap left and right sibling every second level. There is only one even level with nodes to be swapped are 2 and 3. Input : k = 1 and Root of following tree 1 Level 1 / \ 2 3 Level 2 / \ 4 5 Level 3 Output : Root of the following modified tree 1 / \ 3 2 / \ 5 4 Since k is 1, we need to swap sibling nodes of all levels.
A simple solution of this problem is that for each is to find sibling nodes for each multiple of k and swap them.
An efficient solution is to keep track of level number in recursive calls. And for every node being visited, check if level number of its children is a multiple of k. If yes, then swap the two children of the node. Else, recur for left and right children.
Below is the implementation of above idea
// c++ program swap nodes #include<bits/stdc++.h> using namespace std;
// A Binary Tree Node struct Node
{ int data;
struct Node *left, *right;
}; // function to create a new tree node Node* newNode( int data)
{ Node *temp = new Node;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
} // swap two Node void Swap( Node **a , Node **b)
{ Node * temp = *a;
*a = *b;
*b = temp;
} // A utility function swap left- node & right node of tree // of every k'th level void swapEveryKLevelUtil( Node *root, int level, int k)
{ // base case
if (root== NULL ||
(root->left==NULL && root->right==NULL) )
return ;
//if current level + 1 is present in swap vector
//then we swap left & right node
if ( (level + 1) % k == 0)
Swap(&root->left, &root->right);
// Recur for left and right subtrees
swapEveryKLevelUtil(root->left, level+1, k);
swapEveryKLevelUtil(root->right, level+1, k);
} // This function mainly calls recursive function // swapEveryKLevelUtil() void swapEveryKLevel(Node *root, int k)
{ // call swapEveryKLevelUtil function with
// initial level as 1.
swapEveryKLevelUtil(root, 1, k);
} // Utility method for inorder tree traversal void inorder(Node *root)
{ if (root == NULL)
return ;
inorder(root->left);
cout << root->data << " " ;
inorder(root->right);
} // Driver Code int main()
{ /* 1
/ \
2 3
/ / \
4 7 8 */
struct Node *root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->right->right = newNode(8);
root->right->left = newNode(7);
int k = 2;
cout << "Before swap node :" <<endl;
inorder(root);
swapEveryKLevel(root, k);
cout << "\nAfter swap Node :" << endl;
inorder(root);
return 0;
} |
// Java program swap nodes class GFG
{ // A Binary Tree Node static class Node
{ int data;
Node left, right;
}; // function to create a new tree node static Node newNode( int data)
{ Node temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
} // A utility function swap left- node & right node of tree // of every k'th level static void swapEveryKLevelUtil( Node root, int level, int k)
{ // base case
if (root== null ||
(root.left== null && root.right== null ) )
return ;
//if current level + 1 is present in swap vector
//then we swap left & right node
if ( (level + 1 ) % k == 0 )
{
Node temp=root.left;
root.left=root.right;
root.right=temp;
}
// Recur for left and right subtrees
swapEveryKLevelUtil(root.left, level+ 1 , k);
swapEveryKLevelUtil(root.right, level+ 1 , k);
} // This function mainly calls recursive function // swapEveryKLevelUtil() static void swapEveryKLevel(Node root, int k)
{ // call swapEveryKLevelUtil function with
// initial level as 1.
swapEveryKLevelUtil(root, 1 , k);
} // Utility method for inorder tree traversal static void inorder(Node root)
{ if (root == null )
return ;
inorder(root.left);
System.out.print(root.data + " " );
inorder(root.right);
} // Driver Code public static void main(String args[])
{ /* 1
/ \
2 3
/ / \
4 7 8 */
Node root = newNode( 1 );
root.left = newNode( 2 );
root.right = newNode( 3 );
root.left.left = newNode( 4 );
root.right.right = newNode( 8 );
root.right.left = newNode( 7 );
int k = 2 ;
System.out.println( "Before swap node :" );
inorder(root);
swapEveryKLevel(root, k);
System.out.println( "\nAfter swap Node :" );
inorder(root);
} } // This code is contributed by Arnab Kundu |
# Python program to swap nodes # A binary tree node class Node:
# constructor to create a new node
def __init__( self , data):
self .data = data
self .left = None
self .right = None
# A utility function swap left node and right node of tree # of every k'th level def swapEveryKLevelUtil(root, level, k):
# Base Case
if (root is None or (root.left is None and
root.right is None ) ):
return
# If current level+1 is present in swap vector
# then we swap left and right node
if (level + 1 ) % k = = 0 :
root.left, root.right = root.right, root.left
# Recur for left and right subtree
swapEveryKLevelUtil(root.left, level + 1 , k)
swapEveryKLevelUtil(root.right, level + 1 , k)
# This function mainly calls recursive function # swapEveryKLevelUtil def swapEveryKLevel(root, k):
# Call swapEveryKLevelUtil function with
# initial level as 1
swapEveryKLevelUtil(root, 1 , k)
# Method to find the inorder tree traversal def inorder(root):
# Base Case
if root is None :
return
inorder(root.left)
print (root.data,end = " " )
inorder(root.right)
# Driver code """ 1
/ \
2 3
/ / \
4 7 8
""" root = Node( 1 )
root.left = Node( 2 )
root.right = Node( 3 )
root.left.left = Node( 4 )
root.right.right = Node( 8 )
root.right.left = Node( 7 )
k = 2
print ( "Before swap node :" )
inorder(root) swapEveryKLevel(root, k) print ( "\nAfter swap Node : " )
inorder(root) # This code is contributed by Nikhil Kumar Singh(nickzuck_007) |
// C# program swap nodes using System;
class GFG
{ // A Binary Tree Node public class Node
{ public int data;
public Node left, right;
}; // function to create a new tree node static Node newNode( int data)
{ Node temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
} // A utility function swap left- node & right node of tree // of every k'th level static void swapEveryKLevelUtil( Node root, int level, int k)
{ // base case
if (root == null ||
(root.left == null && root.right== null ) )
return ;
//if current level + 1 is present in swap vector
//then we swap left & right node
if ( (level + 1) % k == 0)
{
Node temp=root.left;
root.left=root.right;
root.right=temp;
}
// Recur for left and right subtrees
swapEveryKLevelUtil(root.left, level+1, k);
swapEveryKLevelUtil(root.right, level+1, k);
} // This function mainly calls recursive function // swapEveryKLevelUtil() static void swapEveryKLevel(Node root, int k)
{ // call swapEveryKLevelUtil function with
// initial level as 1.
swapEveryKLevelUtil(root, 1, k);
} // Utility method for inorder tree traversal static void inorder(Node root)
{ if (root == null )
return ;
inorder(root.left);
Console.Write(root.data + " " );
inorder(root.right);
} // Driver Code public static void Main(String []args)
{ /* 1
/ \
2 3
/ / \
4 7 8 */
Node root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.right.right = newNode(8);
root.right.left = newNode(7);
int k = 2;
Console.WriteLine( "Before swap node :" );
inorder(root);
swapEveryKLevel(root, k);
Console.WriteLine( "\nAfter swap Node :" );
inorder(root);
} } // This code contributed by Rajput-Ji |
<script> // JavaScript program swap nodes
class Node
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
// function to create a new tree node
function newNode(data)
{
let temp = new Node(data);
return temp;
}
// A utility function swap left- node & right node of tree
// of every k'th level
function swapEveryKLevelUtil(root, level, k)
{
// base case
if (root== null ||
(root.left== null && root.right== null ) )
return ;
//if current level + 1 is present in swap vector
//then we swap left & right node
if ( (level + 1) % k == 0)
{
let temp=root.left;
root.left=root.right;
root.right=temp;
}
// Recur for left and right subtrees
swapEveryKLevelUtil(root.left, level+1, k);
swapEveryKLevelUtil(root.right, level+1, k);
}
// This function mainly calls recursive function
// swapEveryKLevelUtil()
function swapEveryKLevel(root, k)
{
// call swapEveryKLevelUtil function with
// initial level as 1.
swapEveryKLevelUtil(root, 1, k);
}
// Utility method for inorder tree traversal
function inorder(root)
{
if (root == null )
return ;
inorder(root.left);
document.write(root.data + " " );
inorder(root.right);
}
/* 1
/ \
2 3
/ / \
4 7 8 */
let root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.right.right = newNode(8);
root.right.left = newNode(7);
let k = 2;
document.write( "Before swap node :" + "</br>" );
inorder(root);
swapEveryKLevel(root, k);
document.write( "</br>" + "After swap Node :" + "</br>" );
inorder(root);
</script> |
Before swap node : 4 2 1 7 3 8 After swap Node : 7 3 8 1 4 2
Time Complexity: O(N) where N is the Number of nodes in a given binary tree.
Auxiliary Space: O(log(N))
Another Approach(Iterative):
The given problem can be solved by using the Level Order Traversal(https://www.geeksforgeeks.org/level-order-tree-traversal/amp/). Follow the steps below to solve the problem:
1) Create a queue(q), and store the nodes alongside its level and continuously iterate for next levels.
2) Perform level order traversal and check if (level+1)%k == 0 then swap its left and right children.
3) After completing the above steps, print the inorder traversals of previous and next tree.
Below is the implementation of above approach:
// C++ program for the above approach #include<bits/stdc++.h> using namespace std;
// struct of binary tree node struct Node{
int data;
Node* left;
Node* right;
}; // function to create a new node Node* newNode( int data){
Node* temp = new Node();
temp->data = data;
temp->left = temp->right = NULL;
return temp;
} // swap two nodes void Swap(Node**a, Node**b){
Node* temp = *a;
*a = *b;
*b = temp;
} // a utility function swap left-node and right node // of tree of every k'th level void swapEveryKLevel(Node* root, int k){
int level = 1;
queue<Node*> q;
q.push(root);
while (!q.empty()){
int n = q.size();
for ( int i = 0; i<n; i++){
Node* temp = q.front();
q.pop();
if ((level+1) % k == 0){
Swap(&temp->left, &temp->right);
}
if (temp->left != NULL) q.push(temp->left);
if (temp->right != NULL) q.push(temp->right);
}
level++;
}
} // function to print inorder traversal void inorder(Node* root){
if (root == NULL) return ;
inorder(root->left);
cout<<root->data<< " " ;
inorder(root->right);
} //driver code int main(){
/* 1
/ \
2 3
/ / \
4 7 8 */
struct Node *root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->right->right = newNode(8);
root->right->left = newNode(7);
int k = 2;
cout << "Before swap node :" <<endl;
inorder(root);
swapEveryKLevel(root, k);
cout << "\nAfter swap Node :" << endl;
inorder(root);
return 0;
} // This code is contributed by Yash Agarwal(yashagarwal2852002) |
// Java program swap nodes import java.util.*;
public class Main { // A Binary Tree Node
static class Node {
int data;
Node left, right;
Node( int data)
{
this .data = data;
left = right = null ;
}
};
// a utility function swap left-node and right node
// of tree of every k'th level
static void swapEveryKLevel(Node root, int k)
{
int level = 1 ;
Queue<Node> q = new LinkedList<Node>();
q.add(root);
while (!q.isEmpty()) {
int n = q.size();
for ( int i = 0 ; i < n; i++) {
Node temp = q.remove();
if ((level + 1 ) % k == 0 ) {
Node tmp = temp.left;
temp.left = temp.right;
temp.right = tmp;
}
if (temp.left != null )
q.add(temp.left);
if (temp.right != null )
q.add(temp.right);
}
level++;
}
}
// function to print inorder traversal
static void inorder(Node root)
{
if (root == null )
return ;
inorder(root.left);
System.out.print(root.data + " " );
inorder(root.right);
}
// driver code
public static void main(String[] args)
{
/* 1
/ \
2 3
/ / \
4 7 8 */
Node root = new Node( 1 );
root.left = new Node( 2 );
root.right = new Node( 3 );
root.left.left = new Node( 4 );
root.right.right = new Node( 8 );
root.right.left = new Node( 7 );
int k = 2 ;
System.out.println( "Before swap node :" );
inorder(root);
swapEveryKLevel(root, k);
System.out.println( "\nAfter swap Node :" );
inorder(root);
}
} // This code is contributed by divyansh2212 |
# Python program for the above approach # struct of binary tree node class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
# a utility function to swap left-node and right node # of tree of every k'th level def swapEveryKLevel(root, k):
level = 1
q = []
q.append(root)
while q:
n = len (q)
for i in range (n):
temp = q.pop( 0 )
if (level + 1 ) % k = = 0 :
temp.left, temp.right = temp.right, temp.left
if temp.left ! = None :
q.append(temp.left)
if temp.right ! = None :
q.append(temp.right)
level + = 1
# function to print inorder traversal def inorder(root):
if root = = None :
return
inorder(root.left)
print (root.data, end = " " )
inorder(root.right)
# Driver code """ 1 / \
2 3
/ / \
4 7 8 """ root = Node( 1 )
root.left = Node( 2 )
root.right = Node( 3 )
root.left.left = Node( 4 )
root.right.right = Node( 8 )
root.right.left = Node( 7 )
k = 2
print ( "Before swap node :" )
inorder(root) swapEveryKLevel(root, k) print ( "\nAfter swap Node :" )
inorder(root) # contributed by akashish__ |
// C# program swap nodes using System;
using System.Collections.Generic;
class GFG
{ // A Binary Tree Node
public class Node
{
public int data;
public Node left, right;
};
// function to create a new tree node
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
}
// a utility function swap left-node and right node
// of tree of every k'th level
static void swapEveryKLevel(Node root, int k)
{
int level = 1;
Queue<Node> q = new Queue<Node>();
q.Enqueue(root);
while (q.Count!=0){
int n = q.Count;
for ( int i = 0; i<n; i++){
Node temp = q.Dequeue();
if ((level+1) % k == 0)
{
Node tmp=temp.left;
temp.left=temp.right;
temp.right=tmp;
}
if (temp.left != null )
q.Enqueue(temp.left);
if (temp.right != null )
q.Enqueue(temp.right);
}
level++;
}
}
// function to print inorder traversal
static void inorder(Node root)
{
if (root == null )
return ;
inorder(root.left);
Console.Write(root.data+ " " );
inorder(root.right);
}
//driver code
public static void Main(String []args)
{
/* 1
/ \
2 3
/ / \
4 7 8 */
Node root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.right.right = newNode(8);
root.right.left = newNode(7);
int k = 2;
Console.WriteLine( "Before swap node :" );
inorder(root);
swapEveryKLevel(root, k);
Console.WriteLine( "\nAfter swap Node :" );
inorder(root);
}
} |
// Javascript program for the above approach // struct of binary tree node class Node{ constructor(data)
{
this .data=data;
this .left= null ;
this .right= null ;
}
} // a utility function swap left-node and right node // of tree of every k'th level function swapEveryKLevel(root, k){
let level = 1;
let q=[];
q.push(root);
while (q.length){
let n = q.length;
for (let i = 0; i<n; i++){
let temp = q.shift();
if ((level+1) % k == 0){
[temp.left,temp.right]=[temp.right,temp.left];
}
if (temp.left != null )
q.push(temp.left);
if (temp.right != null )
q.push(temp.right);
}
level++;
}
} // function to print inorder traversal function inorder( root){
if (root == null )
return ;
inorder(root.left);
document.write(root.data+ " " );
inorder(root.right);
} // Driver code /* 1 / \
2 3
/ / \
4 7 8 */ let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.right.right = new Node(8);
root.right.left = new Node(7);
let k = 2; console.log( "Before swap node :" );
inorder(root); swapEveryKLevel(root, k); console.log( "<br>After swap Node :" );
inorder(root); |
Before swap node : 4 2 1 7 3 8 After swap Node : 7 3 8 1 4 2
Time Complexity: O(N) where N is the Number of nodes in a given binary tree.
Auxiliary Space: O(N) due to queue data structure.