Lab1.cpp

#include <iostream>
#include <string>
#include <vector>
#include <fstream>
#include <sstream>
#include <dirent.h>
#include <sys/stat.h>
#include <chrono>
#include <algorithm>

struct Child {
    int year;
    int groupNumber;
    std::string fullName;
    std::string birthDate;
    int shiftNumber;

    bool operator<(const Child& other) const {
        if (year != other.year)
            return year < other.year;
        if (groupNumber != other.groupNumber)
            return groupNumber < other.groupNumber;
        if (shiftNumber != other.shiftNumber)
            return shiftNumber < other.shiftNumber;
        return fullName < other.fullName;
    }

    bool operator>(const Child& other) const {
        return other < *this;
    }

    bool operator<=(const Child& other) const {
        return !(other < *this);
    }

    bool operator>=(const Child& other) const {
        return !(*this < other);
    }
};

// Функция для чтения строки из CSV файла и преобразования в объект child
Child parseCSVLine(const std::string& line) {
    std::stringstream ss(line);
    std::string item;
    Child child;

    std::getline(ss, item, ',');
    child.year = std::stoi(item);
    std::getline(ss, item, ',');
    child.groupNumber = std::stoi(item);
    std::getline(ss, child.fullName, ',');
    std::getline(ss, child.birthDate, ',');
    std::getline(ss, item, ',');
    child.shiftNumber = std::stoi(item);

    return child;
}

// Функция для чтения из файла CSV и создания вектора объектов child
std::vector<Child> readChildrenFromFile(const std::string& filename) {
    std::vector<Child> children;
    std::ifstream file(filename);
    std::string line;
    while (std::getline(file, line)) {
        if (!line.empty()) {
            children.push_back(parseCSVLine(line));
        }
    }
    return children;
}

// Функция для записи в файл CSV вектора объектов child
void writeChildrenToFile(const std::string& filename, const std::vector<Child>& children) {
    std::ofstream file(filename);
    for (const auto& child : children) {
        file << child.year << ","
             << child.groupNumber << ","
             << child.fullName << ","
             << child.birthDate << ","
             << child.shiftNumber << "\n";
    }
}

// Функция сортировки выбором
void selectionSort(std::vector<Child>& arr) {
    size_t n = arr.size();
    for (size_t i = 0; i < n - 1; ++i) {
        size_t minIdx = i;
        for (size_t j = i + 1; j < n; ++j) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        std::swap(arr[i], arr[minIdx]);
    }
}

// Функция сортировки простыми вставками
void insertionSort(std::vector<Child>& arr) {
    size_t n = arr.size();
    for (size_t i = 1; i < n; ++i) {
        Child key = arr[i];
        int j = i - 1;
        while (j >= 0 && key < arr[j]) {
            arr[j + 1] = arr[j];
            --j;
        }
        arr[j + 1] = key;
    }
}

// Функция шейкер-сортировки
void shakerSort(std::vector<Child>& arr) {
    size_t left = 0;
    size_t right = arr.size() - 1;
    while (left < right) {
        for (size_t i = left; i < right; ++i) {
            if (arr[i] > arr[i + 1]) {
                std::swap(arr[i], arr[i + 1]);
            }
        }
        --right;
        for (size_t i = right; i > left; --i) {
            if (arr[i] < arr[i - 1]) {
                std::swap(arr[i], arr[i - 1]);
            }
        }
        ++left;
    }
}

// Функция для измерение времени
template <typename Func>
long long measureSortTime(std::vector<Child>& children, Func sortFunc) {
    auto start = std::chrono::high_resolution_clock::now();
    sortFunc(children);
    auto end = std::chrono::high_resolution_clock::now();
    return std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
}

// Функция для записи в файл CSV времени, затраченного на сортировку 
void writeTimesToFile(const std::string& filename, const std::vector<std::pair<std::string, long long>>& times) {
    std::ofstream file(filename);
    for (const auto& [name, time] : times) {
        file << name << "," << time << "\n";
    }
}

// Функция для проверки того, что строка заканчивается на ".csv"
bool hasCSVExtension(const std::string& filename) {
    return filename.size() >= 4 &&
           filename.substr(filename.size() - 4) == ".csv";
}

// Функция для создания директории (если она не существует)
void createDirectoryIfNotExists(const std::string& dirname) {
    struct stat st{};
    if (stat(dirname.c_str(), &st) != 0) {
        mkdir(dirname.c_str(), 0755);
    }
}

int main() {
    std::string inputDir = "children-unsorted";
    std::string outputBase = "children-sorted";

    createDirectoryIfNotExists(outputBase);
    createDirectoryIfNotExists(outputBase + "/times");

    DIR* dir = opendir(inputDir.c_str());
    if (!dir) {
        std::cerr << "Не удалось открыть директорию: " << inputDir << "\n";
        return 1;
    }

    dirent* entry;
    while ((entry = readdir(dir)) != nullptr) {
        std::string filename = entry->d_name;
        
        // Проверяем, что entry это файл, и что он имеет расширение CSV
        if (entry->d_type == DT_REG && hasCSVExtension(filename)) {
            std::string inputPath = inputDir + "/" + filename;
            std::vector<Child> original = readChildrenFromFile(inputPath);

            std::vector<std::pair<std::string, long long>> times;

            // Создаем вектор пар вида <строка, функция>, в котором лежат наши сортировки
            std::vector<std::pair<std::string, void(*)(std::vector<Child>&)>> sorters = {
                {"SelectionSort", selectionSort},
                {"InsertionSort", insertionSort},
                {"ShakerSort", shakerSort},
                {"StdSort", [](std::vector<Child>& d) { std::sort(d.begin(), d.end()); }}
            };

            for (const auto& [sortName, sortFunc] : sorters) {
                std::vector<Child> sorted = original;

                // Сортируем
                long long time = measureSortTime(sorted, sortFunc);

                std::string sortDir = outputBase + "/" + sortName;
                createDirectoryIfNotExists(sortDir);

                std::string outputPath = sortDir + "/" + filename;
                writeChildrenToFile(outputPath, sorted);

                times.emplace_back(sortName, time);
            }

            // Сохраняем файл с результатами времени
            std::string timeFile = outputBase + "/times/" + filename;
            writeTimesToFile(timeFile, times);
        }
    }

    closedir(dir);
    return 0;
}