Transformed Java/Algorithms folder from submodule to regular folder

manny-pi · manny-pi · commit e5ee749d35c3 · 2022-02-28T09:36:23.000-05:00
diff --git a/Java/Algorithms b/Java/Algorithms
diff --git a/Java/Algorithms/.vscode/settings.json b/Java/Algorithms/.vscode/settings.json
@@ -0,0 +1,7 @@
+{
+    "java.project.sourcePaths": ["src"],
+    "java.project.outputPath": "bin",
+    "java.project.referencedLibraries": [
+        "lib/**/*.jar"
+    ]
+}
diff --git a/Java/Algorithms/src/matrixAlgebra/SquareMatrixMultiplication.java b/Java/Algorithms/src/matrixAlgebra/SquareMatrixMultiplication.java
@@ -0,0 +1,41 @@
+package matrixAlgebra;
+
+import java.util.Arrays; 
+
+
+public class SquareMatrixMultiplication {
+
+    public static int[][] squareMatrixMultiply(int[][] A, int[][] B) {
+
+        int n = A.length; // n equals the number of rows in A
+        int[][] c = new int[n][n]; 
+
+        for(int i = 0; i < n; i++) { 
+            for(int j = 0; j < n; j++) {
+                for(int k = 0; k < n; k++) { 
+                    c[i][j] += A[i][k] * B[k][j]; 
+                }
+            }
+        }
+        return c; 
+    }
+
+    public static void main(String[] args) {
+        int[][] A, B, C; 
+
+        A = new int[][] { 
+            {2, 3}, 
+            {4, 6}  
+        }; 
+
+        B = new int[][] { 
+            {11, 9}, 
+            {2, 16}  
+        }; 
+        
+       C = squareMatrixMultiply(A, B); 
+       for(int[] c: C) { 
+           System.out.println(Arrays.toString(c)); 
+       }
+    }
+}
diff --git a/Java/Algorithms/src/matrixAlgebra/SquareMatrixMultiplicationRecursive.java b/Java/Algorithms/src/matrixAlgebra/SquareMatrixMultiplicationRecursive.java
@@ -0,0 +1,85 @@
+package matrixAlgebra;
+
+import java.util.ArrayList;
+
+
+public class SquareMatrixMultiplicationRecursive {
+    
+    public static int[][] squareMatrixMultiplication(int[][] A, int[][] B) { 
+        ArrayList<ArrayList<Integer>> A1, B2; 
+
+        int rows = A.length, cols = A[0].length; 
+        for(int i = 0; i < rows; i++) {
+            for(int j = 0; j < cols; j++) { 
+                try { 
+
+                    /* */ 
+
+                } catch(IndexOutOfBoundsException e) { 
+                    
+                    /* */ 
+
+                }
+            }
+        } 
+
+        return null; 
+    }
+    
+    /* Note: int i is just to stop the compiler from complaining; redundant parameter*/ 
+    public static ArrayList<ArrayList<Integer>> squareMatrixMultiplication(int[][] A, int[][] B, int i) {
+        int n = A.length; 
+        
+        if (n == 1) {
+            
+        } else {
+            
+            /* Calculate the start, mid, and end indexes */
+            int start = 0, end = n - 1; 
+            int mid = (int) Math.floor((start + end) / 2); 
+            
+            /* Partition A, B, and C into submatrices */ 
+            int[][] A11 = subarray(A, start, mid, start, mid); 
+            int[][] A12 = subarray(A, start, mid, mid + 1, end); 
+            int[][] A21 = subarray(A, mid + 1, end, start, end);
+            int[][] A22 = subarray(A, mid + 1, end, mid + 1, end);
+            
+            int[][] B11 = subarray(A, start, mid, start, mid); 
+            int[][] B12 = subarray(A, start, mid, mid + 1, end); 
+            int[][] B21 = subarray(A, mid + 1, end, start, end);
+            int[][] B22 = subarray(A, mid + 1, end, mid + 1, end);
+            
+        }
+        
+        return null; 
+    }
+    
+    public static int[][] subarray(int[][] nums, int rowStart, int rowEnd, int colStart, int colEnd) {
+        int n = nums.length; 
+        int[][] sub = new int[n][n]; 
+        for(int i = rowStart; i <= rowEnd; i++) { 
+            for(int j = colStart; j <= colEnd; j++) { 
+                sub[i - rowStart][j - colStart] = nums[i][j]; 
+            }
+        }
+        
+        return sub; 
+    }
+    
+    public static int[][] sum(int[][] A, int[][] B) { 
+        int n = A.length; 
+        int[][] sum = new int[n][n];
+        
+        for(int i = 0; i < n; i++) { 
+            for(int j = 0; j < n; j++) {
+                sum[i][j] = A[i][j] + B[i][j]; 
+            }
+        }
+        
+        return sum; 
+    }
+    
+    public static void main(String[] args) { 
+        
+    }
+}
diff --git a/Java/Algorithms/src/searchAlgorithms/BinarySearch.java b/Java/Algorithms/src/searchAlgorithms/BinarySearch.java
@@ -0,0 +1,30 @@
+package searchAlgorithms;
+
+
+public class BinarySearch {
+    public static int binarySearch(Double[] data, Double value) { 
+        int low = 0;
+        int high = data.length - 1; 
+        int mid = (int) (low + high) / 2; 
+        
+        while (low <= high) { 
+            if (data[mid].equals(value)) {
+                return mid;
+            } else { 
+                if (data[mid].compareTo(value) > 0) { 
+                    high = mid - 1; 
+                    mid = (int) (low + high) / 2; 
+                } else if(data[mid].compareTo(value) < 0) { 
+                    low = mid + 1; 
+                    mid = (int) (low + high) / 2; 
+                }
+                return 0; 
+            }
+        }
+        return -1; 
+    }
+    
+    public static void main(String[] args) { 
+
+    }
+}
diff --git a/Java/Algorithms/src/searchAlgorithms/LinearSearch.java b/Java/Algorithms/src/searchAlgorithms/LinearSearch.java
@@ -0,0 +1,32 @@
+package searchAlgorithms;
+
+import java.util.Random;
+import java.util.Arrays; 
+
+public class LinearSearch {
+
+    public static int linearSearch(Object[] data, Object value) { 
+        for (int i = 0; i < data.length; i++) { 
+            if (data[i].equals(value)) return i; 
+        }
+
+        return -1; 
+    }
+
+    public static void main(String[] args) { 
+        Random random = new Random(); 
+        Double[] data = new Double[10]; 
+        for (int i = 0; i < 10; i++) { 
+            data[i] = random.nextDouble() * 100;
+        }
+
+        double val1 = data[5]; 
+        double val2 = 34.4f; 
+        
+        System.out.println("Data: " + Arrays.toString(data)); 
+
+        System.out.printf("val1: %f -> result: %d\n", val1, linearSearch(data, val1)); 
+        System.out.printf("val2: %f -> result: %d\n", val2, linearSearch(data, val2)); 
+
+    }
+}
diff --git a/Java/Algorithms/src/searchAlgorithms/MaximumSubarrayProblem.java b/Java/Algorithms/src/searchAlgorithms/MaximumSubarrayProblem.java
@@ -0,0 +1,64 @@
+package searchAlgorithms;
+
+
+public class MaximumSubarrayProblem {
+    
+    public static double[] findMaxCrossingSubarray(double[] A, int low, int mid, int high) { 
+        double leftSum = Double.NEGATIVE_INFINITY; 
+        double sum = 0; 
+        int maxLeft = mid; 
+        for (int i = mid; i >= low; i--) { 
+            sum = sum + A[i]; 
+            if (sum > leftSum) { 
+                leftSum = sum; 
+                maxLeft = i; 
+            }
+        }
+        
+        double rightSum = Double.NEGATIVE_INFINITY; 
+        sum = 0; 
+        int maxRight = mid + 1; 
+        for (int j = mid + 1; j < high; j++) { 
+            sum = sum + A[j]; 
+            if (sum > rightSum) { 
+                rightSum = sum; 
+                maxRight = j; 
+            }
+        }
+        return new double[]{maxLeft, maxRight, leftSum + rightSum}; 
+    }
+    
+    public static double[] findMaximumSubarray(double[] A, int low, int high) { 
+        if (high == low) { 
+            return new double[] {low, high, A[low]}; 
+        } 
+        
+        int mid = (int) Math.floor((low + high) / 2); 
+        double[] left = findMaximumSubarray(A, low, mid); 
+        double[] right = findMaximumSubarray(A, mid + 1, high); 
+        double[] cross = findMaxCrossingSubarray(A, low, mid, high); 
+        
+        double leftSum = left[2], rightSum = right[2], crossSum = cross[2]; 
+        if (leftSum >= rightSum && leftSum >= crossSum) { 
+            return left; 
+        }
+        else if (rightSum >= leftSum && rightSum >= crossSum) { 
+            return right; 
+        }
+        return cross; 
+    }
+    
+    public static void main(String[] args) { 
+        double[] prices = new double[] {13, -3, -25, 20, -3, -16, -23, 18, 20, -7, 12, - 5, -22, 15,-4, 7};
+        double[] sub = findMaximumSubarray(prices, 0, prices.length - 1); 
+        
+        int low = (int) sub[0], high = (int) sub[1]; 
+        double maxValue = sub[2]; 
+        
+        System.out.println("Max Subarray: ");
+        for(int i = low; i <= high; i++) { 
+            System.out.print(prices[i] + " "); 
+        }
+        System.out.println("\nMax value: " + maxValue); 
+    } 
+}
diff --git a/Java/Algorithms/src/sortAlgorithms/InsertionSort.java b/Java/Algorithms/src/sortAlgorithms/InsertionSort.java
@@ -0,0 +1,32 @@
+package sortAlgorithms;
+
+import java.util.Arrays; 
+
+
+public class InsertionSort {
+
+    public static void insertionSort(int[] nums) { 
+        int key; 
+        int j; 
+
+        for(int i = 1; i < nums.length - 1; i++) { 
+            key = nums[i]; 
+            j = i - 1; 
+
+            while (j >= 0 && nums[j] > key) { 
+                nums[j + 1] = nums[j]; 
+                nums[j] = key; 
+                j -= 1; 
+            }
+        }    
+    }
+
+    public static void main(String[] args) { 
+         int[] nums = new int[] {11, 5, 3, 2, 5, 7, 8, 9, 42}; 
+         System.out.println("Original: " + Arrays.toString(nums)); 
+         
+         insertionSort(nums);
+
+         System.out.println("Sorted: " + Arrays.toString(nums));
+    }
+}
diff --git a/Java/Algorithms/src/sortAlgorithms/MergeSort.java b/Java/Algorithms/src/sortAlgorithms/MergeSort.java
@@ -0,0 +1,73 @@
+package sortAlgorithms;
+
+import java.util.Arrays; 
+
+
+public class MergeSort {
+    public static void mergerSort(int[] nums) {
+        if (nums.length <= 1) { 
+            /* Do nothing */
+            return; 
+
+        } else { 
+            mergeSort(nums, 0, nums.length - 1);
+        }
+    }
+    
+    public static void mergeSort(int[] nums, int leftBound, int rightBound) { 
+        if (leftBound < rightBound) { 
+            int mid = (int) Math.floor((leftBound + rightBound) / 2); 
+            mergeSort(nums, leftBound, mid);
+            mergeSort(nums, mid + 1, rightBound);
+            mergeSortAux(nums, leftBound, mid, rightBound); 
+        }
+    }
+
+    public static void mergeSortAux(int[] nums, int leftBound, int mid, int rightBound) { 
+        int n1 = mid - leftBound + 1; 
+        int n2 = rightBound - mid; 
+
+        int[] L = new int[n1 + 1], R = new int[n2 + 1]; 
+
+        for (int i = leftBound; i <= n1; i++) { 
+            L[i] = nums[i]; 
+        }
+        L[n1] = (int) Double.POSITIVE_INFINITY; 
+
+        for (int j = mid + 1; j <= rightBound; j++) { 
+            R[j - (mid + 1)] = nums[j]; 
+        }
+        R[n2] = (int) Double.POSITIVE_INFINITY; 
+
+        int i = 0, j = 0; 
+        for (int k = leftBound; k <= rightBound; k++) { 
+            if (k <= mid)
+                if (L[k] == Double.POSITIVE_INFINITY) { 
+                    nums[k] = R[j];  
+                    j++; 
+
+            } else if (R[j] == Double.POSITIVE_INFINITY) { 
+                R[k] = L[i]; 
+                i++;
+                
+            } else {
+                if (L[i] <= R[j]) { 
+                    nums[k] = L[i]; 
+                    i++; 
+                } else { 
+                    nums[k] = R[j]; 
+                    j++; 
+                }
+            }
+        }
+    }
+
+    public static void main(String[] args) { 
+        int[] nums = new int[] {11, 5, 3, 2, 5, 7, 8, 9}; 
+        System.out.println("Original: " + Arrays.toString(nums)); 
+        
+        mergeSort(nums, 0, nums.length - 1);
+
+        System.out.println("Sorted: " + Arrays.toString(nums));
+    }
+}
diff --git a/Java/Algorithms/src/sortAlgorithms/SelectionSort.java b/Java/Algorithms/src/sortAlgorithms/SelectionSort.java
