Arrays & Heaps

Author: abhiabhi

src/main/java/com/arrays/InversionCountInArray_MergeSort.html

@@ -0,0 +1,86 @@
+package com.arrays;
+
+import java.util.Arrays;
+
+/**
+ * Inversion Count : For an array, inversion count indicates how far (or close) the array is from being sorted.
+ * If array is already sorted then inversion count is 0. If array is sorted in reverse order that inversion count is the maximum.
+ * Formally, two elements a[i] and a[j] form an inversion if a[i] > a[j] and i < j.
+ * <p>
+ * <p>
+ * Algorithm:
+ * The idea is similar to merge sort, divide the array into two equal or almost equal halves in each step until the base case is reached.
+ * Create a function merge that counts the number of inversions when two halves of the array are merged,
+ * create two indices i and j, i is the index for first half and j is an index of the second half.
+ * if a[i] is greater than a[j], then there are (mid – i) inversions. because left and right subarrays are sorted, so all the remaining elements in left-subarray (a[i+1], a[i+2] … a[mid]) will be greater than a[j].
+ * Create a recursive function to divide the array into halves and find the answer by summing the number of inversions is the first half, number of inversion in the second half and the number of inversions by merging the two.
+ * The base case of recursion is when there is only one element in the given half.
+ * Print the answer
+ * <p>
+ * <p>
+ * Complexity Analysis:
+ * Time Complexity: O(n log n), The algorithm used is divide and conquer, So in each level one full array traversal is needed and there are log n levels so the time complexity is O(n log n).
+ * Space Compelxity:O(1), No extra space is required.
+ */
+public class InversionCountInArray_MergeSort {
+
+    // Merge two sorted subarrays arr[low .. mid] and arr[mid + 1 .. high]
+    public static int merge(int[] arr, int leftIndex, int midIndex, int rightIndex) {
+        // Left subarray
+        int[] left = Arrays.copyOfRange(arr, leftIndex, midIndex + 1);
+
+        // Right subarray
+        int[] right = Arrays.copyOfRange(arr, midIndex + 1, rightIndex + 1);
+
+        int leftCursor = 0, rightCursor = 0, current = leftIndex, swaps = 0;
+
+        while (leftCursor < left.length && rightCursor < right.length) {
+            if (left[leftCursor] <= right[rightCursor])
+                arr[current++] = left[leftCursor++];
+            else {
+                arr[current++] = right[rightCursor++];
+                swaps += (midIndex + 1) - (leftIndex + leftCursor);  /**important*/
+            }
+        }
+
+        // Fill from the rest of the left subarray
+        while (leftCursor < left.length)
+            arr[current++] = left[leftCursor++];
+
+        // Fill from the rest of the right subarray
+        while (rightCursor < right.length)
+            arr[current++] = right[rightCursor++];
+
+        return swaps;
+    }
+
+    // Sort array arr [low..high] using auxiliary array aux[]
+    public static int mergeSort(int[] arr, int low, int high) {
+        // Base case
+        if (high == low) {    // if run size == 1
+            return 0;
+        }
+
+        // find mid point
+        int mid = (low + high) / 2;
+        int inversionCount = 0;
+
+        // recursively split runs into two halves until run size == 1,
+        // then merge them and return back up the call chain
+
+        inversionCount += mergeSort(arr, low, mid);        // split / merge left half
+        inversionCount += mergeSort(arr, mid + 1, high); // split / merge right half
+        inversionCount += merge(arr, low, mid, high);    // merge the two half runs
+
+        return inversionCount;
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {1, 9, 6, 4, 5};
+        int[] aux = Arrays.copyOf(arr, arr.length);
+
+        // get inversion count by performing merge sort on arr
+        System.out.println("Inversion count is " +
+                mergeSort(arr, 0, arr.length - 1));
+    }
+}

src/main/java/com/arrays/InversionCountInArray_MergeSort.java

@@ -1,7 +1,7 @@
 package com.arrays;
 
-/*
- Dutch National Flag Algorithm, or 3-way Partitioning
+/**
+Dutch National Flag Algorithm, or 3-way Partitioning
 
 Sort an array of 0s, 1s and 2s
 Given an array A[] consisting 0s, 1s and 2s.
@@ -21,76 +21,81 @@
 Count the number of 0’s, 1’s and 2’s. After Counting, put all 0’s first, then 1’s and lastly 2’s in the array.
 We traverse the array two times. Time complexity will be O(n).
 
-Best Solution
-https://algorithmsandme.com/dutch-national-flag-problem/
- */
-
-public class SortArrayOf0s1s2s_DutchNationalFlagAlgo {
-/*
     Dutch national flag problem : algorithm
     Start with three pointers : reader, low and high.
     reader and low are initialized as 0 and high is initialized as last element of array as size-1.
     reader will be used to scan the array while low and high will be used to swap elements to their desired positions.
     Starting with current position of reader, follow below steps, keep in mind we need 0 at start of array
     If element at index reader is 0, swap element at reader with element at low and increment low and reader by 1.
     If element at reader is 1, do not swap and increment reader by 1.
-    If element at reader is 2, swap element at reader with element at high and decrease high by 1*/
+    If element at reader is 2, swap element at reader with element at high and decrease high by 1
 
+    Actually, three pointers divide array into four parts.  Red, white, unknown and Blue.
+    Every element is taken from unknown part and put into its right place.
+    So all three other parts expand while unknown part shrinks.
 
-    public void dutchNationalFlagAlgorithm(){
+Best Solution
+https://algorithmsandme.com/dutch-national-flag-problem/
+*/
 
-    }
 
-    public static void sort012(int arr[], int arr_size) {
-        int countZero = 0;
-        int countOne = 0;
-        int countTwo = 0;
-        for (int a : arr) {
-            if (a == 0) {
-                countZero++;
-            } else if (a == 1) {
-                countOne++;
-            } else if (a == 2) {
-                countTwo++;
-            }
-        }
+public class SortArrayOf0s1s2s_DutchNationalFlagAlgo {
 
-        int i = 0;
-        while (countZero > 0) {
-            arr[i] = 0;
-            countZero--;
-            i++;
+        public static void swap(int[] input, int i, int j){
+            int temp =  input[i];
+            input[i] = input[j];
+            input[j] = temp;
         }
 
-        while (countOne > 0) {
-            arr[i] = 1;
-            countOne--;
-            i++;
-        }
+        public static void dutchNationalFalgAlgorithm(int [] input){
+
+            //initialize all variables
+            int reader = 0;
+            int low = 0;
+            int high = input.length - 1;
+
+            while(reader <= high){
+            /*
+              input always holds a permutation of the
+              original data with input(0..(lo-1)) =0,
+              input(lo..(reader-1))=1, input(reader..hi) is
+              untouched, and input((hi+1)..(input.length-1)) = 2
+            */
+                if(input[reader] == 0){
+                /*When element at reader is 0, swap
+                element at reader with element at index
+                low and increment reader and low*/
+                    swap(input, reader, low);
+                    reader++;
+                    low++;
+                }
+                else if(input[reader] == 1){
+                /* if element at reader is just
+                increment reader by 1 */
+                    reader++;
+                }
+                else if(input[reader] == 2){
+                /* If element at reader is 2, swap
+                 element at reader with element at
+                 high and decrease high by 1 */
+                    swap(input, reader, high);
+                    high--;
+                }
+                else{
+                    System.out.println("Bad input");
+                    break;
+                }
+            }
 
-        while (countTwo > 0) {
-            arr[i] = 2;
-            countTwo--;
-            i++;
         }
+        public static void main(String[] args) {
+            int[] input = {2,2,1,1,0,0,0,1,1,2};
 
-    }
-
+            dutchNationalFalgAlgorithm(input);
 
-    /* Utility function to print array arr[] */
-    static void printArray(int arr[], int arr_size) {
-        int i;
-        for (i = 0; i < arr_size; i++)
-            System.out.print(arr[i] + " ");
-        System.out.println("");
+            for(int i=0; i<input.length; i++){
+                System.out.print(" " + input[i]);
+            }
+        }
     }
 
-    /*Driver function to check for above functions*/
-    public static void main(String[] args) {
-        int arr[] = {0, 1, 1, 0, 1, 2, 1, 2, 0, 0, 0, 1};
-        int arr_size = arr.length;
-        sort012(arr, arr_size);
-        System.out.println("Array after seggregation ");
-        printArray(arr, arr_size);
-    }
-}

src/main/java/com/arrays/SortArrayOf0s1s2s_DutchNationalFlagAlgo.java

@@ -33,8 +33,8 @@ public class TripletSumInArray_Sorting_TwoPointerAlgo {
 
     public static void find_all_triplets(int[] arr, int sum) {
 
-        // sort array elements
-        Arrays.sort(arr);  /*important*/
+        /**sort array elements*/
+        Arrays.sort(arr);  /**important*/
 
         int n = arr.length;
         int left;

src/main/java/com/arrays/TripletSumInArray_Sorting_TwoPointerAlgo.java

@@ -2,10 +2,10 @@
 
 import java.util.PriorityQueue;
 
-/*
+/**
 
 Link to priority Queue -
-https://onedrive.live.com/redir?resid=26052E8C3C647484%21105&page=Edit&wd=target%28Queue.one%7C71d394a6-f4c4-41dd-b56a-e1878e78a88a%2FPriorityQueue%7C27bf58ff-75e1-4c3a-aa71-2823e1ff846b%2F%29
+https://onedrive.live.com/redir?resid=26052E8C3C647484%21105&page=Edit&wd=target%28Queue.one%7C71d394a6-f4c4-41dd-b56a-e1878e78a88a%2FPriorityQueue%7C27bf58ff-75e1-4c3a-aa71-2823e1ff846b%2F%29&wdorigin=703
 
 An Efficient Solution is to use Min Heap of size k to store k largest elements of the stream.
 The k’th largest element is always at root and can be found in O(1) time.

src/main/java/com/heaps/KthLargestElement.java

@@ -0,0 +1,12 @@
+package com.test;
+
+public class TestDefault {
+ int i;
+
+
+    public static void main (String args[]){
+        TestDefault td =  new TestDefault();
+        System.out.println(td.i);
+
+    }
+}