Question

我的程序的任务是根据用户使用铲斗排序与原点的距离，在用户给出的x-y平面上对点进行排序。在具有相同距离的两个点的情况下，将选择具有最小x坐标的点作为第一点。如果距离和x坐标都相同，则具有最小y坐标的元素将首先出现。输出是点本身，而不是它们的距离。到目前为止，我发现最合乎逻辑的方法是创建一个自定义数据结构，其中包含x坐标，y坐标和它在一个元素中的距离。我目前遇到的问题是我目前的双标准矢量算法，我不知道如何转换排序以满足我的需求。任何想法或建议都会有所帮助。

这是结构的布局：

struct point {
double  xc;
double  yc;
double  dist;  };

当前的存储桶排序，适用于双打矢量。

void bucketSort(vector<double> &arr) {
    int n = B.size();
    vector<point> b[n];

    for (int i=0; i<n; i++)
    {
       int bi = n*arr[i];
       b[bi].push_back(arr[i]);
    }

    for (int i=0; i<n; i++)
       sort(b[i].begin(), b[i].end());

    int index = 0;
    for (int i = 0; i < n; i++){
        for (int j = 0; j < b[i].size(); j++){
            arr[index++] = b[i][j]; }
        }
    }

截至目前，整个代码。

using namespace std;

struct point {
    double  xc;
    double  yc;
    double  dist;
};

vector<double> A;
vector<double> B;

double findDistance(double x = 0, double y = 0) {
    double x2 = pow(x, 2);
    double y2 = pow(y, 2);
    double z = x2 + y2;
    double final = sqrt(z);
    return final;
}

void bucketSort(vector<double> &arr)
{
    int n = B.size();
    vector<point> b[n];

    for (int i=0; i<n; i++)
    {
       int bi = n*arr[i];
       b[bi].push_back(arr[i]);
    }

    for (int i=0; i<n; i++)
        sort(b[i].begin(), b[i].end());

    int index = 0;
    for (int i = 0; i < n; i++){
        for (int j = 0; j < b[i].size(); j++){
            arr[index++] = b[i][j]; }
        }
    }

int main(){
    double number; int t = 0; 
    while (cin >> number){ 
        A.push_back(number);    }
    struct point    C[A.size()];
    while (t < A.size()){ 
        C[t / 2].xc = A[t]; C[t / 2].yc = A[t + 1]; 
        C[t / 2].dist = (findDistance(A[t], A[t + 1])); t += 2; } 
    cout << setprecision(6); cout << fixed; ;
    bucketSort(C);
    cout << showpos; cout << fixed;
    int x = 0;
    while (x < (A.size() / 2)){
        cout << C[x].xc << " " << C[x].yc << endl;
        x++;
    }
}

双打B的向量在这里，因为最初，我试图用多个双打矢量完成它。

以下是输入的示例：

0.2 0.38
0.6516 -0.1
-0.3 0.41
-0.38 0.2

示例输出：

-0.380000 +0.200000
+0.200000 +0.380000
-0.300000 +0.410000
+0.651600 -0.100000

我意识到这一点可以添加更多功能，以使其在一般情况下更加实用，但我的目标是足以获得当前的工作。任何建议或帮助将不胜感激。拜托，谢谢你。

Answer 1

我会建议其中一个选项 -

指出一个类，而不是一个结构，并重载＆lt;操作员，从而使排序工作顺利。

2.使用按功能排序而不是正常排序：

首先，添加一个比较函数：

bool comparePoint(point* a, point* b) {
  return true if a < b;
}

上面的函数会根据你喜欢的任何规则比较2分，取决于你的代码。

而不是排序使用：

std::sort(b[i].begin(), b[i].end(),comparePoint);

应该适合你。

Bucket按自定义数据结构排序

1 个答案: