Swap Nodes in Binary tree of every k’th level

06 Jul, 2022
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++
Java
Python3
C#
Javascript
// c++ program swap nodes#include<bits/stdc++.h>using namespace std; // A Binary Tree Nodestruct Node{    int data;    struct Node *left, *right;}; // function to create a new tree nodeNode* newNode(int data){    Node *temp = new Node;    temp->data = data;    temp->left = temp->right = NULL;    return temp;} // swap two Nodevoid 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 levelvoid 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 traversalvoid inorder(Node *root){    if (root == NULL)        return;    inorder(root->left);    cout << root->data << " ";    inorder(root->right);} // Driver Codeint 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 nodesclass GFG{ // A Binary Tree Nodestatic class Node{    int data;    Node left, right;}; // function to create a new tree nodestatic 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 levelstatic 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 traversalstatic void inorder(Node root){    if (root == null)        return;    inorder(root.left);    System.out.print(root.data + " ");    inorder(root.right);} // Driver Codepublic 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 nodeclass 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 leveldef 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# swapEveryKLevelUtildef swapEveryKLevel(root, k):         # Call swapEveryKLevelUtil function with    # initial level as 1    swapEveryKLevelUtil(root, 1, k) # Method to find the inorder tree traversaldef 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 = 2print("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 nodesusing System; class GFG{ // A Binary Tree Nodepublic class Node{    public int data;    public Node left, right;}; // function to create a new tree nodestatic 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 levelstatic 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 traversalstatic void inorder(Node root){    if (root == null)        return;    inorder(root.left);    Console.Write(root.data + " ");    inorder(root.right);} // Driver Codepublic 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 
This article is contributed by Nishant_singh(pintu). 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
Rajput-Ji
suresh07
surinderdawra388
amartyaghoshgfg
hardikkoriintern
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
Introduction to Tree Data Structure
What is Data Structure: Types, Classifications and Applications
Binary Tree | Set 3 (Types of Binary Tree)
A program to check if a binary tree is BST or not
Lowest Common Ancestor in a Binary Tree | Set 1
Binary Tree | Set 2 (Properties)
Diameter of a Binary Tree
Decision Tree
Diagonal Traversal of Binary Tree