Skip to content

Commit ee6f572

Browse files
HardvanHardvan
authored
Merge branch 'master' into sum_of_subset_improvement
2 parents 2c86dd4 + be8df21 commit ee6f572

File tree

10 files changed

+491
-148
lines changed

10 files changed

+491
-148
lines changed

‎DIRECTORY.md

+4-2
Original file line numberDiff line numberDiff line change
@@ -156,6 +156,7 @@
156156
* [SearchSinglyLinkedListRecursion](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/SearchSinglyLinkedListRecursion.java)
157157
* [SinglyLinkedList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/SinglyLinkedList.java)
158158
* [SkipList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/SkipList.java)
159+
* [SortedLinkedList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java)
159160
* [Node](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/Node.java)
160161
* queues
161162
* [CircularQueue](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/CircularQueue.java)
@@ -268,6 +269,7 @@
268269
* [FractionalKnapsack](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/FractionalKnapsack.java)
269270
* [GaleShapley](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/GaleShapley.java)
270271
* [JobSequencing](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/JobSequencing.java)
272+
* [MergeIntervals](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/MergeIntervals.java)
271273
* [MinimizingLateness](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/MinimizingLateness.java)
272274
* io
273275
* [BufferedReader](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/io/BufferedReader.java)
@@ -397,7 +399,6 @@
397399
* [PalindromePrime](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/misc/PalindromePrime.java)
398400
* [PalindromeSinglyLinkedList](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/misc/PalindromeSinglyLinkedList.java)
399401
* [RangeInSortedArray](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/misc/RangeInSortedArray.java)
400-
* [Sort012D](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/misc/Sort012D.java)
401402
* [Sparsity](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/misc/Sparsity.java)
402403
* [ThreeSumProblem](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/misc/ThreeSumProblem.java)
403404
* [TwoSumProblem](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/misc/TwoSumProblem.java)
@@ -502,7 +503,6 @@
502503
* [CombSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/CombSort.java)
503504
* [CountingSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/CountingSort.java)
504505
* [CycleSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/CycleSort.java)
505-
* [DNFSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/DNFSort.java)
506506
* [DualPivotQuickSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/DualPivotQuickSort.java)
507507
* [DutchNationalFlagSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/DutchNationalFlagSort.java)
508508
* [ExchangeSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/ExchangeSort.java)
@@ -687,6 +687,7 @@
687687
* [RotateSinglyLinkedListsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/RotateSinglyLinkedListsTest.java)
688688
* [SinglyLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/SinglyLinkedListTest.java)
689689
* [SkipListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/SkipListTest.java)
690+
* [SortedLinkedListTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java)
690691
* queues
691692
* [CircularQueueTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/CircularQueueTest.java)
692693
* [DequeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/DequeTest.java)
@@ -756,6 +757,7 @@
756757
* [FractionalKnapsackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/FractionalKnapsackTest.java)
757758
* [GaleShapleyTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/GaleShapleyTest.java)
758759
* [JobSequencingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/JobSequencingTest.java)
760+
* [MergeIntervalsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/MergeIntervalsTest.java)
759761
* [MinimizingLatenessTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/MinimizingLatenessTest.java)
760762
* io
761763
* [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

+141
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,141 @@
1+
package com.thealgorithms.datastructures.lists;
2+
3+
import java.util.ArrayList;
4+
import java.util.List;
5+
6+
/**
7+
* A SortedLinkedList is a data structure that maintains a sorted list of elements.
8+
* Elements are ordered based on their natural ordering or by a Comparator provided at the time of creation.
9+
* This implementation uses a singly linked list to store the elements.
10+
* Further details can be found on this link
11+
* https://runestone.academy/ns/books/published/cppds/LinearLinked/ImplementinganOrderedList.html
12+
*/
13+
public class SortedLinkedList {
14+
private Node head;
15+
private Node tail;
16+
17+
public SortedLinkedList() {
18+
this.head = null;
19+
this.tail = null;
20+
}
21+
22+
/**
23+
* Inserts a new element into the sorted linked list.
24+
* @param value the value to be inserted
25+
*/
26+
public void insert(int value) {
27+
Node newNode = new Node(value);
28+
if (head == null) {
29+
this.head = newNode;
30+
this.tail = newNode;
31+
} else if (value < head.value) {
32+
newNode.next = this.head;
33+
this.head = newNode;
34+
} else if (value > tail.value) {
35+
this.tail.next = newNode;
36+
this.tail = newNode;
37+
} else {
38+
Node temp = head;
39+
while (temp.next != null && temp.next.value < value) {
40+
temp = temp.next;
41+
}
42+
newNode.next = temp.next;
43+
temp.next = newNode;
44+
if (newNode.next == null) {
45+
this.tail = newNode;
46+
}
47+
}
48+
}
49+
50+
/**
51+
* Displays the elements of the sorted linked list.
52+
*/
53+
public void display() {
54+
System.out.println(this.toString());
55+
}
56+
57+
/**
58+
* Deletes the first occurrence of the specified element in the sorted linked list.
59+
* @param value the value to be deleted
60+
* @return true if the element is found and deleted, false otherwise
61+
*/
62+
public boolean delete(int value) {
63+
if (this.head == null) {
64+
return false;
65+
} else if (this.head.value == value) {
66+
if (this.head.next == null) {
67+
this.head = null;
68+
this.tail = null;
69+
} else {
70+
this.head = this.head.next;
71+
}
72+
return true;
73+
} else {
74+
Node temp = this.head;
75+
while (temp.next != null) {
76+
if (temp.next.value == value) {
77+
if (temp.next == this.tail) {
78+
this.tail = temp;
79+
}
80+
temp.next = temp.next.next;
81+
return true;
82+
}
83+
temp = temp.next;
84+
}
85+
return false;
86+
}
87+
}
88+
89+
/**
90+
* Searches for the specified element in the sorted linked list.
91+
* @param value the value to be searched
92+
* @return true if the element is found, false otherwise
93+
*/
94+
public boolean search(int value) {
95+
Node temp = this.head;
96+
while (temp != null) {
97+
if (temp.value == value) {
98+
return true;
99+
}
100+
temp = temp.next;
101+
}
102+
return false;
103+
}
104+
105+
/**
106+
* Checks if the sorted linked list is empty.
107+
* @return true if the list is empty, false otherwise
108+
*/
109+
public boolean isEmpty() {
110+
return head == null;
111+
}
112+
/**
113+
* Returns a string representation of the sorted linked list.
114+
* @return a string representation of the sorted linked list
115+
*/
116+
@Override
117+
public String toString() {
118+
if (this.head != null) {
119+
List<String> elements = new ArrayList<>();
120+
Node temp = this.head;
121+
while (temp != null) {
122+
elements.add(String.valueOf(temp.value));
123+
temp = temp.next;
124+
}
125+
return "[" + String.join(", ", elements) + "]";
126+
127+
} else {
128+
return "[]";
129+
}
130+
}
131+
132+
public final class Node {
133+
public final int value;
134+
public Node next;
135+
136+
public Node(int value) {
137+
this.value = value;
138+
this.next = null;
139+
}
140+
}
141+
}

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

+42
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
1+
package com.thealgorithms.dynamicprogramming;
2+
3+
import java.util.HashMap;
4+
5+
final class LongestArithmeticSubsequence {
6+
private LongestArithmeticSubsequence() {
7+
}
8+
9+
/**
10+
* Returns the length of the longest arithmetic subsequence in the given array.
11+
*
12+
* A sequence seq is arithmetic if seq[i + 1] - seq[i] are all the same value
13+
* (for 0 <= i < seq.length - 1).
14+
*
15+
* @param nums the input array of integers
16+
* @return the length of the longest arithmetic subsequence
17+
*/
18+
public static int getLongestArithmeticSubsequenceLength(int[] nums) {
19+
if (nums == null) {
20+
throw new IllegalArgumentException("Input array cannot be null");
21+
}
22+
23+
if (nums.length <= 1) {
24+
return nums.length;
25+
}
26+
27+
HashMap<Integer, Integer>[] dp = new HashMap[nums.length];
28+
int maxLength = 2;
29+
30+
// fill the dp array
31+
for (int i = 0; i < nums.length; i++) {
32+
dp[i] = new HashMap<>();
33+
for (int j = 0; j < i; j++) {
34+
final int diff = nums[i] - nums[j];
35+
dp[i].put(diff, dp[j].getOrDefault(diff, 1) + 1);
36+
maxLength = Math.max(maxLength, dp[i].get(diff));
37+
}
38+
}
39+
40+
return maxLength;
41+
}
42+
}

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

+64
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,64 @@
1+
package com.thealgorithms.greedyalgorithms;
2+
3+
import java.util.ArrayList;
4+
import java.util.Arrays;
5+
import java.util.List;
6+
7+
/**
8+
* Problem Statement:
9+
* Given an array of intervals where intervals[i] = [starti, endi].
10+
*
11+
* Merge all overlapping intervals and return an array of the non-overlapping
12+
* intervals
13+
* that cover all the intervals in the input.
14+
*/
15+
public final class MergeIntervals {
16+
17+
/**
18+
* Private constructor to prevent instantiation of this utility class.
19+
*/
20+
private MergeIntervals() {
21+
}
22+
23+
/**
24+
* Merges overlapping intervals from the given array of intervals.
25+
*
26+
* The method sorts the intervals by their start time, then iterates through the
27+
* sorted intervals
28+
* and merges overlapping intervals. If an interval overlaps with the last
29+
* merged interval,
30+
* it updates the end time of the last merged interval. Otherwise, it adds the
31+
* interval as a new entry.
32+
*
33+
* @param intervals A 2D array representing intervals where each element is an
34+
* interval [starti, endi].
35+
* @return A 2D array of merged intervals where no intervals overlap.
36+
*
37+
* Example:
38+
* Input: {{1, 3}, {2, 6}, {8, 10}, {15, 18}}
39+
* Output: {{1, 6}, {8, 10}, {15, 18}}
40+
*/
41+
public static int[][] merge(int[][] intervals) {
42+
// Sort the intervals by their start time (ascending order)
43+
Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
44+
45+
// List to store merged intervals
46+
List<int[]> merged = new ArrayList<>();
47+
48+
for (int[] interval : intervals) { // Each interval
49+
// If the merged list is empty or the current interval does not overlap with
50+
// the last merged interval, add it to the merged list.
51+
if (merged.isEmpty() || interval[0] > merged.get(merged.size() - 1)[1]) {
52+
merged.add(interval);
53+
} else {
54+
// If there is an overlap, merge the intervals by updating the end time
55+
// of the last merged interval to the maximum end time between the two
56+
// intervals.
57+
merged.get(merged.size() - 1)[1] = Math.max(merged.get(merged.size() - 1)[1], interval[1]);
58+
}
59+
}
60+
61+
// Convert the list of merged intervals back to a 2D array and return it
62+
return merged.toArray(new int[merged.size()][]);
63+
}
64+
}

‎src/main/java/com/thealgorithms/misc/Sort012D.java

-63
This file was deleted.

0 commit comments

Comments
 (0)