Merge branch 'sum_of_subset_improvement' of https://github.com/Hardvan/Java into sum_of_subset_improvement

Author: Hardvan

DIRECTORY.md

@@ -156,6 +156,7 @@
               * [SearchSinglyLinkedListRecursion](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/SearchSinglyLinkedListRecursion.java)
               * [SinglyLinkedList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/SinglyLinkedList.java)
               * [SkipList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/SkipList.java)
+              * [SortedLinkedList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java)
             * [Node](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/Node.java)
             * queues
               * [CircularQueue](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/CircularQueue.java)
@@ -237,6 +238,7 @@
             * [KnapsackMemoization](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/KnapsackMemoization.java)
             * [LevenshteinDistance](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/LevenshteinDistance.java)
             * [LongestAlternatingSubsequence](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/LongestAlternatingSubsequence.java)
+            * [LongestArithmeticSubsequence](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/LongestArithmeticSubsequence.java)
             * [LongestCommonSubsequence](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/LongestCommonSubsequence.java)
             * [LongestIncreasingSubsequence](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/LongestIncreasingSubsequence.java)
             * [LongestPalindromicSubsequence](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/LongestPalindromicSubsequence.java)
@@ -268,6 +270,7 @@
             * [FractionalKnapsack](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/FractionalKnapsack.java)
             * [GaleShapley](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/GaleShapley.java)
             * [JobSequencing](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/JobSequencing.java)
+            * [MergeIntervals](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/MergeIntervals.java)
             * [MinimizingLateness](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/MinimizingLateness.java)
           * io
             * [BufferedReader](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/io/BufferedReader.java)
@@ -397,7 +400,6 @@
             * [PalindromePrime](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/misc/PalindromePrime.java)
             * [PalindromeSinglyLinkedList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/misc/PalindromeSinglyLinkedList.java)
             * [RangeInSortedArray](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/misc/RangeInSortedArray.java)
-            * [Sort012D](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/misc/Sort012D.java)
             * [Sparsity](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/misc/Sparsity.java)
             * [ThreeSumProblem](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/misc/ThreeSumProblem.java)
             * [TwoSumProblem](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/misc/TwoSumProblem.java)
@@ -502,7 +504,6 @@
             * [CombSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/CombSort.java)
             * [CountingSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/CountingSort.java)
             * [CycleSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/CycleSort.java)
-            * [DNFSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/DNFSort.java)
             * [DualPivotQuickSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/DualPivotQuickSort.java)
             * [DutchNationalFlagSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java)
             * [ExchangeSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/ExchangeSort.java)
@@ -687,6 +688,7 @@
               * [RotateSinglyLinkedListsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/RotateSinglyLinkedListsTest.java)
               * [SinglyLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/SinglyLinkedListTest.java)
               * [SkipListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/SkipListTest.java)
+              * [SortedLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java)
             * queues
               * [CircularQueueTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/CircularQueueTest.java)
               * [DequeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/DequeTest.java)
@@ -732,6 +734,7 @@
             * [KnapsackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/KnapsackTest.java)
             * [LevenshteinDistanceTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LevenshteinDistanceTests.java)
             * [LongestAlternatingSubsequenceTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LongestAlternatingSubsequenceTest.java)
+            * [LongestArithmeticSubsequenceTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LongestArithmeticSubsequenceTest.java)
             * [LongestIncreasingSubsequenceTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LongestIncreasingSubsequenceTests.java)
             * [LongestPalindromicSubstringTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LongestPalindromicSubstringTest.java)
             * [LongestValidParenthesesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LongestValidParenthesesTest.java)
@@ -756,6 +759,7 @@
             * [FractionalKnapsackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/FractionalKnapsackTest.java)
             * [GaleShapleyTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/GaleShapleyTest.java)
             * [JobSequencingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/JobSequencingTest.java)
+            * [MergeIntervalsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/MergeIntervalsTest.java)
             * [MinimizingLatenessTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/MinimizingLatenessTest.java)
           * io
             * [BufferedReaderTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/io/BufferedReaderTest.java)

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

@@ -0,0 +1,141 @@
+package com.thealgorithms.datastructures.lists;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A SortedLinkedList is a data structure that maintains a sorted list of elements.
+ * Elements are ordered based on their natural ordering or by a Comparator provided at the time of creation.
+ * This implementation uses a singly linked list to store the elements.
+ * Further details can be found on this link
+ * https://runestone.academy/ns/books/published/cppds/LinearLinked/ImplementinganOrderedList.html
+ */
+public class SortedLinkedList {
+    private Node head;
+    private Node tail;
+
+    public SortedLinkedList() {
+        this.head = null;
+        this.tail = null;
+    }
+
+    /**
+     * Inserts a new element into the sorted linked list.
+     * @param value the value to be inserted
+     */
+    public void insert(int value) {
+        Node newNode = new Node(value);
+        if (head == null) {
+            this.head = newNode;
+            this.tail = newNode;
+        } else if (value < head.value) {
+            newNode.next = this.head;
+            this.head = newNode;
+        } else if (value > tail.value) {
+            this.tail.next = newNode;
+            this.tail = newNode;
+        } else {
+            Node temp = head;
+            while (temp.next != null && temp.next.value < value) {
+                temp = temp.next;
+            }
+            newNode.next = temp.next;
+            temp.next = newNode;
+            if (newNode.next == null) {
+                this.tail = newNode;
+            }
+        }
+    }
+
+    /**
+     * Displays the elements of the sorted linked list.
+     */
+    public void display() {
+        System.out.println(this.toString());
+    }
+
+    /**
+     * Deletes the first occurrence of the specified element in the sorted linked list.
+     * @param value the value to be deleted
+     * @return true if the element is found and deleted, false otherwise
+     */
+    public boolean delete(int value) {
+        if (this.head == null) {
+            return false;
+        } else if (this.head.value == value) {
+            if (this.head.next == null) {
+                this.head = null;
+                this.tail = null;
+            } else {
+                this.head = this.head.next;
+            }
+            return true;
+        } else {
+            Node temp = this.head;
+            while (temp.next != null) {
+                if (temp.next.value == value) {
+                    if (temp.next == this.tail) {
+                        this.tail = temp;
+                    }
+                    temp.next = temp.next.next;
+                    return true;
+                }
+                temp = temp.next;
+            }
+            return false;
+        }
+    }
+
+    /**
+     * Searches for the specified element in the sorted linked list.
+     * @param value the value to be searched
+     * @return true if the element is found, false otherwise
+     */
+    public boolean search(int value) {
+        Node temp = this.head;
+        while (temp != null) {
+            if (temp.value == value) {
+                return true;
+            }
+            temp = temp.next;
+        }
+        return false;
+    }
+
+    /**
+     * Checks if the sorted linked list is empty.
+     * @return true if the list is empty, false otherwise
+     */
+    public boolean isEmpty() {
+        return head == null;
+    }
+    /**
+     * Returns a string representation of the sorted linked list.
+     * @return a string representation of the sorted linked list
+     */
+    @Override
+    public String toString() {
+        if (this.head != null) {
+            List<String> elements = new ArrayList<>();
+            Node temp = this.head;
+            while (temp != null) {
+                elements.add(String.valueOf(temp.value));
+                temp = temp.next;
+            }
+            return "[" + String.join(", ", elements) + "]";
+
+        } else {
+            return "[]";
+        }
+    }
+
+    public final class Node {
+        public final int value;
+        public Node next;
+
+        public Node(int value) {
+            this.value = value;
+            this.next = null;
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+package com.thealgorithms.dynamicprogramming;
+
+import java.util.HashMap;
+
+final class LongestArithmeticSubsequence {
+    private LongestArithmeticSubsequence() {
+    }
+
+    /**
+     * Returns the length of the longest arithmetic subsequence in the given array.
+     *
+     * A sequence seq is arithmetic if seq[i + 1] - seq[i] are all the same value
+     * (for 0 <= i < seq.length - 1).
+     *
+     * @param nums the input array of integers
+     * @return the length of the longest arithmetic subsequence
+     */
+    public static int getLongestArithmeticSubsequenceLength(int[] nums) {
+        if (nums == null) {
+            throw new IllegalArgumentException("Input array cannot be null");
+        }
+
+        if (nums.length <= 1) {
+            return nums.length;
+        }
+
+        HashMap<Integer, Integer>[] dp = new HashMap[nums.length];
+        int maxLength = 2;
+
+        // fill the dp array
+        for (int i = 0; i < nums.length; i++) {
+            dp[i] = new HashMap<>();
+            for (int j = 0; j < i; j++) {
+                final int diff = nums[i] - nums[j];
+                dp[i].put(diff, dp[j].getOrDefault(diff, 1) + 1);
+                maxLength = Math.max(maxLength, dp[i].get(diff));
+            }
+        }
+
+        return maxLength;
+    }
+}

src/main/java/com/thealgorithms/greedyalgorithms/MergeIntervals.java

@@ -0,0 +1,64 @@
+package com.thealgorithms.greedyalgorithms;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Problem Statement:
+ * Given an array of intervals where intervals[i] = [starti, endi].
+ *
+ * Merge all overlapping intervals and return an array of the non-overlapping
+ * intervals
+ * that cover all the intervals in the input.
+ */
+public final class MergeIntervals {
+
+    /**
+     * Private constructor to prevent instantiation of this utility class.
+     */
+    private MergeIntervals() {
+    }
+
+    /**
+     * Merges overlapping intervals from the given array of intervals.
+     *
+     * The method sorts the intervals by their start time, then iterates through the
+     * sorted intervals
+     * and merges overlapping intervals. If an interval overlaps with the last
+     * merged interval,
+     * it updates the end time of the last merged interval. Otherwise, it adds the
+     * interval as a new entry.
+     *
+     * @param intervals A 2D array representing intervals where each element is an
+     *                  interval [starti, endi].
+     * @return A 2D array of merged intervals where no intervals overlap.
+     *
+     *         Example:
+     *         Input: {{1, 3}, {2, 6}, {8, 10}, {15, 18}}
+     *         Output: {{1, 6}, {8, 10}, {15, 18}}
+     */
+    public static int[][] merge(int[][] intervals) {
+        // Sort the intervals by their start time (ascending order)
+        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
+
+        // List to store merged intervals
+        List<int[]> merged = new ArrayList<>();
+
+        for (int[] interval : intervals) { // Each interval
+            // If the merged list is empty or the current interval does not overlap with
+            // the last merged interval, add it to the merged list.
+            if (merged.isEmpty() || interval[0] > merged.get(merged.size() - 1)[1]) {
+                merged.add(interval);
+            } else {
+                // If there is an overlap, merge the intervals by updating the end time
+                // of the last merged interval to the maximum end time between the two
+                // intervals.
+                merged.get(merged.size() - 1)[1] = Math.max(merged.get(merged.size() - 1)[1], interval[1]);
+            }
+        }
+
+        // Convert the list of merged intervals back to a 2D array and return it
+        return merged.toArray(new int[merged.size()][]);
+    }
+}