From 0a3717957c0d2aa466f5494be081806ea8c108a2 Mon Sep 17 00:00:00 2001 From: Libin Yang Date: Tue, 15 Jan 2019 19:54:43 +0800 Subject: [PATCH] Update SkylineAlgorithm.java --- divideconquer/SkylineAlgorithm.java | 153 ++++++++++++++-------------- 1 file changed, 74 insertions(+), 79 deletions(-) diff --git a/divideconquer/SkylineAlgorithm.java b/divideconquer/SkylineAlgorithm.java index f1b1f44c..51bce90c 100644 --- a/divideconquer/SkylineAlgorithm.java +++ b/divideconquer/SkylineAlgorithm.java @@ -1,36 +1,32 @@ -package skylinealgorithm; - import java.util.ArrayList; import java.util.Comparator; /** - * * @author dimgrichr - * + *

* Space complexity: O(n) * Time complexity: O(nlogn), because it is a divide and conquer algorithm */ public class SkylineAlgorithm { private ArrayList points; - - + /** * Main constructor of the application. * ArrayList points gets created, which represents the sum of all edges. */ - public SkylineAlgorithm(){ + public SkylineAlgorithm() { points = new ArrayList<>(); } - - + + /** * @return points, the ArrayList that includes all points. */ - public ArrayList getPoints(){ + public ArrayList getPoints() { return points; } - - + + /** * The main divide and conquer, and also recursive algorithm. * It gets an ArrayList full of points as an argument. @@ -38,55 +34,51 @@ public class SkylineAlgorithm { * the ArrayList is returned as it is, or with one less point * (if the initial size is 2 and one of it's points, is dominated by the other one). * On the other hand, if the ArrayList's size is bigger than 2, - * the function is called again, twice, + * the function is called again, twice, * with arguments the corresponding half of the initial ArrayList each time. * Once the flashback has ended, the function produceFinalSkyLine gets called, * in order to produce the final skyline, and return it. + * * @param list, the initial list of points * @return leftSkyLine, the combination of first half's and second half's skyline * @see Point * @see produceFinalSkyLine */ - public ArrayList produceSubSkyLines(ArrayList list){ - - //part where function exits flashback + public ArrayList produceSubSkyLines(ArrayList list) { + + // part where function exits flashback int size = list.size(); - if(size == 1){ + if (size == 1) { return list; - } - else if(size==2){ - if(list.get(0).dominates(list.get(1))){ + } else if (size == 2) { + if (list.get(0).dominates(list.get(1))) { list.remove(1); - } - else{ - if(list.get(1).dominates(list.get(0))){ + } else { + if (list.get(1).dominates(list.get(0))) { list.remove(0); } } return list; } - - //recursive part of the function - ArrayList leftHalf=new ArrayList<>(); - ArrayList rightHalf=new ArrayList<>(); - for (int i=0;i leftHalf = new ArrayList<>(); + ArrayList rightHalf = new ArrayList<>(); + for (int i = 0; i < list.size(); i++) { + if (i < list.size() / 2) { leftHalf.add(list.get(i)); - } - else{ + } else { rightHalf.add(list.get(i)); } } - ArrayList leftSubSkyLine=new ArrayList<>(); - ArrayList rightSubSkyLine=new ArrayList<>(); - leftSubSkyLine=produceSubSkyLines(leftHalf); - rightSubSkyLine=produceSubSkyLines(rightHalf); - - //skyline is produced - return produceFinalSkyLine(leftSubSkyLine,rightSubSkyLine); + ArrayList leftSubSkyLine = produceSubSkyLines(leftHalf); + ArrayList rightSubSkyLine= produceSubSkyLines(rightHalf); + + // skyline is produced + return produceFinalSkyLine(leftSubSkyLine, rightSubSkyLine); } - - + + /** * The first half's skyline gets cleared * from some points that are not part of the final skyline @@ -97,94 +89,97 @@ public class SkylineAlgorithm { * are dominated, so they are not part of the final skyline. * Finally, the "cleaned" first half's and second half's skylines, are combined, * producing the final skyline, which is returned. - * @param left the skyline of the left part of points + * + * @param left the skyline of the left part of points * @param right the skyline of the right part of points * @return left the final skyline */ - public ArrayList produceFinalSkyLine(ArrayList left, ArrayList right){ - - //dominated points of ArrayList left are removed - for(int i=0;ileft.get(i+1).y){ + public ArrayList produceFinalSkyLine(ArrayList left, ArrayList right) { + + // dominated points of ArrayList left are removed + for (int i = 0; i < left.size() - 1; i++) { + if (left.get(i).x == left.get(i + 1).x && left.get(i).y > left.get(i + 1).y) { left.remove(i); i--; } } - - //minimum y-value is found - int min=left.get(0).y; - for(int i=1;ileft.get(i).y){ + + // minimum y-value is found + int min = left.get(0).y; + for (int i = 1; i < left.size(); i++) { + if (min > left.get(i).y) { min = left.get(i).y; - if(min==1){ - i=left.size(); + if (min == 1) { + i = left.size(); } } } - - //dominated points of ArrayList right are removed - for(int i=0;i=min){ + + // dominated points of ArrayList right are removed + for (int i = 0; i < right.size(); i++) { + if (right.get(i).y >= min) { right.remove(i); i--; } } - - //final skyline found and returned + + // final skyline found and returned left.addAll(right); return left; } - - - public static class Point{ + + public static class Point { private int x; private int y; + /** * The main constructor of Point Class, used to represent the 2 Dimension points. + * * @param x the point's x-value. * @param y the point's y-value. */ - public Point(int x, int y){ - this.x=x; - this.y=y; + public Point(int x, int y) { + this.x = x; + this.y = y; } + /** * @return x, the x-value */ - public int getX(){ + public int getX() { return x; } + /** * @return y, the y-value */ - public int getY(){ + public int getY() { return y; } + /** * Based on the skyline theory, * it checks if the point that calls the function dominates the argument point. + * * @param p1 the point that is compared * @return true if the point wich calls the function dominates p1 - * false otherwise. + * false otherwise. */ - public boolean dominates(Point p1){ - - //checks if p1 is dominated - if((this.x { - @Override - public int compare(Point a, Point b) { - return a.x < b.x ? -1 : a.x == b.x ? 0 : 1; - } + @Override + public int compare(Point a, Point b) { + return Integer.compare(a.x, b.x); + } } }