凸包 |第 2 组（格雷厄姆扫描）

给定平面上的一组点。该集合的凸包是包含其所有点的最小凸多边形。

我们强烈建议您先查看以下帖子。
如何检查两个给定的线段是否相交？
我们已经讨论了凸包的 Jarvis 算法。 Jarvis 算法的最坏情况时间复杂度是 O(n^2)。使用 Graham 的扫描算法，我们可以在 O(nLogn) 时间内找到 Convex Hull。以下是格雷厄姆的算法
让 points[0..n-1] 成为输入数组。
1）通过比较所有点的y坐标找到最底部的点。如果有两个点的 y 值相同，则考虑 x 坐标值较小的点。让最底部的点是 P0。将 P0 放在输出外壳的第一个位置。
2）考虑剩余的n-1个点，并围绕点[0]按逆时针顺序按极角对它们进行排序。如果两点的极角相同，则将最近的点放在最前面。
3排序后，检查两个或多个点是否具有相同的角度。如果另外两个点的角度相同，则删除所有相同角度的点，除了离 P0 最远的点。设新数组的大小为 m。
4)如果 m 小于 3，则返回（凸包不可能）
5)创建一个空栈 ‘S’ 并将 points[0]、points[1] 和 points[2] 压入 S。
6) 将剩余的 m-3 点一一处理。对每个点“points[i]”进行以下操作
4.1)当后面 3 个点的方向不是逆时针时（或者他们不左转），继续从堆栈中删除点。
a) 指向栈顶
b) 指向栈顶
c) 点数[i]
4.2) 把points[i]推到S
5)打印 S 的内容
上述算法可以分为两个阶段。
阶段 1（排序点）：我们首先找到最底部的点。这个想法是预处理点，根据最底部的点对它们进行排序。一旦点被排序，它们就形成了一个简单的闭合路径（见下图）。

排序标准应该是什么？实际角度的计算将是低效的，因为三角函数不容易评估。这个想法是使用方向来比较角度而不实际计算它们（参见下面的 compare()函数）
阶段 2（接受或拒绝点）：一旦我们有了封闭的路径，下一步就是遍历路径并移除这条路径上的凹点。如何决定删除哪些点，保留哪些点？同样，方向在这里有帮助。排序数组中的前两个点始终是凸包的一部分。对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。设三个点分别为 prev(p)、curr(c) 和 next(n)。如果这些点的方向（以相同的顺序考虑它们）不是逆时针方向，我们丢弃 c，否则我们保留它。下图显示了此阶段的分步过程。

以下是上述算法的 C++ 实现。

CPP

// A C++ program to find convex hull of a set of points. Refer
// https://www.geeksforgeeks.org/orientation-3-ordered-points/
// for explanation of orientation()
#include 
#include 
#include 
using namespace std;
 
struct Point
{
    int x, y;
};
 
// A global point needed for  sorting points with reference
// to  the first point Used in compare function of qsort()
Point p0;
 
// A utility function to find next to top in a stack
Point nextToTop(stack &S)
{
    Point p = S.top();
    S.pop();
    Point res = S.top();
    S.push(p);
    return res;
}
 
// A utility function to swap two points
void swap(Point &p1, Point &p2)
{
    Point temp = p1;
    p1 = p2;
    p2 = temp;
}
 
// A utility function to return square of distance
// between p1 and p2
int distSq(Point p1, Point p2)
{
    return (p1.x - p2.x)*(p1.x - p2.x) +
          (p1.y - p2.y)*(p1.y - p2.y);
}
 
// To find orientation of ordered triplet (p, q, r).
// The function returns following values
// 0 --> p, q and r are colinear
// 1 --> Clockwise
// 2 --> Counterclockwise
int orientation(Point p, Point q, Point r)
{
    int val = (q.y - p.y) * (r.x - q.x) -
              (q.x - p.x) * (r.y - q.y);
 
    if (val == 0) return 0;  // colinear
    return (val > 0)? 1: 2; // clock or counterclock wise
}
 
// A function used by library function qsort() to sort an array of
// points with respect to the first point
int compare(const void *vp1, const void *vp2)
{
   Point *p1 = (Point *)vp1;
   Point *p2 = (Point *)vp2;
 
   // Find orientation
   int o = orientation(p0, *p1, *p2);
   if (o == 0)
     return (distSq(p0, *p2) >= distSq(p0, *p1))? -1 : 1;
 
   return (o == 2)? -1: 1;
}
 
// Prints convex hull of a set of n points.
void convexHull(Point points[], int n)
{
   // Find the bottommost point
   int ymin = points[0].y, min = 0;
   for (int i = 1; i < n; i++)
   {
     int y = points[i].y;
 
     // Pick the bottom-most or chose the left
     // most point in case of tie
     if ((y < ymin) || (ymin == y &&
         points[i].x < points[min].x))
        ymin = points[i].y, min = i;
   }
 
   // Place the bottom-most point at first position
   swap(points[0], points[min]);
 
   // Sort n-1 points with respect to the first point.
   // A point p1 comes before p2 in sorted output if p2
   // has larger polar angle (in counterclockwise
   // direction) than p1
   p0 = points[0];
   qsort(&points[1], n-1, sizeof(Point), compare);
 
   // If two or more points make same angle with p0,
   // Remove all but the one that is farthest from p0
   // Remember that, in above sorting, our criteria was
   // to keep the farthest point at the end when more than
   // one points have same angle.
   int m = 1; // Initialize size of modified array
   for (int i=1; i S;
   S.push(points[0]);
   S.push(points[1]);
   S.push(points[2]);
 
   // Process remaining n-3 points
   for (int i = 3; i < m; i++)
   {
      // Keep removing top while the angle formed by
      // points next-to-top, top, and points[i] makes
      // a non-left turn
      while (S.size()>1 && orientation(nextToTop(S), S.top(), points[i]) != 2)
         S.pop();
      S.push(points[i]);
   }
 
   // Now stack has the output points, print contents of stack
   while (!S.empty())
   {
       Point p = S.top();
       cout << "(" << p.x << ", " << p.y <<")" << endl;
       S.pop();
   }
}
 
// Driver program to test above functions
int main()
{
    Point points[] = {{0, 3}, {1, 1}, {2, 2}, {4, 4},
                      {0, 0}, {1, 2}, {3, 1}, {3, 3}};
    int n = sizeof(points)/sizeof(points[0]);
    convexHull(points, n);
    return 0;
}

输出：

(0, 3)
(4, 4)
(3, 1)
(0, 0) 

时间复杂度：设 n 为输入点的数量。如果我们使用 O(nLogn) 排序算法，该算法需要 O(nLogn) 时间。
第一步（找到最底部的点）需要 O(n) 时间。第二步（排序点）花费 O(nLogn) 时间。第三步花费 O(n) 时间。在第三步中，每个元素最多被推入和弹出一次。所以第六步一一处理点需要O(n)时间，假设堆栈操作需要O(1)时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。