算法导论学习笔记（五）计算几何之寻找凸包

定义：点集Q的凸包是一个最小的凸多边形P，满足Q中的每个点都在P的边界上或在P的内部。

Graham扫描法

通过排序所有点，选择一个一定是凸包中的点作为基点，再在剩余点中按相对于基点的极角排序，最后依次遍历所有点，将不符合凸多边形定义的点去除，剩下的点集便是凸包中的点。

伪代码

GRAHAM-SCAN( Q)
Q.sort( 0, 1, 2..., n-1) with
(pi.y==pj.y)? (pi.x<pj.x) : (pi.y<pj.y)
//以p0点为原点，建立极坐标
Q.sort( 1, 2..., n-1) with
(pi.θ==pj.θ)? (pi.λ<pj.λ) : (pi.θ<pj.θ)
let S be an empty stack
PUSH( p0, S)
PUSH( p1, S)
PUSH( p2, S)
for i = 3 to n
while    pi makes a nonleft turn
POP( S)
PUSH( pi, S)
return S

代码实现

#include <cmath>
#include <algorithm>
const double ACCURACY = 0.0000001;
typedef struct Point
{
int x,y;
}VectorLine;
VectorLine operator- ( Point a, Point b)
{
VectorLine c;
c.x = a.x - b.x;
c.y = a.y - b.y;
return c;
}
bool cmpX( Point a, Point b )
{
if( a.x == b.x )
return a.y < b.y;
return a.x < b.x;
}
double getDistance( Point a, Point b )
{
return sqrt( pow(a.x-b.x,2.0) + pow(a.y-b.y,2.0) );
}
struct Node
{
Point point;
double degree;
double distance;
};
void setNode(Node &a, Point source )
{
double distance = getDistance( a.point, source );
double deltaY = (a.point).y - source.y;
double degree = asin( deltaY/distance );
a.distance = distance;
a.degree = degree;
}
bool cmpPoint( Node a, Node b )
{
return cmpX( a.point, b.point );
}
bool cmpDegree( Node a, Node b )
{
if( fabs( a.degree-b.degree ) < ACCURACY )
return a.distance < b.distance;
return a.degree < b.degree;
}
int getCrossProduct( VectorLine a, VectorLine b )
{
return a.x*b.y - a.y*b.x;
}
bool check( Point newPoint, Point oldPoint, Point sourcePoint )
{
VectorLine oldLine = oldPoint - sourcePoint;
VectorLine newLine = newPoint - sourcePoint;
return getCrossProduct( oldLine, newLine ) > 0;
}
int getConvexHull( Node *nodes, int sizeOfNodes, Point *convexHull )
{
//Graham's scan
std::sort( nodes, nodes+sizeOfNodes, cmpPoint );

for( int i=1; i<sizeOfNodes; i++ ) {
setNode(nodes[i],nodes[0].point);
}
std::sort( nodes+1, nodes+sizeOfNodes, cmpDegree );

int sizeOfStack = 0;
for( int i=0;i<std::min(3,sizeOfNodes);i++ ) {
convexHull[sizeOfStack++] = nodes[i].point;
}

for( int i=3;i<sizeOfNodes;i++ ) {
while( sizeOfStack > 2 &&
!check( nodes[i].point,
convexHull[sizeOfStack-1],
convexHull[sizeOfStack-2] )
) {

sizeOfStack--;
}
convexHull[sizeOfStack++] = nodes[i].point;
}
return sizeOfStack;
}

Jarvis步进法

将点设为有物理特性，利用一条可弯曲的射线，将一端放在一个最左边的点上，将射线方向设为180度，逆时针旋转，所遇见的第一个为下一个凸包点，然后依次挑选，直至点为第一个点时，所选出的点集为凸包。

伪代码

JARVIS( Q)
Q.sort( 0, 1, 2..., n-1) with
(pi.y==pj.y)? (pi.x<pj.x) : (pi.y<pj.y)
let nowPoint = 0 and nextPoint = -1
while nextPoint != 0
//以p0点为原点，建立极坐标
nextPoint in Q
//nextPoint为Q中极角最小的点
nowPoint = nextPoint