Question

我需要读取3个填充了整数的文本文件，对其执行3种不同的排序方法（插入，shell和快速排序），然后将排序后的列表放入新文件中。

我这样做的方法是将整数存储在3个向量中，对每个向量执行一种排序，然后将向量写入新文件。当我的程序读取它时，我在第二个文件上遇到堆栈溢出错误，并开始重新考虑这个方法。我的程序通过第一个文件很好（大约10行），但第二个文件是66 KB，第三个文件仍然更大（1,038 KB）。

有没有更好的方法来解决这个问题，还是有办法解决溢出错误？

以下是问题代码：

/* read through second file and add to vectors */
file2.open("data2.txt");
file2 >> data;
while (!file2.eof())
{
    v1.push_back(data);
    v2.push_back(data);
    v3.push_back(data);
    file2 >> data;
}
file2.close();

到目前为止，这是我的完整代码:(我还没有想到写入文件，所以部分被注释掉了）

#include "stdafx.h"
#include <time.h>
#include <stdio.h>
#include <dos.h>
#include <iostream>
#include <algorithm>
#include <utility>
#include <fstream>
#include <string>
#include <vector>
#include <iomanip>

/* member function declarations */
using namespace std;
void insertion_sort(vector<int> & v, int length);
void shellsort(vector<int> & v, int n);
int quickSort(vector<int> &, int start, int end);
int partition(vector<int> &, int start, int end, int& swaps);
void swap(int &val1, int &val2);

int main()
{
    /* file stream and clock declarations */
    ifstream file1, file2, file3;
    ofstream I1, I2, I3, S1, S2, S3, Q1, Q2, Q3;

    /* read through first file and add to vectors */
    file1.open("data1.txt");
    vector<int> v1, v2, v3;
    int data;
    file1 >> data;
    while (!file1.eof())
    {
        v1.push_back(data);
        v2.push_back(data);
        v3.push_back(data);
        file1 >> data;
    }
    file1.close(); // end file reading

    /* sort each vector using different methods */
    insertion_sort(v1, v1.size());
    shellsort(v2, v2.size());
    quickSort(v3, 0, v3.size() - 1);

    // write vectors to new files

    /* read through second file and add to vectors */
    file2.open("data2.txt");
    file2 >> data;
    while (!file2.eof())
    {
        v1.push_back(data);
        v2.push_back(data);
        v3.push_back(data);
        file2 >> data;
    }
    file2.close();

    /* sort each vector using different methods */
    insertion_sort(v1, v1.size());
    shellsort(v2, v2.size());
    quickSort(v3, 0, v3.size() - 1);

    // write to file

    /* read through third file and add to vectors */
    file3.open("data3.txt");
    file3 >> data;
    while (!file3.eof())
    {
        v1.push_back(data);
        v2.push_back(data);
        v3.push_back(data);
        file3 >> data;
    }
    file3.close();

    /* sort each vector using different methods */
    insertion_sort(v1, v1.size());
    shellsort(v2, v2.size());
    quickSort(v3, 0, v3.size() - 1);

    // write to file

    cout << endl;
    system("PAUSE");
    return 0;
}

/*insertion sort*/
void insertion_sort(vector<int> &v, int n) {
    int x, y, temp;
    for (x = 1; x < n; x++) {
    y = x;
    while (y > 0 && v[y - 1] > v[y]) {
        temp = v[y];
        v[y] = v[y - 1];
        v[y - 1] = temp;
        y--;
    }//end of while loop
}//end of for loop
}//end of insertion_sort.

 /* shellsort */
void shellsort(vector<int> & v, int n)

{
int k, x, y, temp;
for (k = n / 2; k > 0; k /= 2)
    for (x = k; x < n; x++)
        for (y = x - k; y >= 0 && v[y]>v[y + k]; y -= k) 
        {
            temp = v[y];
            v[y] = v[y + k];
            v[y + k] = temp;
        }
}

/* quicksort function */
int quicksort(vector<int> & v, int s, int last)
{
int swaps = 0;
if (s < last)
{
    int i = partition(v, s, last, swaps);
    swaps += quicksort(v, s, i - 1);
    swaps += quicksort(v, i + 1, last);
}
return swaps;
}

/* partition function for quicksorting */
int partition(vector<int> & v, int start, int end, int& swaps)
{
int pivot = v[end];
int index= start;

for (int i = start; i < end; i++)
{
    if (v[i] <= pivot)
    {

        if (index != i)
        {
            std::swap(v[i], v[index]);
            swaps++;
        }
        index++;
    }
}
if (index != end)
{
    std::swap(v[index], v[end]);
    swaps++;
}
return index;
}

Answer 1

好的，所以我认为这是作业;所以，这是试图引导你回答而不仅仅是给你。

请注意，堆栈用于保存局部变量。在调用新函数时，必须分配其他变量（堆栈空间）。如果函数调用自身（称为递归），可能导致堆栈非常快速地增长（并导致堆栈溢出）。

寻找任何自称的函数。嵌套（调用中的调用）可以达到多深？您的调试信息可以帮助您，或者只是考虑代码的工作原理。还要看一下你的函数需要多少变量（需要在堆栈上分配）。将这两个（调用深度和本地内存）相乘，您就可以了解需要多少堆栈。

由于您说问题随文件大小而增加，请查看文件大小如何影响代码。它是否会影响调用深度或使用的内存量？

了解原因后，您可以转到解决方案。

填充向量C ++时出现溢出错误

1 个答案: