C++ 当输入有大量数据时，for循环进入超长时间（20+；分钟）迭代

我在这里有两个功能：

int getHighestVal(int n, vector<double> arr) {
    int highest = 0;
    for (int i = 0; i < n; i++) {
        if (arr[i] > arr[highest])
            highest = i;
    }

    return highest;
}

intgethighestval（intn，向量arr）{
int最高=0；
对于（int i=0；iarr[highest]）
最高=i；
}
回报最高；
}

向量getRank（int n，向量arr）{ 向量秩（n）； 使用的向量（n）； 对于（int i=0；icout我认为for循环应该小于n in

for（int I=1；I我认为for循环应该小于n in
for（int I=1；I假设您希望始终为整个数组创建秩，那么第一个参数
n
是冗余的–您可以从
arr.size（）获得相同的信息
。冗余可能是错误的来源，因此在这种情况下，请删除参数：

std::vector<size_t> getRank(std::vector<double> const& arr);

不过，这仍然是一个O（n²）算法。不过，您可以更好地使用O（n*log（n））：

std:：vector getRank（std:：vector const&arr）
{
std：：向量值；
values.reserve（arr.size（））；//避免重新分配
尺寸指数=0；
用于（自动d:arr）
值。向后放置（d，index++）；
//将数组复制到索引成对的第二个数组中：O（n）
排序
(
values.begin（）、values.end（），
标准：：更大
);
//std:：pair已经有一个字典运算符假设您希望始终为整个数组创建秩，那么第一个参数
n
是冗余的–您可以从
arr.size（）
获得相同的信息。冗余可能是错误的来源，因此在这种情况下，最好删除该参数：

std::vector<size_t> getRank(std::vector<double> const& arr);

不过，这仍然是一个O（n²）算法。不过，您可以更好地使用O（n*log（n））：

std:：vector getRank（std:：vector const&arr）
{
std：：向量值；
values.reserve（arr.size（））；//避免重新分配
尺寸指数=0；
用于（自动d:arr）
值。向后放置（d，index++）；
//将数组复制到索引成对的第二个数组中：O（n）
排序
(
values.begin（）、values.end（），
标准：：更大
);
//std:：pair已经有了一个字典运算符，因为arr是不变的，getHighestVal返回的值总是相同的，所以只需要调用该函数一次，而不是在循环中执行

使用const reference可以使代码更高效，但也更清晰，因为它可以立即指示arr没有改变，而不必查看主体内部

因此，只需稍作更改即可节省时间（如除以5）：

int getHighestVal(int n, const vector<double> & arr) {
    int highest = 0;
    for (int i = 1; i < n; i++) {
        if (arr[i] > arr[highest])
            highest = i;
    }

    return highest;
}

vector<int> getRank(int n, const vector<double> & arr) {
    vector<int> rank(n);
    vector<bool> used(n, false);
    int lowestVal = getHighestVal(n, arr);
    cout << "Pass waypoint lowestVal" << endl;

    for (int i = 1; i <= n; i++) { //LOOP HERE WENT INFINITE ITERATION
        int lo = lowestVal;
        for (int j = 0; j < n; j++) {
            if (used[j] == false && arr[lo] > arr[j])
                lo = j;
        }

        rank[lo] = i;
        used[lo] = true;
        //cout << "\rPass waypoint RANKING Loop2: " << n;
    }
    cout << "Pass waypoint RANKING" << endl;

    return rank;
}

int getHighestVal（int n、常量向量和arr）{
int最高=0；
对于（int i=1；iarr[highest]）
最高=i；
}
回报最高；
}
向量getRank（整数n、常量向量和arr）{
向量秩（n）；
使用的向量（n，假）；
int lowestVal=getHighestVal（n，arr）；
cout因为arr是不变的，getHighestVal返回的值总是相同的，所以只需要调用该函数一次，而不是在循环中执行

使用const reference可以使代码更高效，但也更清晰，因为它可以立即指示arr没有改变，而不必查看主体内部

因此，只需稍作更改即可节省时间（如除以5）：

int getHighestVal(int n, const vector<double> & arr) {
    int highest = 0;
    for (int i = 1; i < n; i++) {
        if (arr[i] > arr[highest])
            highest = i;
    }

    return highest;
}

vector<int> getRank(int n, const vector<double> & arr) {
    vector<int> rank(n);
    vector<bool> used(n, false);
    int lowestVal = getHighestVal(n, arr);
    cout << "Pass waypoint lowestVal" << endl;

    for (int i = 1; i <= n; i++) { //LOOP HERE WENT INFINITE ITERATION
        int lo = lowestVal;
        for (int j = 0; j < n; j++) {
            if (used[j] == false && arr[lo] > arr[j])
                lo = j;
        }

        rank[lo] = i;
        used[lo] = true;
        //cout << "\rPass waypoint RANKING Loop2: " << n;
    }
    cout << "Pass waypoint RANKING" << endl;

    return rank;
}

int getHighestVal（int n、常量向量和arr）{
int最高=0；
对于（int i=1；iarr[highest]）
最高=i；
}
回报最高；
}
向量getRank（整数n、常量向量和arr）{
向量秩（n）；
使用的向量（n，假）；
int lowestVal=getHighestVal（n，arr）；
我可以稍后再试一次。现在在
const ref
上，完成16200 x 2的双打需要20分钟。非常可笑。警告，getHighestVal返回一个索引，而不是来自array@bruno：与
std:：max_元素
的作用相同–不过，它是以迭代器的形式出现的；我们通过减去
arr.begin（）得到的索引
from。可能我读错了，没有看到你减去arr.begin（）稍后我会尝试。现在在
const ref
上，完成16200 x 2的双打需要20分钟。非常可笑。警告，getHighestVal返回索引，而不是来自array@bruno：与
std:：max_元素
的作用相同–不过，它是以迭代器的形式出现的；我们通过减去
arr.begin（）得到的索引
from。可能我读错了，没有看到你减去arr。begin（）注释不用于扩展讨论；此对话已被删除。注释不用于扩展讨论；此对话已被删除。
int getHighestVal(int n, const vector<double> & arr) {
    int highest = 0;
    for (int i = 1; i < n; i++) {
        if (arr[i] > arr[highest])
            highest = i;
    }

    return highest;
}

vector<int> getRank(int n, const vector<double> & arr) {
    vector<int> rank(n);
    vector<bool> used(n, false);
    int lowestVal = getHighestVal(n, arr);
    cout << "Pass waypoint lowestVal" << endl;

    for (int i = 1; i <= n; i++) { //LOOP HERE WENT INFINITE ITERATION
        int lo = lowestVal;
        for (int j = 0; j < n; j++) {
            if (used[j] == false && arr[lo] > arr[j])
                lo = j;
        }

        rank[lo] = i;
        used[lo] = true;
        //cout << "\rPass waypoint RANKING Loop2: " << n;
    }
    cout << "Pass waypoint RANKING" << endl;

    return rank;
}