Skip to content

Commit a9d9c39

Browse files
DenizAltunkapanDenizAltunkapan
authored
Merge branch 'master' into my_algorithm
2 parents 4257686 + 0a46b82 commit a9d9c39

File tree

4 files changed

+192
-18
lines changed

4 files changed

+192
-18
lines changed

‎src/test/java/com/thealgorithms/datastructures/disjointsetunion/DisjointSetUnionTest.java‎

Lines changed: 88 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,9 @@
11
package com.thealgorithms.datastructures.disjointsetunion;
22

3+
import static org.junit.jupiter.api.Assertions.assertEquals;
4+
import static org.junit.jupiter.api.Assertions.assertNotEquals;
35
import static org.junit.jupiter.api.Assertions.assertNotNull;
46

5-
import org.junit.jupiter.api.Assertions;
67
import org.junit.jupiter.api.Test;
78

89
public class DisjointSetUnionTest {
@@ -12,7 +13,7 @@ public void testMakeSet() {
1213
DisjointSetUnion<Integer> dsu = new DisjointSetUnion<>();
1314
Node<Integer> node = dsu.makeSet(1);
1415
assertNotNull(node);
15-
Assertions.assertEquals(node, node.parent);
16+
assertEquals(node, node.parent);
1617
}
1718

1819
@Test
@@ -33,19 +34,92 @@ public void testUnionFindSet() {
3334
Node<Integer> root3 = dsu.findSet(node3);
3435
Node<Integer> root4 = dsu.findSet(node4);
3536

36-
Assertions.assertEquals(node1, node1.parent);
37-
Assertions.assertEquals(node1, node2.parent);
38-
Assertions.assertEquals(node1, node3.parent);
39-
Assertions.assertEquals(node1, node4.parent);
37+
assertEquals(node1, node1.parent);
38+
assertEquals(node1, node2.parent);
39+
assertEquals(node1, node3.parent);
40+
assertEquals(node1, node4.parent);
4041

41-
Assertions.assertEquals(node1, root1);
42-
Assertions.assertEquals(node1, root2);
43-
Assertions.assertEquals(node1, root3);
44-
Assertions.assertEquals(node1, root4);
42+
assertEquals(node1, root1);
43+
assertEquals(node1, root2);
44+
assertEquals(node1, root3);
45+
assertEquals(node1, root4);
4546

46-
Assertions.assertEquals(1, node1.rank);
47-
Assertions.assertEquals(0, node2.rank);
48-
Assertions.assertEquals(0, node3.rank);
49-
Assertions.assertEquals(0, node4.rank);
47+
assertEquals(1, node1.rank);
48+
assertEquals(0, node2.rank);
49+
assertEquals(0, node3.rank);
50+
assertEquals(0, node4.rank);
51+
}
52+
53+
@Test
54+
public void testFindSetOnSingleNode() {
55+
DisjointSetUnion<String> dsu = new DisjointSetUnion<>();
56+
Node<String> node = dsu.makeSet("A");
57+
assertEquals(node, dsu.findSet(node));
58+
}
59+
60+
@Test
61+
public void testUnionAlreadyConnectedNodes() {
62+
DisjointSetUnion<Integer> dsu = new DisjointSetUnion<>();
63+
Node<Integer> node1 = dsu.makeSet(1);
64+
Node<Integer> node2 = dsu.makeSet(2);
65+
Node<Integer> node3 = dsu.makeSet(3);
66+
67+
dsu.unionSets(node1, node2);
68+
dsu.unionSets(node2, node3);
69+
70+
// Union nodes that are already connected
71+
dsu.unionSets(node1, node3);
72+
73+
// All should have the same root
74+
Node<Integer> root = dsu.findSet(node1);
75+
assertEquals(root, dsu.findSet(node2));
76+
assertEquals(root, dsu.findSet(node3));
77+
}
78+
79+
@Test
80+
public void testRankIncrease() {
81+
DisjointSetUnion<Integer> dsu = new DisjointSetUnion<>();
82+
Node<Integer> node1 = dsu.makeSet(1);
83+
Node<Integer> node2 = dsu.makeSet(2);
84+
Node<Integer> node3 = dsu.makeSet(3);
85+
Node<Integer> node4 = dsu.makeSet(4);
86+
87+
dsu.unionSets(node1, node2); // rank of node1 should increase
88+
dsu.unionSets(node3, node4); // rank of node3 should increase
89+
dsu.unionSets(node1, node3); // union two trees of same rank -> rank increases
90+
91+
assertEquals(2, dsu.findSet(node1).rank);
92+
}
93+
94+
@Test
95+
public void testMultipleMakeSets() {
96+
DisjointSetUnion<Integer> dsu = new DisjointSetUnion<>();
97+
Node<Integer> node1 = dsu.makeSet(1);
98+
Node<Integer> node2 = dsu.makeSet(2);
99+
Node<Integer> node3 = dsu.makeSet(3);
100+
101+
assertNotEquals(node1, node2);
102+
assertNotEquals(node2, node3);
103+
assertNotEquals(node1, node3);
104+
105+
assertEquals(node1, node1.parent);
106+
assertEquals(node2, node2.parent);
107+
assertEquals(node3, node3.parent);
108+
}
109+
110+
@Test
111+
public void testPathCompression() {
112+
DisjointSetUnion<Integer> dsu = new DisjointSetUnion<>();
113+
Node<Integer> node1 = dsu.makeSet(1);
114+
Node<Integer> node2 = dsu.makeSet(2);
115+
Node<Integer> node3 = dsu.makeSet(3);
116+
117+
dsu.unionSets(node1, node2);
118+
dsu.unionSets(node2, node3);
119+
120+
// After findSet, path compression should update parent to root directly
121+
Node<Integer> root = dsu.findSet(node3);
122+
assertEquals(root, node1);
123+
assertEquals(node1, node3.parent);
50124
}
51125
}

‎src/test/java/com/thealgorithms/datastructures/queues/PriorityQueuesTest.java‎

Lines changed: 56 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -55,4 +55,60 @@ void testPQExtra() {
5555
Assertions.assertEquals(myQueue.peek(), 2);
5656
Assertions.assertEquals(myQueue.getSize(), 1);
5757
}
58+
59+
@Test
60+
void testInsertUntilFull() {
61+
PriorityQueue pq = new PriorityQueue(3);
62+
pq.insert(1);
63+
pq.insert(4);
64+
pq.insert(2);
65+
Assertions.assertTrue(pq.isFull());
66+
Assertions.assertEquals(4, pq.peek());
67+
}
68+
69+
@Test
70+
void testRemoveFromEmpty() {
71+
PriorityQueue pq = new PriorityQueue(3);
72+
Assertions.assertThrows(RuntimeException.class, pq::remove);
73+
}
74+
75+
@Test
76+
void testInsertDuplicateValues() {
77+
PriorityQueue pq = new PriorityQueue(5);
78+
pq.insert(5);
79+
pq.insert(5);
80+
pq.insert(3);
81+
Assertions.assertEquals(5, pq.peek());
82+
pq.remove();
83+
Assertions.assertEquals(5, pq.peek());
84+
pq.remove();
85+
Assertions.assertEquals(3, pq.peek());
86+
}
87+
88+
@Test
89+
void testSizeAfterInsertAndRemove() {
90+
PriorityQueue pq = new PriorityQueue(4);
91+
Assertions.assertEquals(0, pq.getSize());
92+
pq.insert(2);
93+
Assertions.assertEquals(1, pq.getSize());
94+
pq.insert(10);
95+
Assertions.assertEquals(2, pq.getSize());
96+
pq.remove();
97+
Assertions.assertEquals(1, pq.getSize());
98+
pq.remove();
99+
Assertions.assertEquals(0, pq.getSize());
100+
}
101+
102+
@Test
103+
void testInsertAndRemoveAll() {
104+
PriorityQueue pq = new PriorityQueue(3);
105+
pq.insert(8);
106+
pq.insert(1);
107+
pq.insert(6);
108+
Assertions.assertTrue(pq.isFull());
109+
pq.remove();
110+
pq.remove();
111+
pq.remove();
112+
Assertions.assertTrue(pq.isEmpty());
113+
}
58114
}

‎src/test/java/com/thealgorithms/stacks/DuplicateBracketsTest.java‎

Lines changed: 28 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -4,20 +4,23 @@
44
import static org.junit.jupiter.api.Assertions.assertThrows;
55
import static org.junit.jupiter.api.Assertions.assertTrue;
66

7+
import java.util.stream.Stream;
78
import org.junit.jupiter.api.Test;
89
import org.junit.jupiter.params.ParameterizedTest;
10+
import org.junit.jupiter.params.provider.Arguments;
911
import org.junit.jupiter.params.provider.CsvSource;
12+
import org.junit.jupiter.params.provider.MethodSource;
1013

1114
class DuplicateBracketsTest {
1215

1316
@ParameterizedTest
14-
@CsvSource({"'((a + b) + (c + d))'", "'(a + b)'", "'a + b'", "'('", "''"})
17+
@CsvSource({"'((a + b) + (c + d))'", "'(a + b)'", "'a + b'", "'('", "''", "'a + (b * c) - d'", "'(x + y) * (z)'", "'(a + (b - c))'"})
1518
void testInputReturnsFalse(String input) {
1619
assertFalse(DuplicateBrackets.check(input));
1720
}
1821

1922
@ParameterizedTest
20-
@CsvSource({"'(a + b) + ((c + d))'", "'((a + b))'", "'((((a + b)))))'"})
23+
@CsvSource({"'(a + b) + ((c + d))'", "'((a + b))'", "'((((a + b)))))'", "'((x))'", "'((a + (b)))'", "'(a + ((b)))'", "'(((a)))'", "'(((())))'"})
2124
void testInputReturnsTrue(String input) {
2225
assertTrue(DuplicateBrackets.check(input));
2326
}
@@ -26,4 +29,27 @@ void testInputReturnsTrue(String input) {
2629
void testInvalidInput() {
2730
assertThrows(IllegalArgumentException.class, () -> DuplicateBrackets.check(null));
2831
}
32+
33+
@ParameterizedTest(name = "Should be true: \"{0}\"")
34+
@MethodSource("provideInputsThatShouldReturnTrue")
35+
void testDuplicateBracketsTrueCases(String input) {
36+
assertTrue(DuplicateBrackets.check(input));
37+
}
38+
39+
static Stream<Arguments> provideInputsThatShouldReturnTrue() {
40+
return Stream.of(Arguments.of("()"), Arguments.of("(( ))"));
41+
}
42+
43+
@ParameterizedTest(name = "Should be false: \"{0}\"")
44+
@MethodSource("provideInputsThatShouldReturnFalse")
45+
void testDuplicateBracketsFalseCases(String input) {
46+
assertFalse(DuplicateBrackets.check(input));
47+
}
48+
49+
static Stream<Arguments> provideInputsThatShouldReturnFalse() {
50+
return Stream.of(Arguments.of("( )"), // whitespace inside brackets
51+
Arguments.of("abc + def"), // no brackets
52+
Arguments.of("(a + (b * c)) - (d / e)") // complex, but no duplicates
53+
);
54+
}
2955
}

‎src/test/java/com/thealgorithms/strings/ValidParenthesesTest.java‎

Lines changed: 20 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,33 @@
11
package com.thealgorithms.strings;
22

33
import static org.junit.jupiter.api.Assertions.assertEquals;
4+
import static org.junit.jupiter.api.Assertions.assertThrows;
5+
import static org.junit.jupiter.api.Assertions.assertTrue;
46

7+
import org.junit.jupiter.api.Test;
58
import org.junit.jupiter.params.ParameterizedTest;
69
import org.junit.jupiter.params.provider.CsvSource;
710

811
public class ValidParenthesesTest {
912

1013
@ParameterizedTest(name = "Input: \"{0}\" → Expected: {1}")
11-
@CsvSource({"'()', true", "'()[]{}', true", "'(]', false", "'{[]}', true", "'([{}])', true", "'([)]', false", "'', true", "'(', false", "')', false"})
12-
void testIsValid(String input, boolean expected) {
14+
@CsvSource({"'()', true", "'()[]{}', true", "'(]', false", "'{[]}', true", "'([{}])', true", "'([)]', false", "'', true", "'(', false", "')', false", "'{{{{}}}}', true", "'[({})]', true", "'[(])', false", "'[', false", "']', false", "'()()()()', true", "'(()', false", "'())', false",
15+
"'{[()()]()}', true"})
16+
void
17+
testIsValid(String input, boolean expected) {
1318
assertEquals(expected, ValidParentheses.isValid(input));
1419
}
20+
21+
@Test
22+
void testNullInputThrows() {
23+
IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> ValidParentheses.isValid(null));
24+
assertEquals("Input string cannot be null", ex.getMessage());
25+
}
26+
27+
@ParameterizedTest(name = "Input: \"{0}\" → throws IllegalArgumentException")
28+
@CsvSource({"'a'", "'()a'", "'[123]'", "'{hello}'", "'( )'", "'\t'", "'\n'", "'@#$%'"})
29+
void testInvalidCharactersThrow(String input) {
30+
IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> ValidParentheses.isValid(input));
31+
assertTrue(ex.getMessage().startsWith("Unexpected character"));
32+
}
1533
}

0 commit comments

Comments
 (0)