C++ opElements[N-1]这对于后续问题“从1000000个列表中找出最大的10000个”来说不是很好@Steve true，如果它变成了一个任意的“从y中找出前x个”问题，那么我的解决方案就不太合适，我会选择像你这样做。我特别想回答Bdesign的直

---

---

opElements[N-1]

这对于后续问题“从1000000个列表中找出最大的10000个”来说不是很好@Steve true，如果它变成了一个任意的“从y中找出前x个”问题，那么我的解决方案就不太合适，我会选择像你这样做。我特别想回答Bdesign的直接问题，即从（我假设的）有限的列表中选择一个非常小的子集，而不必经过他模糊的双重排序。问题本身并不要求这样做，对于这种后续行动，当然你会以不同的方式来处理。目前，没有关于内存或速度要求的确切细节。这只是一个评论，而不是反对票@Jerry的解决方案是最好的通用实现，而你的解决方案是最好的就地实现。@Steve，我认为这是当之无愧的评论。我的解决方案跳到了我的头上，因为它非常适合提问者的范围，并且克服了他使用古老编译器的局限性。我不会说我的答案是最好的，我从来没有这样做，因为我不能肯定其他人会出现，并提出更好的建议。最好的STL，也是最好的启发式非STL解决方案+ 1，因为它使用标准的C++ LIBS，但对于提问者，我不认为他可以使用它，因为Borland 3.1早，我想90年代初。。。Turbo C++的好时光（1版本更老）：NEVETS1219：有Turbo C++ 1，Borland C++ 2，Borland C++ 3，然后Borland C++ 3.1。为了解释一条老式的代码，Borland C++ 3.1比它的前辈和后继者有了巨大的进步。我最初学习了PHP，因为我是一个本地的Web开发者，现在在Borland C++上学习C++是一个真正的痛苦：（你可能想写一条注释，说明这只需要正的非零整数。如果允许使用零和负数，则需要额外的逻辑。此外，你还需要将cout从循环中去掉。为什么要将cout标记为冒泡排序？出于好奇，这是什么样的考试？即使在大学，我们也可以访问当前的编译器。一个在这种古老的技术中学习（通过考试）听起来不是很有用我真的很好奇你为什么要做两次排序？我编辑了这篇文章，这样你就可以看到我为什么用冒泡排序。是的，这是一次大学考试，但罗马尼亚仍然在考试中使用纸张而不是个人电脑。现在我在阅读完回答后思考这个问题，对它进行两次排序是没有意义的。部分排序是最容易编码的，但是第n个元素然后一个线性划分保持线性时间，而“x/y”问题的部分_排序是ω（ylogx）时间。@Neil G这两种方法在容器中的元素数量上都是线性的，以获得所需的特定数量的最高元素。您是对的，

partial_sort

在许多情况下可以有稍高的

C

，但实际上这可能并不重要。partial sort必须对x元素进行排序，因此它有addIX log（x）因子。考虑x＝y的极限情况，部分排序在xLogx时间运行，其中nthyEngy解决方案在x时间内运行。但是，我以前错了，部分排序解决方案的运行时可能是Ω（y+xLogx），所以如果x与y无关，则它与第n个元素解决方案相同。

#include<fstream.h>
#include<conio.h>

int v[1000], n;
ifstream f("bac.in");

void citire();
void afisare_a();
int ultima_cifra(int nr);
void sortare(int asc);

void main() {
    clrscr();
    citire();
    sortare(2);
    afisare_a();
    getch();
}

void citire() {
    f>>n;
    for(int i = 0; i < n; i++)
        f>>v[i];
        f.close();
}                            

void afisare_a() {
    for(int i = 0;i < n; i++)
            if(ultima_cifra(v[i]) == 5)
            cout<<v[i]<<" ";
}

int ultima_cifra(int nr) {
    return nr - 10 * ( nr / 10 );
}

void sortare(int asc) {
    int aux, s;
        if(asc == 1)
        do {
            s = 0;
            for(int i = 0; i < n-1; i++)
                if(v[i] > v[i+1]) {
                    aux = v[i];
                    v[i] = v[i+1];
                    v[i+1] = aux;
                    s = 1;
                }
        } while( s == 1);
    else
        do {
            s = 0;
            for(int i = 0; i < n-1; i++)
                if(v[i] < v[i+1]) {
                    aux = v[i];
                    v[i] = v[i+1];
                    v[i+1] = v[i];
                                        s = 1;
                }
                } while(s == 1);
}

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> nums;
    nums.push_back(1);
    nums.push_back(6);
    nums.push_back(2);
    nums.push_back(5);
    nums.push_back(3);
    nums.push_back(7);
    nums.push_back(4);

    int first = 0;
    int second = 0;
    int third = 0;

    for (int i = 0; i < nums.size(); i++)
    {
        if (nums.at(i) > first)
        {
            third = second;
            second = first;            
            first = nums.at(i);
        }
        else if (nums.at(i) > second)
        {
            third = second;
            second = nums.at(i);
        }
        else if (nums.at(i) > third)
        {
            third = nums.at(i);
        }
        std::cout << "1st: " << first << " 2nd: " << second << " 3rd: " << third << std::endl;

    }

    return 0;
}

std::vector<int>::iterator p = std::max_element(vec.begin(), vec.end());
int x = *p;
*p = std::numeric_limits<int>::min();

std::vector<int>::iterator q = std::max_element(vec.begin(), vec.end());
int y = *q;
*q = std::numeric_limits<int>::min();

int z = *std::max_element(vec.begin(), vec.end());

*q = y;   // restore original value
*p = x;   // restore original value