Skip to content

Commit 2592a08

Browse files
HardvanHardvan
authored
Enhance readability, add comments & function docs to SkylineProblem.java (TheAlgorithms#5534)
1 parent c45b2b8 commit 2592a08

File tree

3 files changed

+154
-43
lines changed

3 files changed

+154
-43
lines changed

‎DIRECTORY.md‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,7 @@
2727
* [IndexOfRightMostSetBit](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/IndexOfRightMostSetBit.java)
2828
* [IsEven](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/IsEven.java)
2929
* [IsPowerTwo](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/IsPowerTwo.java)
30+
* [LowestSetBit](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/LowestSetBit.java)
3031
* [NonRepeatingNumberFinder](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/NonRepeatingNumberFinder.java)
3132
* [NumbersDifferentSigns](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/NumbersDifferentSigns.java)
3233
* [ReverseBits](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/ReverseBits.java)
@@ -280,6 +281,12 @@
280281
* [MinimizingLateness](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/MinimizingLateness.java)
281282
* io
282283
* [BufferedReader](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/io/BufferedReader.java)
284+
* lineclipping
285+
* [CohenSutherland](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/lineclipping/CohenSutherland.java)
286+
* [LiangBarsky](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/lineclipping/LiangBarsky.java)
287+
* utils
288+
* [Line](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/lineclipping/utils/Line.java)
289+
* [Point](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/lineclipping/utils/Point.java)
283290
* maths
284291
* [AbsoluteMax](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/AbsoluteMax.java)
285292
* [AbsoluteMin](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/AbsoluteMin.java)
@@ -615,6 +622,7 @@
615622
* [IndexOfRightMostSetBitTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/IndexOfRightMostSetBitTest.java)
616623
* [IsEvenTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/IsEvenTest.java)
617624
* [IsPowerTwoTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/IsPowerTwoTest.java)
625+
* [LowestSetBitTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/LowestSetBitTest.java)
618626
* [NonRepeatingNumberFinderTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/NonRepeatingNumberFinderTest.java)
619627
* [NumbersDifferentSignsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/NumbersDifferentSignsTest.java)
620628
* [ReverseBitsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/ReverseBitsTest.java)
@@ -785,6 +793,9 @@
785793
* [MinimizingLatenessTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/MinimizingLatenessTest.java)
786794
* io
787795
* [BufferedReaderTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/io/BufferedReaderTest.java)
796+
* lineclipping
797+
* [CohenSutherlandTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/lineclipping/CohenSutherlandTest.java)
798+
* [LiangBarskyTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/lineclipping/LiangBarskyTest.java)
788799
* maths
789800
* [AbsoluteMaxTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/AbsoluteMaxTest.java)
790801
* [AbsoluteMinTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/AbsoluteMinTest.java)
@@ -912,6 +923,7 @@
912923
* [QueueUsingTwoStacksTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/QueueUsingTwoStacksTest.java)
913924
* [RemoveDuplicateFromStringTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/RemoveDuplicateFromStringTest.java)
914925
* [ReverseStackUsingRecursionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/ReverseStackUsingRecursionTest.java)
926+
* [SkylineProblemTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/SkylineProblemTest.java)
915927
* [TestPrintMatrixInSpiralOrder](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/TestPrintMatrixInSpiralOrder.java)
916928
* [TwoPointersTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/TwoPointersTest.java)
917929
* [WorstFitCPUTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/WorstFitCPUTest.java)

‎src/main/java/com/thealgorithms/others/SkylineProblem.java‎

Lines changed: 56 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -1,69 +1,68 @@
11
package com.thealgorithms.others;
22

33
import java.util.ArrayList;
4-
import java.util.Iterator;
5-
import java.util.Scanner;
64

5+
/**
6+
* The {@code SkylineProblem} class is used to solve the skyline problem using a
7+
* divide-and-conquer approach.
8+
* It reads input for building data, processes it to find the skyline, and
9+
* prints the skyline.
10+
*/
711
public class SkylineProblem {
812

913
Building[] building;
1014
int count;
1115

12-
public void run() {
13-
Scanner sc = new Scanner(System.in);
14-
15-
int num = sc.nextInt();
16-
this.building = new Building[num];
17-
18-
for (int i = 0; i < num; i++) {
19-
String input = sc.next();
20-
String[] data = input.split(",");
21-
this.add(Integer.parseInt(data[0]), Integer.parseInt(data[1]), Integer.parseInt(data[2]));
22-
}
23-
this.print(this.findSkyline(0, num - 1));
24-
25-
sc.close();
26-
}
27-
16+
/**
17+
* Adds a building with the given left, height, and right values to the
18+
* buildings list.
19+
*
20+
* @param left The left x-coordinate of the building.
21+
* @param height The height of the building.
22+
* @param right The right x-coordinate of the building.
23+
*/
2824
public void add(int left, int height, int right) {
2925
building[count++] = new Building(left, height, right);
3026
}
3127

32-
public void print(ArrayList<Skyline> skyline) {
33-
Iterator<Skyline> it = skyline.iterator();
34-
35-
while (it.hasNext()) {
36-
Skyline temp = it.next();
37-
System.out.print(temp.coordinates + "," + temp.height);
38-
if (it.hasNext()) {
39-
System.out.print(",");
40-
}
41-
}
42-
}
43-
28+
/**
29+
* Computes the skyline for a range of buildings using the divide-and-conquer
30+
* strategy.
31+
*
32+
* @param start The starting index of the buildings to process.
33+
* @param end The ending index of the buildings to process.
34+
* @return A list of {@link Skyline} objects representing the computed skyline.
35+
*/
4436
public ArrayList<Skyline> findSkyline(int start, int end) {
37+
// Base case: only one building, return its skyline.
4538
if (start == end) {
4639
ArrayList<Skyline> list = new ArrayList<>();
4740
list.add(new Skyline(building[start].left, building[start].height));
48-
list.add(new Skyline(building[end].right, 0));
49-
41+
list.add(new Skyline(building[end].right, 0)); // Add the end of the building
5042
return list;
5143
}
5244

5345
int mid = (start + end) / 2;
5446

55-
ArrayList<Skyline> sky1 = this.findSkyline(start, mid);
56-
ArrayList<Skyline> sky2 = this.findSkyline(mid + 1, end);
57-
58-
return this.mergeSkyline(sky1, sky2);
47+
ArrayList<Skyline> sky1 = this.findSkyline(start, mid); // Find the skyline of the left half
48+
ArrayList<Skyline> sky2 = this.findSkyline(mid + 1, end); // Find the skyline of the right half
49+
return this.mergeSkyline(sky1, sky2); // Merge the two skylines
5950
}
6051

52+
/**
53+
* Merges two skylines (sky1 and sky2) into one combined skyline.
54+
*
55+
* @param sky1 The first skyline list.
56+
* @param sky2 The second skyline list.
57+
* @return A list of {@link Skyline} objects representing the merged skyline.
58+
*/
6159
public ArrayList<Skyline> mergeSkyline(ArrayList<Skyline> sky1, ArrayList<Skyline> sky2) {
6260
int currentH1 = 0;
6361
int currentH2 = 0;
6462
ArrayList<Skyline> skyline = new ArrayList<>();
6563
int maxH = 0;
6664

65+
// Merge the two skylines
6766
while (!sky1.isEmpty() && !sky2.isEmpty()) {
6867
if (sky1.get(0).coordinates < sky2.get(0).coordinates) {
6968
int currentX = sky1.get(0).coordinates;
@@ -96,6 +95,7 @@ public ArrayList<Skyline> mergeSkyline(ArrayList<Skyline> sky1, ArrayList<Skylin
9695
}
9796
}
9897

98+
// Add any remaining points from sky1 or sky2
9999
while (!sky1.isEmpty()) {
100100
skyline.add(sky1.get(0));
101101
sky1.remove(0);
@@ -109,32 +109,45 @@ public ArrayList<Skyline> mergeSkyline(ArrayList<Skyline> sky1, ArrayList<Skylin
109109
return skyline;
110110
}
111111

112+
/**
113+
* A class representing a point in the skyline with its x-coordinate and height.
114+
*/
112115
public class Skyline {
113-
114116
public int coordinates;
115117
public int height;
116118

119+
/**
120+
* Constructor for the {@code Skyline} class.
121+
*
122+
* @param coordinates The x-coordinate of the skyline point.
123+
* @param height The height of the skyline at the given coordinate.
124+
*/
117125
public Skyline(int coordinates, int height) {
118126
this.coordinates = coordinates;
119127
this.height = height;
120128
}
121129
}
122130

131+
/**
132+
* A class representing a building with its left, height, and right
133+
* x-coordinates.
134+
*/
123135
public class Building {
124-
125136
public int left;
126137
public int height;
127138
public int right;
128139

140+
/**
141+
* Constructor for the {@code Building} class.
142+
*
143+
* @param left The left x-coordinate of the building.
144+
* @param height The height of the building.
145+
* @param right The right x-coordinate of the building.
146+
*/
129147
public Building(int left, int height, int right) {
130148
this.left = left;
131149
this.height = height;
132150
this.right = right;
133151
}
134152
}
135-
136-
public static void main(String[] args) {
137-
SkylineProblem skylineProblem = new SkylineProblem();
138-
skylineProblem.run();
139-
}
140153
}

‎src/test/java/com/thealgorithms/others/SkylineProblemTest.java‎

Lines changed: 86 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,86 @@
1+
package com.thealgorithms.others;
2+
3+
import static org.junit.jupiter.api.Assertions.assertEquals;
4+
5+
import java.util.ArrayList;
6+
import org.junit.jupiter.api.Test;
7+
8+
public class SkylineProblemTest {
9+
10+
@Test
11+
public void testSingleBuildingSkyline() {
12+
SkylineProblem skylineProblem = new SkylineProblem();
13+
skylineProblem.building = new SkylineProblem.Building[1];
14+
skylineProblem.add(2, 10, 9);
15+
16+
ArrayList<SkylineProblem.Skyline> result = skylineProblem.findSkyline(0, 0);
17+
18+
assertEquals(2, result.get(0).coordinates);
19+
assertEquals(10, result.get(0).height);
20+
assertEquals(9, result.get(1).coordinates);
21+
assertEquals(0, result.get(1).height);
22+
}
23+
24+
@Test
25+
public void testTwoBuildingsSkyline() {
26+
SkylineProblem skylineProblem = new SkylineProblem();
27+
skylineProblem.building = new SkylineProblem.Building[2];
28+
skylineProblem.add(1, 11, 5);
29+
skylineProblem.add(2, 6, 7);
30+
31+
ArrayList<SkylineProblem.Skyline> result = skylineProblem.findSkyline(0, 1);
32+
33+
// Expected skyline points: (1, 11), (5, 6), (7, 0)
34+
assertEquals(1, result.get(0).coordinates);
35+
assertEquals(11, result.get(0).height);
36+
assertEquals(5, result.get(1).coordinates);
37+
assertEquals(6, result.get(1).height);
38+
assertEquals(7, result.get(2).coordinates);
39+
assertEquals(0, result.get(2).height);
40+
}
41+
42+
@Test
43+
public void testMergeSkyline() {
44+
SkylineProblem skylineProblem = new SkylineProblem();
45+
ArrayList<SkylineProblem.Skyline> sky1 = new ArrayList<>();
46+
ArrayList<SkylineProblem.Skyline> sky2 = new ArrayList<>();
47+
48+
sky1.add(skylineProblem.new Skyline(2, 10));
49+
sky1.add(skylineProblem.new Skyline(9, 0));
50+
51+
sky2.add(skylineProblem.new Skyline(3, 15));
52+
sky2.add(skylineProblem.new Skyline(7, 0));
53+
54+
ArrayList<SkylineProblem.Skyline> result = skylineProblem.mergeSkyline(sky1, sky2);
55+
56+
// Expected merged skyline: (2, 10), (3, 15), (7, 10), (9, 0)
57+
assertEquals(2, result.get(0).coordinates);
58+
assertEquals(10, result.get(0).height);
59+
assertEquals(3, result.get(1).coordinates);
60+
assertEquals(15, result.get(1).height);
61+
assertEquals(7, result.get(2).coordinates);
62+
assertEquals(10, result.get(2).height);
63+
assertEquals(9, result.get(3).coordinates);
64+
assertEquals(0, result.get(3).height);
65+
}
66+
67+
@Test
68+
public void testMultipleBuildingsSkyline() {
69+
SkylineProblem skylineProblem = new SkylineProblem();
70+
skylineProblem.building = new SkylineProblem.Building[3];
71+
skylineProblem.add(1, 10, 5);
72+
skylineProblem.add(2, 15, 7);
73+
skylineProblem.add(3, 12, 9);
74+
75+
ArrayList<SkylineProblem.Skyline> result = skylineProblem.findSkyline(0, 2);
76+
77+
assertEquals(1, result.get(0).coordinates);
78+
assertEquals(10, result.get(0).height);
79+
assertEquals(2, result.get(1).coordinates);
80+
assertEquals(15, result.get(1).height);
81+
assertEquals(7, result.get(2).coordinates);
82+
assertEquals(12, result.get(2).height);
83+
assertEquals(9, result.get(3).coordinates);
84+
assertEquals(0, result.get(3).height);
85+
}
86+
}

0 commit comments

Comments
 (0)