# Swap Nodes in Binary tree of every k’th level

• Difficulty Level : Easy
• Last Updated : 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++

 `// c++ program swap nodes``#include``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 :"``<

## Java

 `// 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`

## Python3

 `# 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#

 `// 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`

## Javascript

 ``

Output

```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.

My Personal Notes arrow_drop_up