Question

我采用Anderson的单调链算法来寻找凸包，但在这样做之后我发现结果点是x阶，而不是旋转顺序。是否有一个凸包船体算法以顺式旋转顺序生成点，这意味着在船体周边的顺序？

这是我的单调链实现，不能满足我的问题：

// monotone chain
public static ComparablePoint[] convex_hull( ComparablePoint[] points ){
    if( points.length > 1 ){
        int ctPoints = points.length;
        int k = 0;
        ComparablePoint[] hull = new ComparablePoint[ 2 * ctPoints ];
        java.util.Arrays.sort( points );

        // Build lower hull
        for (int i = 0; i < ctPoints; ++i) {
            while (k >= 2 && crossProduct(hull[k - 2], hull[k - 1], points[i]) <= 0)
                k--;
            hull[k++] = points[i];
        }

        // Build upper hull
        for (int i = ctPoints - 2, t = k + 1; i >= 0; i--) {
            while (k >= t && crossProduct(hull[k - 2], hull[k - 1], points[i]) <= 0)
                k--;
            hull[k++] = points[i];
        }
        if (k > 1) {
            hull = java.util.Arrays.copyOfRange(hull, 0, k - 1); // remove non-hull vertices after k; remove k - 1 which is a duplicate
        }
        return hull;
    } else if( points.length <= 1 ){
        return points;
    } else{
        return null;
    }
}

要清楚我的旋转顺序是什么意思：凸包上的点位于一个凸多边形的周边。当你绕着多边形的周边时，我需要这些点。

上面显示的单调链算法不会这样做，它按照x坐标的顺序返回点。具有最低x坐标的点是第一个，然后是具有第二个最低x的点，依此类推。

Answer 1

只需将以下算法添加到算法中，该算法以递增的X顺序输出点。

我们将从算法的输出生成凸包的上半部分和下半部分。

让我们看看凸壳上的极端点。将它们命名为L和R. [L是具有最小X坐标的点，R是具有最大X坐标的点]。

现在对于所有其他点我们将检查该点是在上半部分还是下半部分。这可以通过检查某个点K是否位于连接L和R的线上方，或位于连接L和R的线下方来轻松完成。

因此，我们可以在lower_half或upper_half中对所有点进行分类。

最后答案是：点L [左极值，即最小值X] +上部的点数增加X顺序，点R [右极值，即最大值X] +下部的点数按降序X顺序。

注意：上述算法的复杂度为O（n），因此它不会影响算法的运行时复杂度，并且在添加后，解决方案的复杂性仍为O（n log n）。

Answer 2

以下算法会根据您的描述对船体上的点进行排序。它类似于@AyushMishra提供的答案，但另外解决了两个点具有相同X（或Y）值的情况。

/**
 * Sorts the given array according to "merry-go-round" order. The array is
 * sorted in-place. The ordering is clockwise ending with the bottom-most
 * point.
 * 
 * @param points
 *            An array of points on a convex hull.
 */
public static void sortPoints(Point[] points) {

    // Ensure the input array is sorted by x-value
    Arrays.sort(points, (o1, o2) -> Double.compare(o1.getX(), o2.getX()));

    // get the index of the point with the smallest Y-value
    int bottomMost = 0;
    for (int i = 0; i < points.length; i++) {
        if (points[i].getY() < points[bottomMost].getY())
            bottomMost = i;
    }

    final Comparator<Point> hullComp = new Comparator<Point>() {

        @Override
        public int compare(Point o1, Point o2) {
            // handle case when Y's are the same.
            if (o1.getY() == o2.getY())
                return Double.compare(o1.getX(), o2.getX());

            // otherwise, just compare Y values
            return Double.compare(o1.getY(), o2.getY());
        }
    };

    // Sort the left side of the hull from smallest Y to largest Y
    Arrays.sort(points, 0, bottomMost, hullComp);

    // Sort the right side of the hull from largest Y to smallest Y
    Arrays.sort(points, bottomMost, points.length,
            (o1, o2) -> hullComp.compare(o2, o1));

}

我将此算法应用于this question中的2D船体。这是结果图。（注意：我偏移了点，这样轴就不会使图像混乱）跟踪线显示执行中不同点的排序：

或者，您可以使用生成船体的算法，该船体按（顺时针）顺序自动排序。例如，Gift wrapping algorithm在 O（nh）时间内以旋转木马顺序生成点，其中 h 是船体上的顶点数。该算法的伪代码（借用维基百科）是：

jarvis(S)
   pointOnHull = leftmost point in S
   i = 0
   repeat
      P[i] = pointOnHull
      endpoint = S[0]         // initial endpoint for a candidate edge on the hull
      for j from 1 to |S|
         if (endpoint == pointOnHull) or (S[j] is on left of line from P[i] to endpoint)
            endpoint = S[j]   // found greater left turn, update endpoint
      i = i+1
      pointOnHull = endpoint
   until endpoint == P[0]      // wrapped around to first hull point

在快乐中生成点的凸壳算法是否按顺序排列？

2 个答案: