Swap Nodes in Binary tree of every k’th level
Last Updated :
10 Mar, 2023
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++
#include<bits/stdc++.h>
using namespace std;
struct Node
{
int data;
struct Node *left, *right;
};
Node* newNode( int data)
{
Node *temp = new Node;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
void Swap( Node **a , Node **b)
{
Node * temp = *a;
*a = *b;
*b = temp;
}
void swapEveryKLevelUtil( Node *root, int level, int k)
{
if (root== NULL ||
(root->left==NULL && root->right==NULL) )
return ;
if ( (level + 1) % k == 0)
Swap(&root->left, &root->right);
swapEveryKLevelUtil(root->left, level+1, k);
swapEveryKLevelUtil(root->right, level+1, k);
}
void swapEveryKLevel(Node *root, int k)
{
swapEveryKLevelUtil(root, 1, k);
}
void inorder(Node *root)
{
if (root == NULL)
return ;
inorder(root->left);
cout << root->data << " " ;
inorder(root->right);
}
int main()
{
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
class GFG
{
static class Node
{
int data;
Node left, right;
};
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
}
static void swapEveryKLevelUtil( Node root, int level, int k)
{
if (root== null ||
(root.left== null && root.right== null ) )
return ;
if ( (level + 1 ) % k == 0 )
{
Node temp=root.left;
root.left=root.right;
root.right=temp;
}
swapEveryKLevelUtil(root.left, level+ 1 , k);
swapEveryKLevelUtil(root.right, level+ 1 , k);
}
static void swapEveryKLevel(Node root, int k)
{
swapEveryKLevelUtil(root, 1 , k);
}
static void inorder(Node root)
{
if (root == null )
return ;
inorder(root.left);
System.out.print(root.data + " " );
inorder(root.right);
}
public static void main(String args[])
{
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);
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def swapEveryKLevelUtil(root, level, k):
if (root is None or (root.left is None and
root.right is None ) ):
return
if (level + 1 ) % k = = 0 :
root.left, root.right = root.right, root.left
swapEveryKLevelUtil(root.left, level + 1 , k)
swapEveryKLevelUtil(root.right, level + 1 , k)
def swapEveryKLevel(root, k):
swapEveryKLevelUtil(root, 1 , k)
def inorder(root):
if root is None :
return
inorder(root.left)
print (root.data,end = " " )
inorder(root.right)
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)
|
C#
using System;
class GFG
{
public class Node
{
public int data;
public Node left, right;
};
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
}
static void swapEveryKLevelUtil( Node root, int level, int k)
{
if (root == null ||
(root.left == null && root.right== null ) )
return ;
if ( (level + 1) % k == 0)
{
Node temp=root.left;
root.left=root.right;
root.right=temp;
}
swapEveryKLevelUtil(root.left, level+1, k);
swapEveryKLevelUtil(root.right, level+1, k);
}
static void swapEveryKLevel(Node root, int k)
{
swapEveryKLevelUtil(root, 1, k);
}
static void inorder(Node root)
{
if (root == null )
return ;
inorder(root.left);
Console.Write(root.data + " " );
inorder(root.right);
}
public static void Main(String []args)
{
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
<script>
class Node
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
function newNode(data)
{
let temp = new Node(data);
return temp;
}
function swapEveryKLevelUtil(root, level, k)
{
if (root== null ||
(root.left== null && root.right== null ) )
return ;
if ( (level + 1) % k == 0)
{
let temp=root.left;
root.left=root.right;
root.right=temp;
}
swapEveryKLevelUtil(root.left, level+1, k);
swapEveryKLevelUtil(root.right, level+1, k);
}
function swapEveryKLevel(root, k)
{
swapEveryKLevelUtil(root, 1, k);
}
function inorder(root)
{
if (root == null )
return ;
inorder(root.left);
document.write(root.data + " " );
inorder(root.right);
}
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>
|
Output
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/). 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++
#include<bits/stdc++.h>
using namespace std;
struct Node{
int data;
Node* left;
Node* right;
};
Node* newNode( int data){
Node* temp = new Node();
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
void Swap(Node**a, Node**b){
Node* temp = *a;
*a = *b;
*b = temp;
}
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++;
}
}
void inorder(Node* root){
if (root == NULL) return ;
inorder(root->left);
cout<<root->data<< " " ;
inorder(root->right);
}
int main(){
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
import java.util.*;
public class Main {
static class Node {
int data;
Node left, right;
Node( int data)
{
this .data = data;
left = right = null ;
}
};
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++;
}
}
static void inorder(Node root)
{
if (root == null )
return ;
inorder(root.left);
System.out.print(root.data + " " );
inorder(root.right);
}
public static void main(String[] args)
{
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);
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
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
def inorder(root):
if root = = None :
return
inorder(root.left)
print (root.data, end = " " )
inorder(root.right)
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)
|
C#
using System;
using System.Collections.Generic;
class GFG
{
public class Node
{
public int data;
public Node left, right;
};
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
}
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++;
}
}
static void inorder(Node root)
{
if (root == null )
return ;
inorder(root.left);
Console.Write(root.data+ " " );
inorder(root.right);
}
public static void Main(String []args)
{
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
class Node{
constructor(data)
{
this .data=data;
this .left= null ;
this .right= null ;
}
}
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 inorder( root){
if (root == null )
return ;
inorder(root.left);
document.write(root.data+ " " );
inorder(root.right);
}
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);
|
Output
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.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...