Question

所以这是一个优化问题，我找不到答案。

我已经编写了一些用于计算给定随机点集的凸包的代码。为了比较的目的，我制作了自己的慢速O（n³）算法，使用一些旧的OpenGL来实现它的可视化。由于慢凸壳算法的性质，这些点根本没有排序。因此，排序发生在CH的计算之后。

我的问题是，直到1000点，我在不到一秒的时间内得到了视觉效果。但是对于10000点，它需要超过15-20分钟（我没有等待超过这一点）。然而如果我跳过排序代码并让opengl显示未分类的凸包顶点，则需要不到一分钟。所以这就是ClockWise排序，它一直在吃掉。检查代码（某些名称没有意义，因为它们在别处定义）：

// This code actually compares every pair iteratively with respect to the center point
// Consider a given vector "convex", which contains all the convex hull points unsorted

.
..
...
....

int avgx,avgy,sumx=0,sumy=0;

for (int i=0;i<convex.size();i++){
    sumx+=convex.at(i).at(0);
    sumy+=convex.at(i).at(1);
}

avgx=sumx/(convex.size()/2.0); //something like an internal point
avgy=sumy/(convex.size()/2.0);

sort(convex.begin(),convex.end()); //x-sort 
int det,tempx,tempy;
for (int i=0;i<convex.size()-1;i++){
    x1=convex.at(i).at(0);
    y1=convex.at(i).at(1);
    x2=convex.at(i+1).at(0);
    y2=convex.at(i+1).at(1);
    det=(x1-avgx)*(y2-avgy)-(x2-avgx)*(y1-avgy); 
    if (det<0){ //on which side of O-X1 lies X2?
        tempx=convex.at(i).at(0); //swapping points 
        tempy=convex.at(i).at(1);
        convex.at(i).at(0)=convex.at(i+1).at(0);
        convex.at(i).at(1)=convex.at(i+1).at(1);
        convex.at(i+1).at(0)=tempx;
        convex.at(i+1).at(1)=tempy;
        i=-1; //check again the new vector from the beginning
    }
    }
return convex;

显示部分：

glColor3f(0.8, 0.2, 0.2);
glPointSize(3);
glBegin(GL_LINE_LOOP);
    for (int i=0;i<count;i++){
        glVertex2f(convexHull.at(i).at(0),convexHull.at(i).at(1));
    }
glEnd();

从我所看到的，这种方法（通过比较交叉产品）是最有效的。然而，在此之前我写了一些实际上更快的肮脏代码，因为它在8分钟内给了我一个视觉结果。我不想保留它，因为它太脏而且很长，这个更干净但很慢（如果它实际上可以工作......）。那么，我是否必须等待CW类10000个凸点，或者我有什么遗漏？

我很感激任何想法，如果我需要包含其他内容，请告诉我。

Answer 1

一般来说，这个问题有点奇怪。大多数2D凸壳算法（我所知道的都是）以顺时针或逆时针顺序给出点（顶点）列表，或者可以通过简单修改它们来实现。

在任何情况下，由于有几种良好的二维凸包测定方法以 O（N ^ 2）或更快的速度运行，您可以使用其中一种方法将数据“排序”到顺时针顺序。我所说的是你可以对数据运行CH算法，并按照你想要的顺序得到结果。

这是一个我躺在那里的示例代码，我认为可以做你想做的事情：

#define TURN_DIR(p1,p2,p3)  (p1.x * p2.y - p1.y * p2.x + \
                             p2.x * p3.y - p2.y * p3.x + \
                             p3.x * p1.y - p3.y * p1.x)
#define LAST(cntnr)         (cntnr).back()
#define BEFORE_LAST(cntnr)  (cntnr)[(cntnr).size() - 2]

void ConvexHull (std::vector<Point> & pts)
{
    std::sort (pts.begin(), pts.end());

    std::vector<Point> lower, upper;
    for (unsigned i = 0; i < pts.size(); ++i)
    {
        while (lower.size() > 1 && TURN_DIR(BEFORE_LAST(lower), LAST(lower), pts[i]) <= 0)
            lower.pop_back ();
        while (upper.size() > 1 && TURN_DIR(BEFORE_LAST(upper), LAST(upper), pts[i]) >= 0)
            upper.pop_back ();

        lower.push_back (pts[i]);
        upper.push_back (pts[i]);
    }

    upper.insert (upper.end(), lower.rbegin() + 1, lower.rend() - 1);
    pts.swap (upper);
}

有几点需要考虑：

上面的代码接收其输入并以相同的参数返回其输出：pts。
Point结构是一个简单的结构（或类），包含两个公共成员x和y，以及一个比较小于运算符（operator <）的结构它们非常简单地首先基于x，然后基于y。
我认为上面代码的运行时间是 O（N * log（N）），但肯定不会比 O（N ^ 2）差
返回的点将按顺时针顺序。如果你想逆时针，你只需要改变最后两行。
此代码不会处理所有点都具有相同X坐标的情况（我认为！）
除此之外，这是一个功能齐全，快速简单的2D凸壳实现。
如果输入中有连续的点位于同一行，则此实现将删除它们。如果您不希望这样，则可以分别用<= 0和>= 0替换while循环中的< 0和> 0测试。

让我强调一下：虽然上面的代码是CH实现，但你可以用它来按顺时针顺序排序你的点（如果它们已经形成一个凸包）。

Answer 2

您已实施Bubble Sort，即O（n ²）。你可以使用带有适当比较函子的STL sort得到O（n log（n））。

这是第一次努力;它使用了一个非传递的比较器，但它似乎适用于我的测试用例，我认为它通常是正确的：

struct clockwise : public binary_function<vector<int>, vector<int>, bool>
{
  bool operator()(vector<int> A, vector<int> B)
  {
    int det=(A[0]-avgx)*(B[1]-avgy)-(B[0]-avgx)*(A[1]-avgy);
    return(det<0);
  }

  static int avgx, avgy;
};

int clockwise::avgx = 0;
int clockwise::avgy = 0;

...

int clockwise::avgx=sumx/(convex.size()/2.0);
int clockwise::avgy=sumy/(convex.size()/2.0);
sort(convex.begin(),convex.end(), clockwise()); //clockwise-sort

修改

非传递性比较者并不是一个好主意。这更可靠：

#include <math.h>

...

struct clockwise : public binary_function<vector<int>, vector<int>, bool>
{
  bool operator()(vector<int> A, vector<int> B)
  {
    return(atan2(A[0]-avgx, A[1]-avgy) < atan2(B[0]-avgx, B[1]-avgy));
  }
}

优化顺时针排序算法

2 个答案: