大厂高频经典面试题(65)-大文件排序

1. 题目：

设想你有个20GB的文件，每行有一个字符串，请阐述一下将如何对这个文件进行排序。

2. 解题思路：

对于20GB的大文件排序，由于内存无法一次性加载全部数据，我们需要采用外部排序(External Sorting)算法。

解决问题的思路：

1）分块处理：将大文件分割成多个可以放入内存的小块
2）内部排序：对每个小块在内存中进行排序
3）归并合并：将排序后的小块合并成最终的有序文件

可以考虑的一些优化手段：

1）内存管理：

• 根据可用内存大小确定每个块的大小
• 可以使用缓冲技术减少I/O操作

2）并行处理：

• 分块阶段可以并行处理多个块
• 归并阶段可以使用多线程读取不同文件

3）算法选择：

• 内部排序可以选择快速排序等高效算法
• 归并阶段可以使用优先队列(堆)实现高效合并

具体的执行步骤：

对于20GB的文件，假设内存限制为2GB，可以：

1）将文件分成约10-15个约1.5GB的块
2）对每个块进行内存排序
3）使用k路归并算法合并这些排序后的块
4）如果归并阶段仍然内存不足，可以进行多轮归并

这种方法的时间复杂度为O(nlogn)，与内存排序相同，但增加了I/O开销。

3. 代码完整实现(C++)：

#include <algorithm>
#include <fstream>
#include <iostream>
#include <queue>
#include <string>
#include <vector>

// 定义每个块的最大行数(根据可用内存调整)
const size_t MAX_LINES_PER_CHUNK = 1000000;

// 用于归并排序的最小堆节点
struct HeapNode {
    std::string line;
    std::ifstream* file_ptr;

    bool operator>(const HeapNode& other) const { return line > other.line; }
};

// 分块排序函数
void sort_chunks(const std::string& input_file,
                 std::vector<std::string>& temp_files) {
    std::ifstream in(input_file);
    if (!in) {
        std::cerr << "无法打开输入文件: " << input_file << std::endl;
        return;
    }

    std::vector<std::string> lines;
    lines.reserve(MAX_LINES_PER_CHUNK);
    std::string line;
    size_t chunk_count = 0;

    while (std::getline(in, line)) {
        lines.push_back(line);

        // 当收集到足够行数时，排序并写入临时文件
        if (lines.size() >= MAX_LINES_PER_CHUNK) {
            std::sort(lines.begin(), lines.end());

            std::string temp_filename =
                "temp_" + std::to_string(chunk_count++) + ".txt";
            std::ofstream out(temp_filename);

            for (const auto& l : lines) {
                out << l << "\n";
            }

            temp_files.push_back(temp_filename);
            lines.clear();
        }
    }

    // 处理剩余的行
    if (!lines.empty()) {
        std::sort(lines.begin(), lines.end());

        std::string temp_filename =
            "temp_" + std::to_string(chunk_count++) + ".txt";
        std::ofstream out(temp_filename);

        for (const auto& l : lines) {
            out << l << "\n";
        }

        temp_files.push_back(temp_filename);
    }

    in.close();
}

// 多路归并函数
void merge_files(const std::vector<std::string>& temp_files,
                 const std::string& output_file) {
    std::priority_queue<HeapNode, std::vector<HeapNode>, std::greater<HeapNode>>
        min_heap;
    std::vector<std::ifstream*> file_ptrs;

    // 打开所有临时文件并将第一行放入堆中
    for (const auto& filename : temp_files) {
        std::ifstream* file = new std::ifstream(filename);
        if (!file->is_open()) {
            std::cerr << "无法打开临时文件: " << filename << std::endl;
            continue;
        }

        std::string line;
        if (std::getline(*file, line)) {
            min_heap.push({line, file});
            file_ptrs.push_back(file);
        } else {
            file->close();
            delete file;
        }
    }

    std::ofstream out(output_file);
    if (!out) {
        std::cerr << "无法打开输出文件: " << output_file << std::endl;
        return;
    }

    // 执行多路归并
    while (!min_heap.empty()) {
        HeapNode smallest = min_heap.top();
        min_heap.pop();

        out << smallest.line << "\n";

        // 从取出行的文件中读取下一行
        std::string line;
        if (std::getline(*smallest.file_ptr, line)) {
            min_heap.push({line, smallest.file_ptr});
        } else {
            smallest.file_ptr->close();
            delete smallest.file_ptr;
        }
    }

    out.close();
}

// 清理临时文件
void cleanup_temp_files(const std::vector<std::string>& temp_files) {
    for (const auto& filename : temp_files) {
        std::remove(filename.c_str());
    }
}

// 主排序函数
void external_sort(const std::string& input_file,
                   const std::string& output_file) {
    std::vector<std::string> temp_files;

    // 第一步: 分块排序
    sort_chunks(input_file, temp_files);

    // 第二步: 多路归并
    merge_files(temp_files, output_file);

    // 第三步: 清理临时文件
    cleanup_temp_files(temp_files);
}

int main(int argc, char* argv[]) {
    if (argc != 3) {
        std::cerr << "用法: " << argv[0] << " <输入文件> <输出文件>"
                  << std::endl;
        return 1;
    }

    external_sort(argv[1], argv[2]);
    return 0;
}

4. 代码分析：

解决方案步骤
1）分块排序：将大文件分割成多个可以放入内存的小块，对每个小块进行排序后写入临时文件
2）归并排序：使用多路归并算法将所有已排序的临时文件合并为最终的有序文件

关键点说明
1）内存管理：通过MAX_LINES_PER_CHUNK控制每个块的大小，确保内存足够容纳
2）分块排序：将大文件分割为多个小文件，每个小文件单独排序
3）多路归并：使用最小堆高效合并多个已排序文件
4）资源清理：正确处理文件指针和临时文件

优化建议
1）根据可用内存调整MAX_LINES_PER_CHUNK大小
2）可以使用更高效的内存分配策略
3）对于非常大的文件，可以考虑多线程处理分块排序
4）可以使用更高效的字符串处理方式减少内存使用

5. 运行结果：

文件操作没有输出，可观察排序后的文件内容

感谢您的阅读。原创不易，如您觉得有价值，请点赞，关注。