Arrays & Heaps

Author: abhiabhi

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

@@ -0,0 +1,58 @@
+package com.arrays;
+/*
+
+Dynamic programming solves a problem by dividing it into smaller subproblems. This is very similar to the divide-and-conquer algorithm solving technique.
+ The major difference, however, is that dynamic programming solves a subproblem only once.
+It then stores the result of this subproblem and later reuses this result to solve other related subproblems. This process is known as memoization.
+
+Dynamic programming builds solutions from the bottom up by breaking each problem down into smaller,
+problems that you solve first. Recursion also breaks problems down into subproblems but does this from
+the top down.
+One advantage of dynamic programming over recursion is that it prevents possible duplicate solutions of the same subproblem,
+which uses less CPUs and generally makes your code run faster.
+
+Complexity of finding largest sum subarray in an array is O(N) in time and O(1) in space.
+
+    */
+
+public class MaxSumSubArray_KadaneAlgo_DynamicProgram {
+
+    public static void main(String[] args) {
+
+        int[] arr = {-1, 3, -5, 4, 6, -1, 2, -7, 3, -3};
+
+        int[] result = findMaxSumIndex(arr);
+        System.out.println("start index :" + result[0]);
+        System.out.println("End index :" + result[1]);
+        System.out.println("Sum :" + result[2]);
+
+    }
+
+    private static int[] findMaxSumIndex(int[] arr) {
+        int[] result = new int[3];
+        int maxSumTillNow = Integer.MIN_VALUE;
+
+        int tempStartIndex = 0;
+        int tempSum = 0;
+
+        for (int i = 0; i < arr.length; i++) {
+            tempSum = tempSum + arr[i];
+
+            if (tempSum > maxSumTillNow) {
+                maxSumTillNow = tempSum;
+                result[0] = tempStartIndex;
+                result[1] = i;
+                result[2] = maxSumTillNow;
+            }
+
+            //Important Condition to reset
+            if (tempSum < 0) {
+                tempSum = 0;
+                tempStartIndex = i + 1;
+            }
+        }
+        return result;
+    }
+}
+
+

src/main/java/com/arrays/MaxSumSubArray_KadaneAlgo_DynamicProgram.java

@@ -1,6 +1,8 @@
 package com.arrays;
 
 /*
+ 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.
 The task is to write a function that sorts the given array.

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

@@ -0,0 +1,49 @@
+package com.arrays;
+
+/**
+ * https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/solution/
+ * Approach-3
+ *
+ * we can simply go on crawling over the slope and keep on adding the profit obtained
+ * from every consecutive transaction.
+ *
+ * we can directly keep on adding the difference between the consecutive numbers of the array
+ * if the second number is larger than the first one, and at the total sum we obtain will be the maximum profit.
+ *
+ * Since there is no transaction limit, we just calculate max amount of profit, which is
+ * "any price raise is profit".
+ *
+ * From the above graph, we can observe that the sum A+B+C is equal to the difference D
+ * corresponding to the difference between the heights of the consecutive peak and valley.
+ *
+ * Example 1:
+ *
+ * Input: [7,1,5,3,6,4]
+ * Output: 7
+ * Explanation: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
+ *              Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
+ *
+ *  Complexity Analysis
+ *
+ * Time complexity : O(n). Single pass.
+ *
+ * Space complexity: O(1). Constant space needed.
+ */
+public class StockBuySellToMaximizeProfit_PeakValleyApproach {
+
+    public static int maxProfit(int[] prices) {
+        int maxprofit = 0;
+        for (int i = 1; i < prices.length; i++) {
+            if (prices[i] > prices[i - 1])
+                maxprofit += prices[i] - prices[i - 1];
+        }
+        return maxprofit;
+    }
+
+    public static void main (String args[]){
+        int[] price  = {100,60,120,110,90,200};
+        int maxProfit= maxProfit(price);
+        System.out.println(maxProfit);
+
+    }
+}

src/main/java/com/arrays/StockBuySellToMaximizeProfit_PeakValleyApproach.java

@@ -0,0 +1,37 @@
+package com.heaps;
+
+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
+
+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.
+
+Time complexity of finding the k’th largest element is O(Logk).
+
+ */
+public class KthLargestElement {
+
+    public static int findKthLargest(int arr[], int k) {
+        PriorityQueue<Integer> minHeap = new PriorityQueue<>();
+        for (int num : arr) {
+            minHeap.add(num);
+            if (minHeap.size() > k) {
+
+                //this will remove the element from root since its minHeap it will remove minimum element.
+                //this will rearrange the elements back in proper heap with min element on root.
+                minHeap.remove();
+            }
+        }
+        return minHeap.remove();
+    }
+
+    public static void main(String args[]) {
+        int arr[] = {10, 70, 20, 30, 50, 80};
+        int result = findKthLargest(arr, 2);
+        System.out.println(result);
+    }
+}

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

@@ -0,0 +1,46 @@
+package com.heaps;
+
+import java.util.PriorityQueue;
+
+
+/*
+
+Example:
+
+int[] A = { 1, 2, 10, 20, 40, 32, 44, 51, 6 };
+
+K=4. 4th smallest element in given array: 10
+
+Approach: (Kth Smallest Element)
+        Use min-Heap. (Click here to read about Priority Queue).
+        Insert all the elements in the Priority Queue.
+        Extract K elements from the priority queue.
+        The last element (kth) extracted with be the kth smallest element in the array.
+
+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
+
+
+*/
+public class KthSmallestElement {
+
+    public static int findKthSmallest(int arr[], int k) {
+        PriorityQueue<Integer> minHeap = new PriorityQueue<>();
+        for (int num : arr) {
+            minHeap.add(num);
+        }
+            int n = -1;
+            while(k>0){
+                 n = minHeap.poll();
+                 k--;
+            }
+
+        return n;
+    }
+
+    public static void main(String args[]) {
+        int arr[] = {10, 70, 20, 30, 50, 80};
+        int result = findKthSmallest(arr, 5);
+        System.out.println(result);
+    }
+}