Внешняя сортировка

#include <iostream>
#include <iomanip>
#include <vector>
 
using namespace std;
 
const size_t DataLen = 10;
const size_t FileQty = 4;
 
class DataFile {
public:
    DataFile() : m_cursor(0) {}
    void rewind() {
        m_cursor = 0;
    }
    void reset() {
        m_cursor = 0;
        m_data.clear();
    }
    int peek() {
        return m_data[m_cursor];
    }
    int read() {
        return m_data[m_cursor++];
    }
    void write(int num) {
        if (eof()) {
            m_data.push_back(num);
            ++m_cursor;
        }
        else
            m_data[m_cursor++] = num;
    }
    void next() {
        if (!eof())
            ++m_cursor;
    }
    bool eof() {
        return m_cursor == m_data.size();
    }
    void fill() {
        m_data.clear();
        m_data.resize(DataLen);
        for (size_t i = 0; i < DataLen; ++i) {
            m_data[i] = rand() % 1000;
            cout << setw(5) << m_data[i];
        }
        cout << endl;
    }
    friend ostream& operator<<(ostream& os, const DataFile &df) {
        for (size_t i = 0; i < df.m_data.size(); ++i) {
            if (i == df.m_cursor)
                os << "[" << setw(5) << df.m_data[i] << "]";
            else
                os << setw(5) << df.m_data[i];
        }
        return os;
    }
private:
    vector<int> m_data;
    size_t m_cursor;
};
 
bool getNextMinData(int &data, DataFile *files, size_t len) {
    int minData = INT_MAX;
    size_t minDataIdx = 0;
    bool noMoreData = true;
    for (size_t i = 0; i < len; ++i) {
        if (!files[i].eof()) {
            noMoreData = false;
            if (files[i].peek() < minData) {
                minData = files[i].peek();
                minDataIdx = i;
            }
        }
    }
    if (!noMoreData)
        data = files[minDataIdx].read();
    return !noMoreData;
}
 
int main() {
    DataFile df, adf[FileQty];
 
    for (size_t i = 0; i < FileQty; ++i) {
        adf[i].fill();
    }
 
    bool sorted;
    int data, prev;
    size_t counter = 0;
    do {
        ++counter;
        sorted = true;
        prev = INT_MIN;
        df.reset();
        while (getNextMinData(data, adf, FileQty)) {
            df.write(data);
            if (data < prev)
                sorted = false;
            prev = data;
        }
        if (!sorted) {
            for (size_t i = 0; i < FileQty; ++i) {
                adf[i].reset();
            }
            df.rewind();
            size_t idx = 0;
            while (!df.eof()) {
                adf[idx].write(df.read());
                idx = rand() % FileQty;
            }
            for (size_t i = 0; i < FileQty; ++i) {
                adf[i].rewind();
            }
        }
    } while (!sorted);
    cout << "Result: " << df << endl;
    cout << "Steps " << counter << endl;
}