edited Integer Reverse

Author: saihariG

Arrays/IntegerReverse.java

@@ -1,2 +1,22 @@
-package Arrays;public class IntegerReverse {
+package Arrays;
+
+import java.util.Scanner;
+
+public class IntegerReverse {
+    private static void reverse(int num) {
+        int reversed = 0, remainder ;
+
+        while(num != 0) {
+            remainder = num % 10; // reversed integer is stored in variable
+            reversed = reversed * 10 + remainder; //multiply reversed by 10 then add the remainder so it gets stored at next decimal place.
+            num  /= 10;  //the last digit is removed from num after division by 10.
+        }
+        System.out.println(reversed);
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        reverse(n);
+    }
 }

Arrays/SmallestDifference.java

@@ -1,2 +1,4 @@
-package Arrays;public class SmallestDifference {
+package Arrays;
+
+public class SmallestDifference {
 }

README.md

@@ -1,12 +1,8 @@
 # Ultimate Data Structures and Algorithms in Java
 This repository contains code implementation for all data Structures and algorithms, necessary for coding interviews
-
-<a href="https://www.paypal.com/paypalme/saiharig">
-    <img src="https://img.shields.io/badge/Donate-PayPal-green.svg?logo=paypal&style=flat-square" height="20" alt="Donate">
-</a>
-
+```
 Handwritten notes will be uploaded soon !
-
+```
 ## Ultimate 90 day Study Plan
 
 | Day       | Topics  |

Trees/BinaryTree.java

@@ -198,8 +198,6 @@ private void levelOrderTraversal() {
                 queue.offer(temp.right);
             }
         }
-
-
     }
 
     public static void main(String[] args) {

Trees/InvertBinaryTree.java

@@ -1,2 +1,100 @@
-package Trees;public class InvertBinaryTree {
+package Trees;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class InvertBinaryTree {
+
+    /*
+     *              10                                           10
+     *            /    \            Inversion                 /      \
+     *          20        50      ------------>             50         20
+     *        /    \     /   \                            /    \      /   \
+     *       30    40   null   60                        60   null   40    30
+     */
+    private static TreeNode root;
+    static class TreeNode {
+        int data;
+        TreeNode left,right;
+
+        public TreeNode(int data) {
+            this.data = data;
+            this.left = null;
+            this.right = null;
+        }
+
+    }
+
+    private static void createBinaryTree() {
+
+        TreeNode first = new TreeNode(10);
+        TreeNode second = new TreeNode(20);
+        TreeNode third = new TreeNode(50);
+        TreeNode fourth = new TreeNode(30);
+        TreeNode fifth = new TreeNode(40);
+        TreeNode six = new TreeNode(60);
+
+
+        root = first;
+        first.left = second;
+        first.right = third;
+
+        second.left = fourth;
+        second.right = fifth;
+
+        third.right = six;
+
+    }
+
+
+    private static void invert(TreeNode root) {
+        if(root == null) {
+            return;
+        }
+
+        // swapping
+        TreeNode temp = root.left;
+        root.left = root.right;
+        root.right = temp;
+
+        invert(root.left);
+        invert(root.right);
+    }
+
+    private static void levelOrderTraversal() {
+        if(root == null) {
+            return;
+        }
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+
+        while(!queue.isEmpty()) {
+            TreeNode temp = queue.poll();
+            System.out.print(temp.data+" ");
+
+            if(temp.left != null) {
+                queue.offer(temp.left);
+            }
+
+            if(temp.right != null) {
+                queue.offer(temp.right);
+            }
+        }
+    }
+
+
+    public static void main(String[] args) {
+
+        createBinaryTree();
+
+        System.out.print("Before Inverting : ");
+        levelOrderTraversal();
+
+        invert(root);
+
+        System.out.print("\nAfter Inverting : ");
+        levelOrderTraversal();
+
+    }
 }