Arrays & Heaps

Author: abhiabhi

src/main/java/com/arrays/MaxSumWithoutAdjacents.java

@@ -0,0 +1,36 @@
+package com.arrays;
+
+/**
+ *
+ * Complexity Analysis:
+ * Time Complexity: O(n), Only one traversal of original array is needed. So the time complexity is O(n).
+ *
+ * Question
+ * Stickler the thief wants to loot money from a society having n houses in a single line.
+ * Rule 1 - never loot two consecutive houses.
+ * he wants to maximize the amount he loots.
+ * find the maximum money he can get if he strictly follows the rule.
+ *
+ */
+public class MaxSumWithoutAdjacents {
+
+    public static void main(String[] args) {
+
+        int[] input = {3, 2, 5, 10, 7};
+        int counter = 0;
+        int evenSum = 0;
+        int oddSum = 0;
+
+        while (counter != input.length) {
+
+            if (counter % 2 == 0) {
+                evenSum += input[counter];
+            } else {
+                oddSum += input[counter];
+            }
+            counter++;
+        }
+        int max = Integer.max(evenSum, oddSum);
+        System.out.println(max);
+    }
+}

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

@@ -1,6 +1,8 @@
 package com.arrays;
 
 /**
+ * https://onedrive.live.com/redir?resid=26052E8C3C647484%21105&page=Edit&wd=target%28Programs.one%7C6d1885b7-0ca6-4a4e-81df-92e3ac05fb6f%2FStockBuySellMaximizeProfit%7C9427c9b7-0a0a-41ec-b618-85ab5bbc1447%2F%29&wdorigin=703
+ *
  * https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/solution/
  * Approach-3
  *
@@ -28,7 +30,9 @@
  * Time complexity : O(n). Single pass.
  *
  * Space complexity: O(1). Constant space needed.
- */
+ *
+ *
+ * */
 public class StockBuySellToMaximizeProfit_PeakValleyApproach {
 
     public static int maxProfit(int[] prices) {

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

@@ -0,0 +1,66 @@
+package com.arrays;
+
+import java.util.Arrays;
+
+/**
+ * This method uses the method of Sorting and Two-pointer Technique to solve the above problem.
+ * This execution will involve O(n2)) time complexity and O(1) space complexity.
+ */
+
+
+/**
+ * 1. Sort all element of array
+ * 2. Run loop from i=0 to n-2.
+ * Initialize two index variables l=i+1 and r=n-1
+ * 4. while (l < r)
+ * Check sum of arr[i], arr[l], arr[r] is
+ * given sum or not if sum is 'sum', then print
+ * the triplet and do l++ and r--.
+ * 5. If sum is less than given sum then l++
+ * 6. If sum is greater than given sum then r--
+ * 7. If not exist in array then print not found.
+ */
+
+/**
+ * Complexity Analysis:
+ * Time Complexity: O(n2).
+ * Use of a nested loop (one for iterating , other for two-pointer technique) brings the time complexity to O(n2).
+ * Auxiliary Space: O(1).
+ * As no use of additional data structure is used.
+ */
+
+public class TripletSumInArray_Sorting_TwoPointerAlgo {
+
+    public static void find_all_triplets(int[] arr, int sum) {
+
+        // sort array elements
+        Arrays.sort(arr);  /*important*/
+
+        int n = arr.length;
+        int left;
+        int right;
+        for (int i = 0; i < n - 2; i++) {
+            left = i + 1;
+            right = n - 1;
+            while (left < right) {
+                int tempSum = arr[i] + arr[left] + arr[right];
+                if (tempSum == sum) {
+                    System.out.println("triplet:{" + arr[i] + "," + arr[left] + "," + arr[right] + "}");
+                    left++;
+                    right--;
+                } else if (tempSum < sum) {
+                    left++;
+                } else {
+                    right--;
+                }
+            }
+        }
+    }
+
+
+    public static void main(String args[]) {
+        int arr[] = {1, 7, 4, 3, 4, 5, 2};
+        int sum = 9;
+        find_all_triplets(arr, sum);
+    }
+}