-

src/Main.java

@@ -17,10 +17,63 @@
 public class Main {
     public static void main(String[] args) {
         int[] nums = {19, 48, 99, 71, 13, 52, 96, 73, 86, 7};
-        Quicksort.quickSort(nums, 0, nums.length - 1);
+        mergeSort(nums);
         System.out.println(Arrays.toString(nums));
     }
 
+    public static void mergeSort(int[] nums) {
+        int n = nums.length;
+        if (nums == null || n < 2)
+            return;
+
+        int midPoint = n / 2; // Divide the array into half
+        int[] leftHalf = new int[midPoint];
+        int[] rightHalf = new int[n - midPoint];
+
+        // Copy all elements from start to the midpoint
+        for (int i = 0; i < midPoint; i++) {
+            leftHalf[i] = nums[i];
+        }
+        // Copy all elements from the midpoint to the length
+        for (int i = midPoint; i < n; i++) {
+            rightHalf[i - midPoint] = nums[i];
+        }
+
+        mergeSort(leftHalf); // sort left half
+        mergeSort(rightHalf); // sort right half
+        merge(nums, leftHalf, rightHalf); // merge the left and right half
+    }
+
+    private static void merge(int[] merged, int[] first, int[] second) {
+
+        // Get three variables, i for the first, j for the second, k for the merged array
+        int i = 0, j = 0, k = 0;
+
+        while (i < first.length && j < second.length) {
+            if (first[i] <= second[j]) {
+                merged[k] = first[i];
+                i++;
+            } else {
+                merged[k] = second[j];
+                j++;
+            }
+            k++;
+        }
+
+        // Check for remaining elements in the left or right but not both
+        while (i < first.length){
+            merged[k] = first[i];
+            i++;
+            k++;
+        }
+
+        while (j < second.length){
+            merged[k] = second[j];
+            j++;
+            k++;
+        }
+    }
+
     static void bubble_sort(int[] array, int size) {
         int i, j;
 
@@ -52,7 +105,7 @@ public static int squareOfDigits(int n) {
         int ans = 0;
         while (n > 0) {
             int remainder = n % 10;
-            ans  += remainder * remainder;
+            ans += remainder * remainder;
             n /= 10;
         }
         return ans;

src/advance/AVLTree.java → src/advance/trees/AVLTree.java

@@ -1,4 +1,4 @@
-package advance;
+package advance.trees;
 
 class AVLTree {
 

src/advance/BinarySearchTree.java → src/advance/trees/BinarySearchTree.java

@@ -1,4 +1,4 @@
-package advance;
+package advance.trees;
 
 public class BinarySearchTree {
 

src/advance/BinaryTree.java → src/advance/trees/BinaryTree.java

@@ -1,4 +1,4 @@
-package advance;
+package advance.trees;
 
 import java.util.Scanner;
 

src/advance/BitManipulation.java → src/advance/trees/BitManipulation.java

@@ -1,4 +1,4 @@
-package advance;
+package advance.trees;
 
 public class BitManipulation {
 

src/advance/BitwiseNums.java → src/advance/trees/BitwiseNums.java

@@ -1,4 +1,4 @@
-package advance;
+package advance.trees;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;

src/advance/trees/interviews/BFS.java

@@ -0,0 +1,105 @@
+package advance.trees.interviews;
+
+import com.sun.source.tree.Tree;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class BFS {
+
+    // https://leetcode.com/problems/binary-tree-level-order-traversal/
+    public List<List<Integer>> levelOrderTraversal(TreeNode root) {
+        List<List<Integer>> result = new ArrayList<>();
+        if (root == null)
+            return result;
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+
+        while (!queue.isEmpty()) {
+            int levelSize = queue.size();
+
+            // Get the current level list(the list at each level of the tree)
+            List<Integer> subList = new ArrayList<>(levelSize);
+
+            // Loop through the level
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode currentNode = queue.poll();
+                if (currentNode != null) {
+                    subList.add(currentNode.value);
+
+                    if (currentNode.left != null)
+                        queue.offer(currentNode.left);
+                    if (currentNode.right != null)
+                        queue.offer(currentNode.right);
+                }
+
+            }
+            result.add(subList);
+        }
+        return result;
+    }
+
+    // https://leetcode.com/problems/average-of-levels-in-binary-tree/description/
+    public List<Double> averageOfLevels(TreeNode root) {
+        List<Double> result = new ArrayList<>();
+
+        if (root == null)
+            return result;
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+
+        while (!queue.isEmpty()) {
+            int levelSize = queue.size();
+            double averageOfEachLevel = 0;
+
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode currentNode = queue.poll(); // the head or top node
+                averageOfEachLevel += currentNode.value;
+
+                if (currentNode.left != null)
+                    queue.offer(currentNode.left);
+                if (currentNode.right != null)
+                    queue.offer(currentNode.right);
+            }
+            averageOfEachLevel /= levelSize;
+            result.add(averageOfEachLevel);
+        }
+        return result;
+    }
+
+    /*
+    Given the root of a binary tree,
+    return the sum value of the nodes on each level in the form of an array.
+    Answers within 10-5 of the actual answer will be accepted.
+     */
+    public List<Integer> sumOfLevels(TreeNode root) {
+        List<Integer> result = new ArrayList<>();
+
+        if (root == null)
+            return result;
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+
+        while (!queue.isEmpty()){
+            int levelSize=queue.size();
+            int sumOfAtLevel = 0;
+
+            for (int i=0; i < levelSize; i++){
+                TreeNode currentNode = queue.poll(); // the topmost node
+                sumOfAtLevel += currentNode.value;
+
+                if (currentNode.left != null)
+                    queue.offer(currentNode.left);
+                if (currentNode.right != null)
+                    queue.offer(currentNode.right);
+            }
+            result.add(sumOfAtLevel);
+        }
+        return result;
+    }
+}

src/advance/trees/interviews/TreeNode.java

@@ -0,0 +1,19 @@
+package advance.trees.interviews;
+
+import com.sun.source.tree.Tree;
+
+class TreeNode {
+     int value;
+     TreeNode left;
+     TreeNode right;
+
+    TreeNode(int value, TreeNode left, TreeNode right){
+        this.value = value;
+        this.left = left;
+        this.right = right;
+    }
+
+    TreeNode(int value){
+        this.value = value;
+    }
+}

src/intermediate/MergeSort.java

@@ -18,7 +18,7 @@ public static void main(String[] args) {
         mergeSort(nums);
         long endTime = System.currentTimeMillis();
         System.out.println("After: ");
-         printArray(nums);
+        printArray(nums);
         System.out.println("\nTime taken: " + (endTime - startTime) + "ms");
 
     }
@@ -31,28 +31,31 @@ static void mergeSort(int[] nums) {
 
         int n = nums.length;
         int middle = n / 2;
-        int[] left = new int[middle];
-        int[] right = new int[n - middle];
+        int[] leftSubArray = new int[middle];
+        int[] rightSubArray = new int[n - middle];
 
         for (int i=0; i < middle; i++){
-            left[i] = nums[i];
+            leftSubArray[i] = nums[i];
         }
         for (int j = middle; j < n; j++){
-            right[j - middle] = nums[j];
+            // start the right sub array from 0. eg: if middle is 5, j is also 5
+            // Therefore, 5 - 5 = 0. when j is 6, we get 6 - 5 = 1, when j is 7
+            // we get 7 - 5 = 2 and so on
+            rightSubArray[j - middle] = nums[j];
         }
-        mergeSort(left); // sort
-        mergeSort(right); // sort
+        mergeSort(leftSubArray); // sort leftSubArray sub array
+        mergeSort(rightSubArray); // sort rightSubArray sub array
 
         // merge both halves
-        merge(nums, left, right); // Merge
+        merge(nums, leftSubArray, rightSubArray); // Merge both leftSubArray and rightSubArray sub array
     }
 
     private static void merge(int[] mix, int[] first, int[] second)
     {
         int i = 0, j = 0, k = 0;
 
         while (i < first.length && j < second.length) {
-            if (first[i] < second[j]) {
+            if (first[i] <= second[j]) {
                 mix[k] = first[i];
                 i++;
             } else {
@@ -63,7 +66,7 @@ private static void merge(int[] mix, int[] first, int[] second)
         }
 
         // At the end, it may be possible that one of the arrays is not complete
-        // copy the remaining elements. Please note that either of the loops will run
+        // copy the remaining elements. Please note that either of the loops will run not both
         while (i < first.length) {
             mix[k] = first[i];
             i++;

src/intermediate/Quicksort.java

@@ -41,6 +41,7 @@ public static void quicksortPretty(int[] nums){
     }
 
     // Approach 2, Quicksort using lomuto partition
+    // O(LOG(N)) on BEST and AVERAGE, O(N^2) on WORST CASE
     public static void quicksortLomuto(int[] nums, int start, int end) {
         // First, check the case only one element left to sort
         if (start >= end || nums == null)
@@ -87,8 +88,13 @@ public static void printArray(int[] nums) {
     }
 
     public static void main(String[] args) {
+        testQuickSort();
+    }
+
+    private static void testQuickSort() {
         Random random = new Random();
-        int[] nums = new int[10];
+        int[] nums = new int[1000];
+        long startTime = System.currentTimeMillis();
 
         for (int i = 0; i < nums.length; i++) {
             nums[i] = random.nextInt(100);
@@ -98,10 +104,12 @@ public static void main(String[] args) {
         printArray(nums);
 
         quicksortPretty(nums);
+        long endTime  = System.currentTimeMillis();
 
         System.out.println("AFTER");
         printArray(nums);
 
-    }
+        System.out.println("\nTime taken: " + (endTime - startTime) + "ms");
 
-}
+    }
+}