Swapping Nodes algorithm Implementation using java (binary tree)

Swapping subtrees of a node means that if initially node has left subtree L and right subtree R, then after swapping left subtree will be R and right subtree L.

1. import java.io.*;
2. import java.util.*;
3. 
   
4. public class Solution {
5. 
   
6.     public static void main(String[] args) {
7.         Scanner stdIn=new Scanner(System.in);
8.         int totalNodesInTree=stdIn.nextInt();
9.         Queue <Node> nodesInCurrentLevel=new LinkedList<Node>();
10.         
11.         //Initially we have Node(1) in the tree;
12.         Node root=new Node(1);
13.         nodesInCurrentLevel.add(root);
14.         Node current;
15. 
    
16.         /*
17.          * Building the Tree by adding nodes to the tree in level order from input via stdIn
18.         */
19.         int i=0;
20.         while(i<totalNodesInTree && !nodesInCurrentLevel.isEmpty()){
21.                 //Reading data for left child
22.                 int leftVal=stdIn.nextInt();
23.                 //Reading data for right child
24.                 int rightVal=stdIn.nextInt(); 
25.                 current=nodesInCurrentLevel.remove();
26.                 /*
27.                     Upon pointing current.left={leftChild} and current.right={rightChild}
28.                     We push the {leftChild} and {rightChild} into the queue if not null
29.                 */
30.                 insertLeft(current,leftVal,nodesInCurrentLevel);    
31.                 insertRight(current,rightVal,nodesInCurrentLevel);
32.                 i++;
33.         }    
34.        
35.         //Performing swaps
36.         int numberOfSwaps=0;
37.         if(totalNodesInTree>0)numberOfSwaps=stdIn.nextInt();
38.         for (i=0; i<numberOfSwaps; i++){
39.             swapLeftRightAtLevelKN(root,stdIn.nextInt(),1,1);
40.             printTree(root);
41.             System.out.println("");
42.         }
43.         
44.                
45.     }
46.     
47.     public static void swapLeftRightAtLevelKN(Node root, int levelK, int n, int currentLevel){
48.         if(root==null) return;
49.         if(currentLevel==levelK*n){
50.             Node temp=root.left;
51.             root.left=root.right;
52.             root.right=temp;
53.             n++;
54.         }
55.         swapLeftRightAtLevelKN(root.left, levelK, n,  currentLevel+1);
56.         swapLeftRightAtLevelKN(root.right, levelK, n, currentLevel+1);
57.     }
58.     
59.     public static void insertLeft(Node root, int val, Queue <Node> nodesInCurrentLevel){
60.         if(val==-1){
61.             root.left=null;
62.         }else{
63.             root.left=new Node(val);
64.             nodesInCurrentLevel.add(root.left);
65.         }
66.     }
67.     
68.      
69.     public static void insertRight(Node root, int val, Queue <Node> nodesInCurrentLevel){
70.         if(val==-1){
71.             root.right=null;
72.         }else{
73.             root.right=new Node(val);
74.             nodesInCurrentLevel.add(root.right);
75.         }
76.     }
77.     
78.     
79.     public static void printTree(Node root){
80.         if(root==null) return;
81.         printTree(root.left);
82.         System.out.printf("%d ",root.data);
83.         printTree(root.right);
84.     }
85. }
86. 
    
87. class Node{
88.     int data;
89.     Node left=null;
90.     Node right=null;
91.     public Node(int data){
92.         this.data=data;
93.     }
94. }