Swap Nodes in Binary tree of every k’th level

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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 travesal
def inorder(root):
      
    # Base Case
    if root is None:
        return 
    inorder(root.left)
    print root.data, 
    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)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right



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 contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up

Improved By : andrew1234, Rajput-Ji



Article Tags :
Practice Tags :


2


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.