Внешняя сортировка прямым слиянием: ошибка "Text file busy"

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
// Функция для обмена элементов
void swap(long *a, long *b) {
    long temp = *a;
    *a = *b;
    *b = temp;
}
// Функция для быстрой сортировки
void qs(long *arr, int left, int right, int ascending) {
    if (left >= right) return;
    int i = left, j = right;
    long pivot = arr[left + (right - left) / 2];
    while (i <= j) {
        if (ascending) {
            while (arr[i] < pivot) i++;
            while (arr[j] > pivot) j--;
        } else {
            while (arr[i] > pivot) i++;
            while (arr[j] < pivot) j--;
        }
        if (i <= j) {
            swap(&arr[i], &arr[j]);
            i++;
            j--;
        }
    }
    if (left < j) qs(arr, left, j, ascending);
    if (i < right) qs(arr, i, right, ascending);
}
// Функция для вывода справки
void print_help() {
    printf("Использование: external_sort -i input_file [-l memory_limit_MB] [-d (up|down)]\n");
    printf("Параметры:\n");
    printf("\t-i input_file\t\tИмя входного файла (обязательно)\n");
    printf("\t-d (up|down)\t\tНаправление сортировки (по умолчанию up)\n");
    printf("\t-l memory_limit_MB\tЛимит памяти в мегабайтах\n");
    printf("\t-h\t\t\tПечать этой справки\n");
}
// Функция для парсинга аргументов командной строки
int parse_arguments(int argc, char *argv[], char **input_filename, int *ascending, size_t *memory_limit) {
    for (int i = 1; i < argc; ++i) {
        if (strcmp(argv[i], "-i") == 0) {
            if (i + 1 < argc) {
                *input_filename = argv[++i];
            } else {
                fprintf(stderr, "Ошибка: Не указано имя входного файла.\n");
                print_help();
                return 0;
            }
        } else if (strcmp(argv[i], "-d") == 0) {
            if (i + 1 < argc) {
                if (strcmp(argv[i + 1], "up") == 0) {
                    *ascending = 1;
                } else if (strcmp(argv[i + 1], "down") == 0) {
                    *ascending = 0;
                } else {
                    fprintf(stderr, "Ошибка: Некорректное значение направления сортировки.\n");
                    print_help();
 
                    return 0;
                }
                i++;
            } else {
                fprintf(stderr, "Ошибка: Не указано значение направления сортировки.\n");
                print_help();
                return 0;
            }
        } else if (strcmp(argv[i], "-l") == 0) {
            if (i + 1 < argc) {
                char *endptr;
                long val = strtol(argv[++i], &endptr, 10);
                if (*endptr == '\0' && val > 0) {
                    *memory_limit = val * 1024 * 1024; // Перевод мегабайт в байты
                } else {
                    fprintf(stderr, "Ошибка: Некорректное значение лимита памяти.\n");
                    print_help();
 
                    return 0;
                }
            } else {
                fprintf(stderr, "Ошибка: Не указано значение лимита памяти.\n");
                print_help();
 
                return 0;
            }
        } else if (strcmp(argv[i], "-h") == 0) {
            exit(EXIT_SUCCESS);
        } else {
            fprintf(stderr, "Ошибка: Неизвестный параметр: %s\n", argv[i]);
            print_help();
            return 0;
        }
    }
    if (*input_filename == NULL) {
        fprintf(stderr, "Ошибка: Имя входного файла обязательно.\n");
        print_help();
        return 0;
    }
    return 1;
}
// Функция для создания бинарного файла с случайными числами
void create_binary_file(const char *filename, size_t num_elements) {
    printf("Создаём файл %s с %zu элементами.\n", filename, num_elements);
    FILE *file = fopen(filename, "wb");
    if (!file) {
        perror("Ошибка открытия файла для записи");
        exit(EXIT_FAILURE);
    }
    srand(time(NULL));
    for (size_t i = 0; i < num_elements; ++i) {
        long number = (long)(rand() % 1000000 - 500000); // Диапазон: -500000 до 499999
        fwrite(&number, sizeof(long), 1, file);
    }
    fclose(file);
    printf("Файл %s успешно создан с %zu элементами.\n", filename, num_elements);
}
// Функция для чтения и вывода содержимого бинарного файла
void read_binary_file(const char* filename) {
    FILE* file = fopen(filename, "rb");
    if (!file) {
        perror("Ошибка открытия файла для чтения");
        return;
    }
    long number;
    while (fread(&number, sizeof(long), 1, file) == 1) {
        printf("%ld ", number);
    }
    fclose(file);
    printf("\n");
}
// Функция для разделения исходного файла на отсортированные run'ы
size_t split_into_runs(const char *input_filename, const char *temp1_filename, size_t run_size, int ascending) {
    printf("Разделяем файл %s на run'ы размером %zu.\n", input_filename, run_size);
    FILE *input = fopen(input_filename, "rb");
    if (!input) {
        perror("Ошибка открытия входного файла для разделения");
        exit(EXIT_FAILURE);
    }
    FILE *temp1 = fopen(temp1_filename, "wb");
    if (!temp1) {
        perror("Ошибка открытия временного файла temp1 для run'ов");
        fclose(input);
        exit(EXIT_FAILURE);
    }
    long *buffer = (long *)malloc(run_size * sizeof(long));
    if (!buffer) {
        perror("Ошибка выделения памяти для разделения run'ов");
        fclose(input);
        fclose(temp1);
        exit(EXIT_FAILURE);
    }
    size_t count;
    size_t run_count = 0;
    while ((count = fread(buffer, sizeof(long), run_size, input)) > 0) {
        // Сортируем текущий run
        qs(buffer, 0, count - 1, ascending);
        // Записываем отсортированный run в temp1.bin
        fwrite(buffer, sizeof(long), count, temp1);
        run_count++;
    }
    free(buffer);
    fclose(input);
    fclose(temp1);
    return run_count;
}
// Функция для слияния двух run'ов из temp1.bin в temp2.bin
size_t merge_runs_pass(const char *temp1_filename, const char *temp2_filename, size_t run_size, int ascending) {
    printf("Сливаем run'ы из %s в %s с размером run'а %zu.\n", temp1_filename, temp2_filename, run_size);
    FILE *temp1 = fopen(temp1_filename, "rb");
    if (!temp1) {
        perror("Ошибка открытия temp1.bin для чтения");
        exit(EXIT_FAILURE);
    }
    FILE *temp2 = fopen(temp2_filename, "wb");
    if (!temp2) {
        perror("Ошибка открытия temp2.bin для записи");
        fclose(temp1);
        exit(EXIT_FAILURE);
    }
    long *buffer1 = (long *)malloc(run_size * sizeof(long));
    long *buffer2 = (long *)malloc(run_size * sizeof(long));
    if (!buffer1 || !buffer2) {
        perror("Ошибка выделения памяти для слияния");
        fclose(temp1);
        fclose(temp2);
        exit(EXIT_FAILURE);
    }
    size_t count1, count2;
    size_t merged_runs = 0;
    while (1) {
        // Читаем первый run
        count1 = fread(buffer1, sizeof(long), run_size, temp1);
        if (count1 == 0) {
            break; // Нет больше run'ов
        }
        // Читаем второй run
        count2 = fread(buffer2, sizeof(long), run_size, temp1);
        // Если нет второго run'а, записываем первый run как есть
        if (count2 == 0) {
            fwrite(buffer1, sizeof(long), count1, temp2);
            merged_runs++;
            // Удалён вывод содержимого run'а
            break;
        }
        // Сливаем два run'а и записываем в temp2.bin
        size_t i = 0, j = 0;
        while (i < count1 && j < count2) {
            if ((buffer1[i] <= buffer2[j] && ascending) ||
                (buffer1[i] >= buffer2[j] && !ascending)) {
                fwrite(&buffer1[i++], sizeof(long), 1, temp2);
            }
            else {
                fwrite(&buffer2[j++], sizeof(long), 1, temp2);
            }
        }
        // Записываем оставшиеся элементы из первого run
        while (i < count1) {
            fwrite(&buffer1[i++], sizeof(long), 1, temp2);
        }
        // Записываем оставшиеся элементы из второго run
        while (j < count2) {
            fwrite(&buffer2[j++], sizeof(long), 1, temp2);
        }
        merged_runs++;
        // Удалён вывод содержимого слитого run'а
    }
    free(buffer1);
    free(buffer2);
    fclose(temp1);
    fclose(temp2);
    return merged_runs;
}
// Основная функция внешней сортировки с прямым слиянием
int external_merge_sort_direct(const char *input_filename, size_t num_elements, int ascending, size_t memory_limit) {
    // Вычисляем размер run'а на основе лимита памяти
    // Используем половину памяти для одного run'а, чтобы можно было считывать два run'а одновременно при слиянии
    size_t run_size = memory_limit / (2 * sizeof(long));
    if (run_size == 0) {
        fprintf(stderr, "Ошибка: Лимит памяти слишком мал для выполнения сортировки.\n");
        return -1;
    }
    printf("Начинаем внешнюю сортировку с run_size = %zu.\n", run_size);
    char temp1_filename[256];
    char temp2_filename[256];
    sprintf(temp1_filename, "temp1_%d.bin", rand()%1000000);
    sprintf(temp2_filename, "temp2_%d.bin", rand()%1000000);
    printf("Используем временные файлы: %s и %s\n", temp1_filename, temp2_filename);
    size_t run_count = split_into_runs(input_filename, temp1_filename, run_size, ascending);
    printf("Создано %zu run'ов при начальном разделении.\n", run_count);
    if (run_count <= 1) {
        // Если только один run, переименовываем temp1.bin в исходный файл
        if (run_count == 1) {
            printf("Создан один run, переименовываем %s в %s.\n", temp1_filename, input_filename);
            if (remove(input_filename) != 0) {
                perror("Ошибка при удалении исходного файла");
                return -1;
            }
            if (rename(temp1_filename, input_filename) != 0) {
                perror("Ошибка при переименовании temp1.bin в исходный файл");
                return -1;
            }
            printf("Сортировка завершена за один проход.\n");
        }
        else {
            // Нет элементов для сортировки
            printf("Файл пуст. Сортировка не требуется.\n");
            remove(temp1_filename);
        }
        return 0;
    }
    // Многократное слияние run'ов
    int pass = 1;
    while (run_count > 1) {
        printf("Проход %d: слияние run'ов размером %zu.\n", pass, run_size);
        size_t merged_runs = merge_runs_pass(temp1_filename, temp2_filename, run_size, ascending);
        printf("Проход %d завершён: слито %zu run'ов.\n", pass, merged_runs);
        // Переименовываем temp2.bin в temp1.bin для следующего прохода
        printf("Переименовываем %s в %s.\n", temp2_filename, temp1_filename);
        if (remove(temp1_filename) != 0) {
            perror("Ошибка при удалении temp1.bin");
            return -1;
        }
        if (rename(temp2_filename, temp1_filename) != 0) {
            perror("Ошибка при переименовании temp2.bin в temp1.bin");
            return -1;
        }
        // Обновляем параметры для следующего прохода
        run_size *= 2;
        run_count = merged_runs;
        printf("Новый run_size = %zu, количество run'ов = %zu.\n", run_size, run_count);
        pass++;
    }
    printf("Переименовываем %s в %s.\n", temp1_filename, input_filename);
    if (remove(input_filename) != 0) {
        perror("Ошибка при удалении исходного файла");
        return -1;
    }
    if (rename(temp1_filename, input_filename) != 0) {
        perror("Ошибка при переименовании temp1.bin в исходный файл");
        return -1;
    }
    remove(temp2_filename);
    printf("Сортировка завершена за %d проходов.\n", pass - 1);
    return 0;
}
// Основная функция программы
int main(int argc, char* argv[]) {
    char *file_name_a = NULL;
    int ascending = 1;
    size_t memory_limit = 10 * 1024 * 1024; // По умолчанию 10 МБ
    if (!parse_arguments(argc, argv, &file_name_a, &ascending, &memory_limit)) {
        print_help();
        return EXIT_FAILURE;
    }
    size_t num_elements;
    printf("Введите количество элементов для сортировки: ");
    if (scanf("%zu", &num_elements) != 1 || num_elements <= 0) {
        printf("Ошибка ввода числа элементов.\n");
        return 1;
    }
    create_binary_file(file_name_a, num_elements);
    printf("Содержимое входного файла до сортировки:\n");
    read_binary_file(file_name_a);
    if (external_merge_sort_direct(file_name_a, num_elements, ascending, memory_limit) != 0) {
        fprintf(stderr, "Ошибка во время сортировки.\n");
        return EXIT_FAILURE;
    }
    printf("Содержимое файла после сортировки:\n");
    read_binary_file(file_name_a);
    return 0;
}

Ошибка при удалении temp1.bin: Text file busy
Ошибка во время сортировки

Ошибка при переименовании temp2.bin в temp1.bin: Text file busy
Ошибка во время сортировки.