填充向量C ++时发生溢出错误

Question

I need to read 3 text files filled with integers, perform 3 different sort methods (insertion, shell, and quick sort) on it, then put the sorted list into a new file.

My method for doing this was going to be storing the integers in 3 vectors, performing one type of sort on each vector, then writing the vectors to new files. I'm running into a stack overflow error on the second file while my program reads it though, and am starting to reconsider this method. My program gets through the first file just fine (it's about 10 lines), but the second file is 66 KB, and the third one is larger still (1,038 KB).

Is there a better way of going about this or is there some way to fix the overflow error?

Here is the problem code:

/* 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();

Here is my complete code so far: (I have not quite figured out writing to files yet so that part is commented out)

#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

OK, so I assume this is homework; so, here is an attempt to lead you to the answer without just giving it to you.

Note that the stack is used to hold local variables. As a new function is called, additional variables (stack space) has to be allocated. If a function calls itself (called recursion) that can cause the stack to grow very quickly (and cause a stack overflow).

Look for any functions that are calling themselves. How deep the nesting (calls within calls) can get? Your debug info could help you with that, or maybe just think about how the code works. Also look at how many variables your function needs (that will need to be allocated on the stack). Multiply these two (call depth and local memory) and you will an idea of how much stack you will need.

Since you say the problem increases with file size, look at how file size affects the code. Does it affect the call depth or the amount of memory used?

Once you know the cause, you can move onto a solution.