C++ 对1000个整数的数组进行排序

我在用下面的代码对1000个整数的数组进行排序时遇到了一个问题。对于10个整数，它工作得很好，但是对于1000个整数，它似乎继续工作，我假设这是某种内存泄漏

我以前从未整理过，对我的错误进行一个小小的解释也会有帮助

多谢各位

    class RandomNumbers
    {
    private:

        int intRandomNumbers;

    public:
        int getRandomNumbers();
        void setRandomNumbers(int intPRandomNumbers);
        RandomNumbers(void);
     };

-----------------------------------------------------------
     void printArray(const int intArray[], int intLength);
     int searchFull(const int intArray[], int intLength, int intSearchItem);
     void sortBubble(int intArray[], int intLength);
     int searchLinear(const int intArray[], int intLength, int intSearchItem);
     int searchBinary(const int intArray[], int intLength, int intSearchItem);

--------
     //Getters and setters for RandomNumber class.

     RandomNumbers::RandomNumbers()
     {
     setRandomNumbers(0);
     }

     void RandomNumbers::setRandomNumbers(int intPRandomNumbers)
     {
     intRandomNumbers = intPRandomNumbers;
     }

     int RandomNumbers::getRandomNumbers()
     {
     return intRandomNumbers;
     }

     void printArray(const int intArray[], int intLength) {
    for(int intIndex = 0; intIndex < intLength - 1; intIndex++) {
        cout << intArray[intIndex] << ", ";
    }
    cout << intArray[intLength - 1] << endl;
      }

        int searchFull(const int intArray[], int intLength, int intSearchItem) {
    int intLocation = -1;
    int intCounter = 1;
    for(int intIndex = 0; intIndex < intLength; intIndex++) {
        cerr << "searchFull: " << intCounter++ << endl;
        if(intArray[intIndex] == intSearchItem)
        {
            intLocation = intIndex;
        }
    }
    return intLocation;
        }

        void sortBubble(int intArray[], int intLength){
    int intTemp = 0;
    int intIteration = 0;
    int intIndex = 0;
    for(intIteration = 1; intIteration < intLength; intIteration++) {
        for(intIndex = 0; intIndex < intLength - intIteration; intIndex++) {
            if(intArray[intIndex] > intArray[intIndex + 1]) {
                intTemp = intArray[intIndex];
                intArray[intIndex] = intArray[intIndex + 1];
                intArray[intIndex + 1] = intTemp;
            }
            printArray(intArray,intLength);
            }
           }
           }

           int searchLinear(const int intArray[], int intLength, int intSearchItem) {
       int intLocation = -1;
       int intCounter = 1;
       for(int intIndex = 0; intIndex < intLength && intSearchItem >= intArray[intIndex];                 intIndex++)   intIndex++) 
   {
        cerr << "searchLinear: " << intCounter++ << endl;
        if(intArray[intIndex] == intSearchItem)
        {
            intLocation = intIndex;
        }
    }
    return intLocation;
}

int searchBinary(const int intArray[], int intLength, int intSearchItem) {
    int intFirstIndex = 0;
    int intLastIndex = intLength - 1;
    int intMiddle = 0;
    bool boolFound = false;

    while(intFirstIndex <= intLastIndex && !boolFound) {
        intMiddle = (intFirstIndex + intLastIndex) / 2;
        if(intArray[intMiddle] == intSearchItem) {
            boolFound = true;
        } else if(intArray[intMiddle] > intSearchItem) {
            intLastIndex = intMiddle - 1;
        } else {
            intFirstIndex = intMiddle + 1;
        }
        cerr << "searchBinary: " << intFirstIndex << ", " << intMiddle << ", " << intLastIndex << endl;
    }

    if(boolFound) {
        return intMiddle;
    } else {
        return -1;
    }
}


    int main() {

    srand (time(NULL));

    ofstream myfile;
    myfile.open ("RandomNumber.txt");

    if (myfile.is_open())
    {
        for (int i = 0; i < 1000; ++i)
        {
            int RandomNumbers = rand() % 1000 + 1;
            myfile << RandomNumbers << "\n";
        }
    }

       myfile.close();

    int array_size = 1000;
    int * array = new int[array_size];
    int position = 0;

    ifstream fin("RandomNumber.txt");

    if(fin.is_open())
    {
        cout << "File opened!!! Loading array. ";

        while(!fin.eof() && position < array_size)
        {
            fin >> array[position];
            position++;
        }

        cout << "Displaying array..." << endl <<endl;

        for(int intIndex = 0; intIndex < array_size; intIndex++)
        {
            cout << array[intIndex] << endl;
        }
        fin.close();
    }
    else
    {
        cout<< "File could not be opened." << endl;
    }



    cout << searchFull(array, array_size, 43) << endl;
    cout << searchLinear(array, array_size, 43) << endl; //Incorrect not sorted
    cout << searchFull(array, array_size, 5) << endl;
    cout << searchLinear(array, array_size, 5) << endl; //Incorrect not sorted

    sortBubble(array, array_size);

    cout << searchFull(array, array_size, 43) << endl;
    cout << searchLinear(array, array_size, 43) << endl;
    cout << searchBinary(array, array_size, 43) << endl;
    cout << searchFull(array, array_size, 5) << endl;
    cout << searchLinear(array, array_size, 5) << endl;
    cout << searchBinary(array, array_size, 5) << endl;

    system("PAUSE");

    return 0;
        };

类随机数
{
私人：
整数；
公众：
int getRandomNumbers（）；
void setRandomNumbers（int intPRandomNumbers）；
随机数（空）；
};
-----------------------------------------------------------
void printary（const int intArray[]，int intLength）；
int searchFull（const int intArray[]，int intLength，int intSearchItem）；
无效排序气泡（int intArray[]，int intLength）；
int searchLinear（const int intArray[]，int intLength，int intSearchItem）；
int searchBinary（const int intArray[]，int intLength，int intSearchItem）；
--------
//RandomNumber类的getter和setter。
RandomNumbers:：RandomNumbers（）
{
设置随机数（0）；
}
void RandomNumbers:：setRandomNumbers（int intPRandomNumbers）
{
intRandomNumbers=intPRandomNumbers；
}
int RandomNumbers:：getRandomNumbers（）
{
返回数字；
}
void printary（常量int intArray[]，int intLength）{
对于（intIndex=0；intIndex而（！fin.eof（）

是一个错误。在读取最后一个值之后，但在发生

eof（）

之前会发生什么？（回答：您将复制最后一个条目两次）。通过执行以下操作修复它：

while ( position < array_size && fin >> array[position] )
    position++;

while（位置>数组[位置]）
位置++；

另外，您应该使用

位置

作为计数器来显示和排序，而不是

数组大小

---

可能您的

sortbuble

函数有一个bug，或者可能只是运行了很长时间。如果您尝试使用100个数字，会发生什么情况？您可以发布它的代码吗？

其他函数在哪里？它们看起来像什么？我刚刚编辑添加了所有代码。我提取了您的排序例程，而没有调用

printary

d在调试构建中，它在1ms内对1000个随机整数进行排序，在190ms内对10000个随机整数进行排序。我没有检查整个数组，但打印了前10个和后10个，它们似乎是有序的。注释掉

printary

调用，然后重试。如果仍然存在问题，请使用调试器，当它看起来卡住时，请中断并查看其中。对printArray进行注释就达到了目的。while循环中的更改仅适用于100个整数，但对于1000个整数，它似乎不会停止，除非它只是需要那么长的时间。尝试将数字从100逐渐增加到1000，并观察每次运行所需的时间