礼物包装算法求凸包

写在前面：本人还是JAVA和算法的初学者，在博客中写的代码可能比较烂，算法理解也可能不深入，只是通过博客记录一下自己的学习历程，希望大佬们能多多帮我提出意见。

概念基础：

  凸包问题：凸包是一个几何概念，而求凸包则是一个图论问题。

  凸包定义如下：

  ⒈.对于一个集合D，D中任意有限个点的凸组合的全体称为D的凸包。

  ⒉.对于一个集合D，所有包含D的凸集之交称为D的凸包。

  我是这样理解的，对于二维坐标系下的一系列点，凸包就是我们用线来连接最外一圈的点，保证所有的点都在圈内并且线的长度要尽可能短。类比来说，就像在一块海绵板上扎上许多牙签，

用一根橡皮筋套住所有牙签，这个橡皮筋所围起来的就是这些牙签的凸包。

  礼物包装算法：礼物包装算法求凸包是从凸包某一点为起始点，按某一时针方向依次寻找最外侧的点并链接。此时所有的点就像等待包装的“礼物”，围成凸包的线就是“包装纸”，像包礼物一样

以某个方向“缠绕过去”，最后所得出的就是凸包。

  算法实现：在实现算法中，我是以顺时针方向，寻找与y轴正方向顺时针夹角最小的点来编写的，这要求了我的起始点必须是整个图最左下角的点，即x最小，x相同下y最小的点（或y最小，y

相同下x最小的点）。这保证了所选取的初始点一定在最终的凸包上。随后，将这一点加入凸包集合，注意为了最后能再找到这一点，仅这一点不进行标记。遍历图中尚未被标记的所有点并计算

起始点与这一点连线与y轴顺时针夹角，取夹角最小点加入凸包并标记，将新加入的这一点选为起始点，继续上述操作...直至最终找到最初的起始点，凸包完成。

  代码如下：

 public static Set<Point> convexHull(Set<Point> points) {
    	if (points.size() <= 3) {
    		return points;
    	}
    	Set<Point> sorder = new HashSet<Point>();
    	
        Iterator<Point> ie = points.iterator();
        Point tempt = ie.next();
        while(ie.hasNext())
        {
        	Point tempx1 = ie.next();
        	if(tempx1.x() < tempt.x())
        	{
        		tempt = tempx1;
        	} else if (tempx1.x() == tempt.x() && tempx1.y() < tempt.y()) {
        		tempt = tempx1;
        	}
        }
        sorder.add(tempt);
        
        ArrayList<Point> listp = new ArrayList<>(points);
        Point waitp, pointp;
        double anglel1 = 0;
        double anglel2 = 0;
        waitp = tempt;
        pointp = listp.get(0);
        double tempx, tempy;
        
        do
        {
        	anglel1 = 360;
            for(int i = 0; i < listp.size(); i++)
            {
            	if(listp.get(i) != waitp)
            	{
            		tempx = listp.get(i).x();
                	tempy = listp.get(i).y();
                	anglel2 = calculateBearingToPoint(0, (int)waitp.x(), (int)waitp.y(),(int)tempx, (int)tempy);
                	if(anglel2 < anglel1)
                	{
                		pointp = listp.get(i);
                		anglel1 = anglel2;
                	} else if(anglel1 == anglel2) {
                		double distance1 = Math.pow(waitp.x() - tempx,2) + Math.pow(waitp.y() - tempy,2);
                		double distance2 = Math.pow(waitp.x() - pointp.x(),2) + Math.pow(waitp.y() - pointp.y(),2);
                		if (distance1 > distance2) {
                			pointp = listp.get(i);
                		}
                	}
            	}
            }
            sorder.add(pointp);
            listp.remove(pointp);
            waitp = pointp;
        }while(waitp != tempt);
        return sorder;
    }

 public static double calculateBearingToPoint(double currentBearing, int currentX, int currentY,int targetX, int targetY) {
    	double temp, aangle;
    	if(currentX != targetX)
    	{
    		aangle = Math.toDegrees(Math.atan(Math.abs((double)(currentY - targetY) /(double) (currentX - targetX))));
    	}
    	else
    	{
    		aangle = 90;
    	}
        if(currentY == targetY)
        {
        	if(currentX >= targetX)
        	{
        		if(currentBearing <= 270)
        		{
        			return Math.abs(270 - currentBearing);
        		}
        		else
        		{
        			return Math.abs(630 - currentBearing);
        		}
        	}
        	else
        	{
        		if(currentBearing <= 90)
        		{
        			return Math.abs(90 - currentBearing);
        		}
        		else
        		{
        			return Math.abs(450 - currentBearing);
        		}
        	}
        }
        else if(currentY > targetY)
        {
        	if(currentX >= targetX)
        	{
        		if(currentBearing + aangle <= 270)
        		{
        			return (270 - currentBearing - aangle);
        		}
        		else
        		{
        			return 360 - (currentBearing - 270 + aangle);
        		}
        	}
        	else
        	{
        		if(currentBearing <= (90 + aangle))
        		{
        			return 90 - currentBearing + aangle;
        		}
        		else
        		{
        			return 360 - (currentBearing - (90 + aangle));
        		}
        	}
        }
        else
        {
        	if(currentX >= targetX)
        	{
        		if(currentBearing <= (270 + aangle))
        		{
        			
        			return (270 - currentBearing + aangle) % 360;
        		}
        		else
        		{
        			return 360 - (currentBearing - (270 + aangle));
        		}
        	}
        	else
        	{
        		if(currentBearing <= (90 - aangle))
        		{
        			return 90 - currentBearing - aangle;
        		}
        		else
        		{
        			return 360 - (currentBearing - 90 + aangle);
        		}
        	}
        }
    }

（求夹角代码写的很烂，请见谅）在我的代码中有几点值得注意的地方，首先当求得两夹角相等时，应该判断两点对初始点距离，取距离远者加入，其次

因为我的最终返回类型为set，最后将最初的起始点加入操作相当于没有对集合进行任何操作，因为集合中已经有了这一元素。