Merge branch 'master' into RegularExpressionMatching

Author: jayeshrdeotalu

DIRECTORY.md

@@ -31,6 +31,7 @@
             * [IsPowerTwo](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/IsPowerTwo.java)
             * [LowestSetBit](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/LowestSetBit.java)
             * [NonRepeatingNumberFinder](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/NonRepeatingNumberFinder.java)
+            * [NumberAppearingOddTimes](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/NumberAppearingOddTimes.java)
             * [NumbersDifferentSigns](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/NumbersDifferentSigns.java)
             * [ReverseBits](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/ReverseBits.java)
             * [SingleBitOperations](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/SingleBitOperations.java)
@@ -228,6 +229,7 @@
           * divideandconquer
             * [BinaryExponentiation](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/divideandconquer/BinaryExponentiation.java)
             * [ClosestPair](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/divideandconquer/ClosestPair.java)
+            * [MedianOfTwoSortedArrays](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/divideandconquer/MedianOfTwoSortedArrays.java)
             * [SkylineAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/divideandconquer/SkylineAlgorithm.java)
             * [StrassenMatrixMultiplication](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/divideandconquer/StrassenMatrixMultiplication.java)
           * dynamicprogramming
@@ -473,6 +475,7 @@
           * scheduling
             * [FCFSScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/FCFSScheduling.java)
             * [HighestResponseRatioNextScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/HighestResponseRatioNextScheduling.java)
+            * [JobSchedulingWithDeadline](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/JobSchedulingWithDeadline.java)
             * [MLFQScheduler](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/MLFQScheduler.java)
             * [PreemptivePriorityScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/PreemptivePriorityScheduling.java)
             * [RRScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/RRScheduling.java)
@@ -638,6 +641,7 @@
             * [IsPowerTwoTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/IsPowerTwoTest.java)
             * [LowestSetBitTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/LowestSetBitTest.java)
             * [NonRepeatingNumberFinderTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/NonRepeatingNumberFinderTest.java)
+            * [NumberAppearingOddTimesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/NumberAppearingOddTimesTest.java)
             * [NumbersDifferentSignsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/NumbersDifferentSignsTest.java)
             * [ReverseBitsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/ReverseBitsTest.java)
             * [SingleBitOperationsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/SingleBitOperationsTest.java)
@@ -729,6 +733,7 @@
               * [LeftistHeapTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/heaps/LeftistHeapTest.java)
             * lists
               * [CircleLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/CircleLinkedListTest.java)
+              * [CreateAndDetectLoopTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/CreateAndDetectLoopTest.java)
               * [QuickSortLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/QuickSortLinkedListTest.java)
               * [ReverseKGroupTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/ReverseKGroupTest.java)
               * [RotateSinglyLinkedListsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/RotateSinglyLinkedListsTest.java)
@@ -773,12 +778,15 @@
           * divideandconquer
             * [BinaryExponentiationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/divideandconquer/BinaryExponentiationTest.java)
             * [ClosestPairTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/divideandconquer/ClosestPairTest.java)
+            * [MedianOfTwoSortedArraysTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/divideandconquer/MedianOfTwoSortedArraysTest.java)
             * [SkylineAlgorithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/divideandconquer/SkylineAlgorithmTest.java)
             * [StrassenMatrixMultiplicationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/divideandconquer/StrassenMatrixMultiplicationTest.java)
           * dynamicprogramming
             * [BoardPathTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/BoardPathTest.java)
+            * [BruteForceKnapsackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/BruteForceKnapsackTest.java)
             * [CatalanNumberTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/CatalanNumberTest.java)
             * [ClimbStairsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/ClimbStairsTest.java)
+            * [CountFriendsPairingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/CountFriendsPairingTest.java)
             * [EditDistanceTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/EditDistanceTest.java)
             * [EggDroppingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/EggDroppingTest.java)
             * [KnapsackMemoizationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/KnapsackMemoizationTest.java)
@@ -958,6 +966,7 @@
           * scheduling
             * [FCFSSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/FCFSSchedulingTest.java)
             * [HighestResponseRatioNextSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/HighestResponseRatioNextSchedulingTest.java)
+            * [JobSchedulingWithDeadlineTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/JobSchedulingWithDeadlineTest.java)
             * [MLFQSchedulerTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/MLFQSchedulerTest.java)
             * [PreemptivePrioritySchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/PreemptivePrioritySchedulingTest.java)
             * [RRSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/RRSchedulingTest.java)

src/main/java/com/thealgorithms/datastructures/lists/CreateAndDetectLoop.java

@@ -1,63 +1,66 @@
 package com.thealgorithms.datastructures.lists;
 
-import java.util.Scanner;
-
 public final class CreateAndDetectLoop {
+
+    // Node class representing a single node in the linked list
     private CreateAndDetectLoop() {
+        throw new UnsupportedOperationException("Utility class");
     }
+    static final class Node {
+        int data;
+        Node next;
 
-    /**
-     * Prints the linked list.
-     *
-     * @param	head	head node of the linked list
-     */
-    static void printList(Node head) {
-        Node cur = head;
-
-        while (cur != null) {
-            System.out.print(cur.value + " ");
-            cur = cur.next;
+        Node(int data) {
+            this.data = data;
+            next = null;
         }
     }
 
-    /**
-     * Creates a loop in the linked list.
-     *
-     * @see
-     * 	<a href="https://www.geeksforgeeks.org/make-loop-k-th-position-linked-list/">
-     * GeeksForGeeks: Make a loop at K-th position</a>
-     * @param	head	head node of the linked list
-     * @param	k	position of node where loop is to be created
+    // Method to create a loop between two specific positions in the linked list
+    /*
+     *  Test case that shows the Cycle(loop) in a LinkedList
+     *  Let's take this linked list:
+     *  1->2->3->4->5->6
+     *     \______/
+     *   In this linked list we can see there is a cycle.
+     *   we can create loop by calling createLoop function in main after creating LL
+     *   createLoop(head,2,5);
+     *  to detect there is loop or not we can call detectloop function in main
+     *  detectloop(head);
      */
-    static void createLoop(Node head, int k) {
-        if (head == null) {
+
+    static void createLoop(Node head, int position1, int position2) {
+        if (position1 == 0 || position2 == 0) {
             return;
         }
-        Node temp = head;
-        int count = 1;
-        while (count < k) { // Traverse the list till the kth node
-            temp = temp.next;
-            count++;
-        }
 
-        Node connectedPoint = temp;
+        Node node1 = head;
+        Node node2 = head;
 
-        while (temp.next != null) { // Traverse remaining nodes
-            temp = temp.next;
+        int count1 = 1;
+        int count2 = 1;
+        // Traverse to find node at position1
+        while (count1 < position1 && node1 != null) {
+            node1 = node1.next;
+            count1++;
         }
 
-        temp.next = connectedPoint; // Connect last node to k-th element
-    }
+        // Traverse to find node at position2
+        while (count2 < position2 && node2 != null) {
+            node2 = node2.next;
+            count2++;
+        }
 
+        // Create a loop by connecting node2's next to node1
+        if (node1 != null && node2 != null) {
+            node2.next = node1;
+        }
+    }
+    // Method to detect a loop in the linked list
     /**
      * Detects the presence of a loop in the linked list.
      *
-     * @see
-     * 	<a href="https://en.wikipedia.org/wiki/Cycle_detection#Floyd's_tortoise_and_hare">
-     * Floyd's Cycle Detection Algorithm</a>
-     *
-     * @param head the head node of the linked list
-     *
+     * @see <a href="https://en.wikipedia.org/wiki/Cycle_detection#Floyd's_tortoise_and_hare">Floyd's Cycle Detection Algorithm</a>
      * @return true if loop exists else false
      */
     static boolean detectLoop(Node head) {
@@ -67,40 +70,10 @@ static boolean detectLoop(Node head) {
         while (fptr != null && fptr.next != null) {
             sptr = sptr.next;
             fptr = fptr.next.next;
-            if (fptr == sptr) {
+            if (sptr == fptr) {
                 return true;
             }
         }
-
         return false;
     }
-
-    public static void main(String[] args) {
-        SinglyLinkedList singlyLinkedList = new SinglyLinkedList();
-        Scanner sc = new Scanner(System.in);
-
-        System.out.println("Enter the number of elements to be inserted: ");
-        int n = sc.nextInt();
-        System.out.printf("Enter the %d elements: %n", n);
-        while (n-- > 0) {
-            singlyLinkedList.insert(sc.nextInt());
-        }
-
-        System.out.print("Given list: ");
-        printList(singlyLinkedList.getHead());
-        System.out.println();
-
-        System.out.println("Enter the location to generate loop: ");
-        int k = sc.nextInt();
-
-        createLoop(singlyLinkedList.getHead(), k);
-
-        if (detectLoop(singlyLinkedList.getHead())) {
-            System.out.println("Loop found");
-        } else {
-            System.out.println("No loop found");
-        }
-
-        sc.close();
-    }
 }

src/main/java/com/thealgorithms/divideandconquer/MedianOfTwoSortedArrays.java

@@ -0,0 +1,53 @@
+package com.thealgorithms.divideandconquer;
+
+public final class MedianOfTwoSortedArrays {
+
+    private MedianOfTwoSortedArrays() {
+    }
+
+    /**
+     * Finds the median of two sorted arrays in logarithmic time.
+     *
+     * @param nums1 the first sorted array
+     * @param nums2 the second sorted array
+     * @return the median of the combined sorted array
+     * @throws IllegalArgumentException if the input arrays are not sorted
+     */
+    public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
+        if (nums1.length > nums2.length) {
+            return findMedianSortedArrays(nums2, nums1); // Ensure nums1 is the smaller array
+        }
+
+        int m = nums1.length;
+        int n = nums2.length;
+        int low = 0;
+        int high = m;
+        while (low <= high) {
+            int partition1 = (low + high) / 2; // Partition in the first array
+            int partition2 = (m + n + 1) / 2 - partition1; // Partition in the second array
+
+            int maxLeft1 = (partition1 == 0) ? Integer.MIN_VALUE : nums1[partition1 - 1];
+            int minRight1 = (partition1 == m) ? Integer.MAX_VALUE : nums1[partition1];
+            int maxLeft2 = (partition2 == 0) ? Integer.MIN_VALUE : nums2[partition2 - 1];
+            int minRight2 = (partition2 == n) ? Integer.MAX_VALUE : nums2[partition2];
+
+            // Check if partition is valid
+            if (maxLeft1 <= minRight2 && maxLeft2 <= minRight1) {
+                // If combined array length is odd
+                if (((m + n) & 1) == 1) {
+                    return Math.max(maxLeft1, maxLeft2);
+                }
+                // If combined array length is even
+                else {
+                    return (Math.max(maxLeft1, maxLeft2) + Math.min(minRight1, minRight2)) / 2.0;
+                }
+            } else if (maxLeft1 > minRight2) {
+                high = partition1 - 1;
+            } else {
+                low = partition1 + 1;
+            }
+        }
+
+        throw new IllegalArgumentException("Input arrays are not sorted");
+    }
+}

src/main/java/com/thealgorithms/dynamicprogramming/BruteForceKnapsack.java

@@ -1,39 +1,67 @@
 package com.thealgorithms.dynamicprogramming;
 
-/* A Naive recursive implementation
-of 0-1 Knapsack problem */
+/**
+ * A naive recursive implementation of the 0-1 Knapsack problem.
+ *
+ * <p>The 0-1 Knapsack problem is a classic optimization problem where you are
+ * given a set of items, each with a weight and a value, and a knapsack with a
+ * fixed capacity. The goal is to determine the maximum value that can be
+ * obtained by selecting a subset of the items such that the total weight does
+ * not exceed the knapsack's capacity. Each item can either be included (1) or
+ * excluded (0), hence the name "0-1" Knapsack.</p>
+ *
+ * <p>This class provides a brute-force recursive approach to solving the
+ * problem. It evaluates all possible combinations of items to find the optimal
+ * solution, but this approach has exponential time complexity and is not
+ * suitable for large input sizes.</p>
+ *
+ * <p><b>Time Complexity:</b> O(2^n), where n is the number of items.</p>
+ *
+ * <p><b>Space Complexity:</b> O(n), due to the recursive function call stack.</p>
+ */
 public final class BruteForceKnapsack {
     private BruteForceKnapsack() {
     }
-    // Returns the maximum value that
-    // can be put in a knapsack of
-    // capacity W
+
+    /**
+     * Solves the 0-1 Knapsack problem using a recursive brute-force approach.
+     *
+     * @param w   the total capacity of the knapsack
+     * @param wt  an array where wt[i] represents the weight of the i-th item
+     * @param val an array where val[i] represents the value of the i-th item
+     * @param n   the number of items available for selection
+     * @return    the maximum value that can be obtained with the given capacity
+     *
+     * <p>The function uses recursion to explore all possible subsets of items.
+     * For each item, it has two choices: either include it in the knapsack
+     * (if it fits) or exclude it. It returns the maximum value obtainable
+     * through these two choices.</p>
+     *
+     * <p><b>Base Cases:</b>
+     * <ul>
+     * <li>If no items are left (n == 0), the maximum value is 0.</li>
+     * <li>If the knapsack's remaining capacity is 0 (w == 0), no more items can
+     * be included, and the value is 0.</li>
+     * </ul></p>
+     *
+     * <p><b>Recursive Steps:</b>
+     * <ul>
+     * <li>If the weight of the n-th item exceeds the current capacity, it is
+     * excluded from the solution, and the function proceeds with the remaining
+     * items.</li>
+     * <li>Otherwise, the function considers two possibilities: include the n-th
+     * item or exclude it, and returns the maximum value of these two scenarios.</li>
+     * </ul></p>
+     */
     static int knapSack(int w, int[] wt, int[] val, int n) {
-        // Base Case
         if (n == 0 || w == 0) {
             return 0;
         }
 
-        // If weight of the nth item is
-        // more than Knapsack capacity W,
-        // then this item cannot be included
-        // in the optimal solution
         if (wt[n - 1] > w) {
             return knapSack(w, wt, val, n - 1);
-        } // Return the maximum of two cases:
-        // (1) nth item included
-        // (2) not included
-        else {
-            return Math.max(val[n - 1] + knapSack(w - wt[n - 1], wt, val, n - 1), knapSack(w, wt, val, n - 1));
+        } else {
+            return Math.max(knapSack(w, wt, val, n - 1), val[n - 1] + knapSack(w - wt[n - 1], wt, val, n - 1));
         }
     }
-
-    // Driver code
-    public static void main(String[] args) {
-        int[] val = new int[] {60, 100, 120};
-        int[] wt = new int[] {10, 20, 30};
-        int w = 50;
-        int n = val.length;
-        System.out.println(knapSack(w, wt, val, n));
-    }
 }