给定一组点，连接点而不交叉。
例子：
Input: points[] = {(0, 3), (1, 1), (2, 2), (4, 4),
(0, 0), (1, 2), (3, 1}, {3, 3}};
Output: Connecting points in following order would
not cause any crossing
{(0, 0), (3, 1), (1, 1), (2, 2), (3, 3),
(4, 4), (1, 2), (0, 3)}我们强烈建议您将浏览器最小化，然后自己先尝试一下。
这个想法是使用排序。
- 通过比较所有点的 y 坐标找到最底部的点。如果有两个点的 y 值相同，则考虑 x 坐标值较小的点。将最底部的点放在第一个位置。
- 考虑剩余的 n-1 个点，并在点 [0] 周围按逆时针顺序按极角对它们进行排序。如果两点的极角相同，则将最近的点放在最前面。
- 遍历已排序的数组（按角度递增顺序排序）产生简单的闭合路径。
如何计算角度？
一种解决方案是使用三角函数。
观察：我们不关心角度的实际值。我们只想按角度排序。
想法：使用方向来比较角度而不实际计算它们！
下面是上述想法的 C++ 实现。
C++
// A C++ program to find simple closed path for n points
// for explanation of orientation()
#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 swap two points
int 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 dist(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; // clockwise 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 (dist(p0, *p2) >= dist(p0, *p1))? -1 : 1;
return (o == 2)? -1: 1;
}
// Prints simple closed path for a set of n points.
void printClosedPath(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. In case of tie, chose the
// left most point
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);
// Now stack has the output points, print contents
// of stack
for (int i=0; i 输出：
(0, 0), (3, 1), (1, 1), (2, 2), (3, 3),
(4, 4), (1, 2), (0, 3), 如果我们使用 O(nLogn) 排序算法对点进行排序，则上述解决方案的时间复杂度为 O(n Log n)。
如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。