Added some Easy questions 🎉

Author: Jatin-8898

Easy/BalancedBinaryTree.java

@@ -0,0 +1,35 @@
+public class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+    TreeNode(int x) { val = x; }
+}
+class Solution {
+  
+  public boolean isBalanced(TreeNode root) {
+      int left;
+      int right;
+      
+      if(root == null)
+          return true;
+      
+      left = height(root.left);
+      right = height(root.right);
+      
+      if(Math.abs(left-right) <=1 && isBalanced(root.left) && isBalanced(root.right))
+          return true;
+      
+      return false;
+  }
+  
+  int height(TreeNode node) 
+  { 
+      /* base case tree is empty */
+      if (node == null) 
+          return 0; 
+
+      /* If tree is not empty then height = 1 + max of left 
+       height and right heights */
+      return 1 + Math.max(height(node.left), height(node.right)); 
+  } 
+}

Easy/StockBuySell.java renamed to Easy/BestTimeToBuyAndSellStock.java

@@ -1,4 +1,4 @@
-class StockBuySell {
+class Solution {
     public static void main(String[] args) {
         int[] arr = {7,1,5,3,6,4};
         System.out.println(maxProfit(arr));

Easy/ConvertSortedArrayToBinarySearchTree.java

@@ -0,0 +1,40 @@
+class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+    TreeNode(int x) { val = x; }
+}
+class ConvertSortedArrayToBinarySearchTree {
+
+    public static void main(String[] args) {
+        int[] nums = {-10,-3,0,5,9};
+        TreeNode head = sortedArrayToBST(nums);
+        System.out.println(head.val);
+        /*System.out.println(head.val);
+        System.out.println(head.left.val);
+        System.out.println(head.left.right.val);
+        System.out.println(head.right.val);
+        System.out.println(head.right.right.val);
+        */
+    }
+
+    public static TreeNode sortedArrayToBST(int[] nums) {
+        if(nums.length == 0) 
+            return null;
+            
+        return buildBST(nums, 0, nums.length - 1);
+    }
+    
+    public static  TreeNode buildBST(int[] nums, int start, int end) {
+        if(start > end) 
+            return null;
+
+        int mid = start + (end - start) / 2;
+        TreeNode root = new TreeNode(nums[mid]);
+        
+        root.left = buildBST(nums, start, mid - 1);
+        root.right = buildBST(nums, mid + 1, end);
+        
+        return root;
+    }
+}

Easy/CountAndSay.class

@@ -0,0 +1,14 @@
+class Solution {
+    public int titleToNumber(String s) {
+        
+        int result  = 0;
+        
+        for (int i = 0; i < s.length(); i++){   //for s = A => 65-65=0 => Add 1 to it
+    
+            result *= 26;                       //For AA = 1*26 = 26 + 1 = 27
+            result += ((s.charAt(i) - 'A') + 1);    
+        }
+    
+        return result;
+    }
+}

Easy/DistributeCandies.class

@@ -0,0 +1,10 @@
+class Solution{
+    
+    public int trailingZero(int n) { //Eg 25
+    
+        return n == 0   ? 0 :    (n/2 +  trailingZero(n/2));
+        
+        //25/2 = 5 + (25/2)     =>    5 + 1 = 6
+    
+    }
+}

Easy/ExcelSheetColumnNumber.java

@@ -1,25 +1,5 @@
 class Solution {
 
-    /* BEST SOLUTION 
-        TIME : O(n)
-        SPACE: O(1)
-    */
-    public int robEff(int[] nums) {
-        if (nums.length == 0) return 0;
-        
-        int prev1 = 0;
-        int prev2 = 0;
-        
-        for (int num : nums) {
-            int tmp = prev1;
-            prev1 = Math.max(prev2 + num, prev1);
-            prev2 = tmp;
-        }
-        
-        return prev1;
-    }
-
-    /* ANOTHER WAY */
     public int rob(int[] nums) {    //Eg 2, 7 ,9 ,3 ,1 
 
         int n = nums.length;        //n=5
@@ -39,7 +19,6 @@ public int rob(int[] nums) {    //Eg 2, 7 ,9 ,3 ,1
         return Math.max(nums[n-1], nums[n-2]);  //Max(12,10)  => return 12 correct ans
     }
 
-
     /* ANOTHER APPROACH */
     public int rob2(int[] nums) {
         if (nums.length == 0) return 0;

Easy/FactorialTrailingZeroes.java

@@ -0,0 +1,41 @@
+import java.util.*;
+
+class IntersectionOfTwoArrays {
+    public static void main(String[] args) {
+        int[] nums1 = {1,2,2,1};
+        int[] nums2 = {2,2};
+        Integer res[] = intersect(nums1, nums2);
+        for(int i: res) System.out.println(i);
+    }
+
+    public static Integer[] intersect(int[] nums1, int[] nums2) {
+        
+        // freq count for nums1
+        HashMap<Integer, Integer> map = new HashMap<>();
+        
+        for (int num : nums1) 
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        
+        // collect result
+        ArrayList<Integer> result = new ArrayList<>();
+        
+        for (int num: nums2) {
+            
+            if (map.containsKey(num)){
+                result.add(num);
+                map.put(num, map.get(num) - 1);
+                map.remove(num, 0);
+            }
+        }
+        
+       Integer[] res = result.toArray(new Integer[result.size()]); 
+       
+       // convert result            MANUAL WAY OF CONVERTING TO INT[]
+       int[] r = new int[result.size()];
+       for(int i = 0; i < result.size(); i++) {
+           r[i] = result.get(i);
+       }
+
+       return res;
+    }
+}

Easy/HappyNumber.class

@@ -0,0 +1,27 @@
+class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+    
+    TreeNode(int x) { 
+        val = x; 
+    }
+}
+
+class MaxDepth {
+  
+    public int maxDepth(TreeNode root) {
+      
+        if(root == null){
+            return 0;
+        }
+        
+        int leftDepth = maxDepth(root.left);
+        int rightDepth = maxDepth(root.right);
+            
+        if(leftDepth > rightDepth)
+            return leftDepth+1;
+        else
+            return rightDepth+1;
+    }
+}

Easy/HouseRobber.java

@@ -0,0 +1,27 @@
+public class ListNode {
+
+    int val;
+    ListNode next;
+
+    ListNode(int x) {
+        val = x;
+    }
+}
+
+class Solution {
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+        if (l1 == null)
+            return l2;
+        if (l2 == null)
+            return l1;
+
+        if (l1.val < l2.val) {
+            l1.next = mergeTwoLists(l1.next, l2);
+            return l1;
+
+        } else {
+            l2.next = mergeTwoLists(l1, l2.next);
+            return l2;
+        }
+    }
+}

Easy/IntersectionOfTwoArray.class

@@ -0,0 +1,32 @@
+public class NumberOf1Bits {
+    // you need to treat n as an unsigned value
+    public int hammingWeight(int n) {
+        
+        
+        //1 way of doing
+        //return Integer.bitCount(n);
+        
+
+        //2nd way of doing
+        /*int count = 0;
+            
+        while(n != 0){
+            n = n & (n - 1);
+            count++;
+        }
+
+        return count;*/
+        
+        //3rd way of doing
+        int bits = 0;
+        int mask = 1;
+        
+        for (int i = 0; i < 32; i++) {
+            if ((n & mask) != 0) {
+                bits++;
+            }
+            mask <<= 1;
+        }
+        return bits;
+    }
+}

Easy/IntersectionOfTwoArrays.java

@@ -0,0 +1,27 @@
+import java.util.*;
+
+class Solution {
+    public List<List<Integer>> generate(int numRows) {
+        
+        List<List<Integer>> result = new ArrayList<>();
+        
+        for(int i = 0 ; i < numRows; i++) {
+            List<Integer> list = new ArrayList<>();
+            
+            for(int j = 0; j < i + 1 ; j++) {
+                if(j == 0 || j == i) {
+                    list.add(1);
+                }
+                else {
+                    int a = result.get(i - 1).get(j - 1);
+                    int b = result.get(i - 1).get(j);
+                    list.add(a + b);
+                }
+            }
+            result.add(list);
+         }
+        
+        return result;
+        
+    }
+}

Easy/IsomorphicString.class

@@ -0,0 +1,26 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode deleteDuplicates(ListNode head) {
+        ListNode list = head;
+         
+         while(list != null) {
+        	 if (list.next == null) {
+        		 break;
+        	 }
+        	 if (list.val == list.next.val) {
+        		 list.next = list.next.next;
+        	 } else {
+        		 list = list.next;
+        	 }
+         }
+         
+         return head;
+    }
+}

Easy/LongestPrefix.class

@@ -1,4 +1,4 @@
-class Reverse32bit {
+class ReverseBits {
     public int reverse(int x) {
         boolean overflowed = false;
         int result = 0;

Easy/MaxDistanceToClosest.class

@@ -0,0 +1,19 @@
+class Solution {
+    public int searchInsert(int[] A, int target) {
+        int low = 0, high = A.length-1;
+        
+        while(low <= high){
+            
+            int mid = (low + high)/2;
+            
+            if(A[mid] == target) 
+                return mid;
+            
+            else if(A[mid] > target) 
+                high = mid-1;
+            
+            else low = mid+1;
+        }
+        return low;
+    }
+}