【不看会后悔系列】排序之——文件归并【史上最全详解】~

于 2024-10-02 18:34:02 发布
阅读量824 收藏 21
点赞数 35
分类专栏： 排序 数据结构与算法 C语言 文章标签： 算法 排序算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jdxxwu/article/details/142624871
版权

文章目录

前言

学习了归并排序了之后，我们来了解一下文件是怎么归并的。、

要看归并排序请戳我~

在这里插入图片描述

一、何为文件归并？

文件归并外排序（External Sorting with Merge）是一种专门处理大规模数据的排序算法，适用于数据量大到无法一次全部加载到内存的情况。主要用于处理硬盘等外部存储设备上的数据，而不是内存中的数据。

外排序的核心思想：

  1. 排序阶段（分割数据）：由于数据量过大，无法一次性全部放入内存，所以将数据分块处理。每次读取内存能够容纳的一部分数据，对这部分数据进行排序，然后将排序后的数据存储到临时文件中。重复这个过程，直到所有数据都被处理并生成多个有序的临时文件。

  2. 归并阶段（合并文件）：将之前生成的多个有序临时文件按一定方式归并成一个大的有序文件。归并排序的特点是不需要随机访问数据，只需按顺序读入数据进行归并，因此特别适合外排序。

步骤总结：

  • Step 1: 分割数据并对每个分块排序（生成多个有序的临时文件）。
  • Step 2: 将这些有序的临时文件逐步归并，直到所有数据整合成一个完整的有序文件。

外排序与内排序的区别：

  • 外排序：处理无法完全加载到内存中的数据，使用“排序-归并”策略，依赖外部存储设备。
  • 内排序：处理能完全加载到内存中的数据，常用排序算法如快速排序、堆排序等都属于内排序。

归并排序作为一种适用于顺序读取数据的算法，可以同时用于内存中的排序和外存储的排序，因此在外排序中也广泛应用。

二、文件归并思路分析

假设这是我们未排序的文件
在这里插入图片描述

  1. 分块排序：

    • 读取内存能容纳的 n 个数据，进行排序。
    • 将排序后的数据写入到 file1。
    • 再次读取 n 个数据，排序后写入到 file2。

    在这里插入图片描述

  2. 初步归并：

    • 通过归并排序的思想，同时从 file1 和 file2 中按顺序读取数据。
    • 比较 file1 和 file2 的当前值，将较小的值依次写入到 mfile 中。
    • 继续此过程，直到 file1 和 file2 的数据全部归并到 mfile 中，生成一个新的有序文件。

    在这里插入图片描述

  3. 文件重命名和清理：

    • 删除 file1 和 file2，释放存储空间。
    • 将 mfile 重命名为 file1，以便后续继续归并。

    在这里插入图片描述

  4. 继续处理新的数据：

    • 继续读取 n 个新的数据进行排序，并将其写入到 file2。
    • 再次执行归并操作，将 file1 和 file2 归并成一个新的有序文件，存入 mfile。

    在这里插入图片描述

  5. 重复归并，直到结束：

    • 重复步骤 2 和步骤 4，直到所有数据处理完毕。
    • 最终归并后的有序文件存放在 file1 中，完成整个排序过程。

    在这里插入图片描述

文件归并的特点：

  • 每次只需在内存中处理一小部分数据，避免内存溢出问题。
  • 使用归并排序保证了数据在外存储中按顺序处理，高效完成排序。

三、创造多数据文件

思路如下：

  1. 定义随机数个数 n:

    int n = 1000000;
    • 定义 n 为 1000000，表示需要在文件中生成 100 万个随机数。

  2. 初始化随机数种子:

    srand(time(0));
    • 使用 srand(time(0)) 来初始化随机数种子，确保每次运行时生成的随机数序列不同。

  3. 定义文件名:

    const char* file = "data.txt";
const char* file1 = "file1";
const char* file2 = "file2";
    • 定义了三个文件路径，data.txt 用于存储生成的随机数，file1 和 file2 用于后续归并排序中的临时文件。

  4. 打开文件 data.txt（用于写入数据）:

    FILE* fin = fopen(file, "w");
if (fin == NULL)
{
    perror("fopen error");
    return;
}
    • 使用 fopen 以写入模式 (w) 打开 data.txt，若打开失败，则输出错误信息并退出函数。

  5. 生成并写入随机数:

    for (int i = 0; i < n; i++)
{
    int x = rand() + i;
    fprintf(fin, "%d\n", x);
}
    • 使用 for 循环生成 n 个随机数，并通过 fprintf 将它们逐行写入到 data.txt 文件中。
    • rand() 用于生成随机数，并在每个随机数上加上当前循环索引 i，以增加随机数的分布多样性。

  6. 关闭文件 data.txt:

    fclose(fin);
    • 随机数写入完成后，关闭 data.txt 文件。

  7. 清空 file1 和 file2:

    FILE* f1 = fopen(file1, "w");
FILE* f2 = fopen(file2, "w");
if (f1 == NULL || f2 == NULL)
{
    perror("fopen file1 or file2 fail!");
    return;
}
    • 分别以写模式打开 file1 和 file2 文件。如果文件不存在，则会创建；如果文件存在，则清空内容。

  8. 关闭 file1 和 file2:

    fclose(f1);
fclose(f2);
    • 清空完成后，关闭 file1 和 file2，准备后续排序时使用。

总结：

  • 这个函数的核心任务是生成一个包含随机数的文件 data.txt，并准备两个空的文件 file1 和 file2，为接下来的外部归并排序操作做准备。
  • 通过这种方式，数据先被分批处理、排序并写入 file1 和 file2，最后通过归并的方式组合成有序文件。

像这样就创建成功了
在这里插入图片描述

代码如下：

// 创建有 N 个数据的文件，并同时创建 file1 和 file2
void CreatNData()
{
	// 随机数造数据
	int n = 1000000;
	srand(time(0));
	const char* file = "data.txt";
	const char* file1 = "file1";
	const char* file2 = "file2";

	// 打开文件(写数据)
	FILE* fin = fopen(file, "w");
	// 判断文件是否打开成功
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}

	// 循环开始写数据
	for (int i = 0; i < n; i++)
	{
		int x = rand() + i;
		fprintf(fin, "%d\n", x);
	}

	// 关闭大文件
	fclose(fin);

	// 清空 file1 和 file2，以便后续使用
	FILE* f1 = fopen(file1, "w");
	FILE* f2 = fopen(file2, "w");
	if (f1 == NULL || f2 == NULL)
	{
		perror("fopen file1 or file2 fail!");
		return;
	}

	// 关闭 file1 和 file2
	fclose(f1);
	fclose(f2);
}

四、前置准备——堆排序

后面拿n个数据读取到file1和file2中的时候需要排序，我们这里使用堆排序

J桑前面讲过好多次堆排序，这里就直接给代码啦~

需要看堆排序戳我~~~

//先把堆排拿过来备用
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		// 选出左右孩⼦中⼤的那⼀个
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int* a, int n)
{
	// 建堆 -- 向下调整建堆 -- O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}
	// O(N*logN)
	
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[end], &a[0]);
		AdjustDown(a, end, 0);
		--end;
	}
}

五、两个文件写入到第三个文件

这段代码通过归并排序的思想，将 file1 和 file2 中的数据按序合并到 mfile 中。具体流程如下：

  1. 打开文件：以读取模式打开 file1 和 file2，以写入模式打开 mfile。
  2. 归并数据：通过循环从 file1 和 file2 读取数据，比较大小后将较小的值写入 mfile。
  3. 处理剩余数据：当一个文件的数据读完后，将另一个文件剩下的数据依次写入 mfile。
  4. 关闭文件：处理完成后，关闭所有文件。

这里简单解释一下 fscanf 的用法
在这里插入图片描述
在这里插入图片描述
fscanf发生错误时会返回EOF，因此我们可以用EOF来判断

代码如下：

// file1⽂件的数据和file2⽂件的数据归并到mfile⽂件中
void MergeFile(const char* file1, const char* file2, const char* mfile)
{
	//创立三个文件，以读的方式打开file1和file2，以写的方式打开mfile
	FILE* fout1 = fopen(file1, "r");
	if (fout1 == NULL)
	{
		perror("fopen file1 fail!");
		exit(-1);
	}

	FILE* fout2 = fopen(file2, "r");
	if (fout2 == NULL)
	{
		perror("fopen file2 fail!");
		exit(-1);
	}

	FILE* fin = fopen(mfile, "w");
	if (fin == NULL)
	{
		perror("fopen mfile fail!");
		exit(-1);
	}

	// 这⾥跟内存中数组归并的思想完全类似，只是数据在硬盘⽂件中⽽已
    // 依次读取file1和file2的数据，谁的数据⼩，谁就往mfile⽂件中去写
    // file1和file2其中⼀个⽂件结束后，再把另⼀个⽂件未结束⽂件数据，
    // 依次写到mfile的后⾯
	int num1, num2;
	int ret1 = fscanf(fout1, "%d\n", &num1);
	int ret2 = fscanf(fout2, "%d\n", &num2);

	while (ret1 != EOF && ret2 != EOF)
	{
		if (num1 < num2)
		{
			fprintf(fin, "%d\n", num1);
			ret1 = fscanf(fout1, "%d\n", &num1);
		}
		else
		{
			fprintf(fin, "%d\n", num2);
			ret2 = fscanf(fout2, "%d\n", &num2);
		}
	}

	while (ret1 != EOF)
	{
		fprintf(fin, "%d\n", num1);
		ret1 = fscanf(fout1, "%d\n", &num1);
	}
	while (ret2 != EOF)
	{
		fprintf(fin, "%d\n", num2);
		ret2 = fscanf(fout2, "%d\n", &num2);
	}

	///打开文件后记得关闭
	fclose(fout1);
	fclose(fout2);
	fclose(fin);
}

六、读 N 个数据返回给文件,并返回读到数据的个数

这段代码的功能是从文件中读取 n 个数据，排序后再写入另一个文件，并返回实际读取到的数据个数。具体流程如下：

  1. 读取数据：

    • 使用 fscanf 从文件 fout 中读取整数，最多读取 n 个数据，存储在数组 a 中。
    • 通过 i 记录实际读取到的数据个数，循环读取直到达到 n 或文件结束。

  2. 检查数据数量：

    • 如果没有读取到任何数据，直接返回 0，表示读取失败或文件为空。

  3. 堆排序：

    • 如果读取到了数据，调用 HeapSort 对数组 a 中的 i 个数据进行排序。

  4. 写入排序后的数据：

    • 打开目标文件 file，并将排序后的数据逐行写入。
    • 文件写入完成后关闭文件。

  5. 返回值：

    • 返回实际读取并排序的数据个数 i，用于后续处理。

关键点：

  • 数据读取使用 fscanf，按行读取整数。我们构建父本的时候也是按行%d\n形式的
  • 使用堆排序 HeapSort 对数据进行排序。
  • 数据排序后写回到指定的 file 文件中。

代码如下：

// 返回读取到的数据个数,并排序,读 N 个数据返回给文件,并返回读到数据的个数
int ReadNNumSortToFile(FILE* fout, int* a, int n, const char* file)
{
	//数据读到 x 中
	int x = 0;

	// i 表示读到数据的个数
	int i = 0;

	while (i < n && fscanf(fout, "%d\n", &x) != EOF)
	{
		a[i++] = x;
	}

	//如果一个数据都没读到，不用排序了，返回0
	if (i == 0)
	{
		return i;
	}

	//读到的数据堆排序
	HeapSort(a, i);

	//把排序过的数组放回文件中去
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen file fail!");
		exit(-1);
	}

	for (int j = 0; j < i; j++)
	{
		fprintf(fin, "%d\n", a[j]);
	}

	//记得关闭文件
	fclose(fin);
	return i;
}

七、文件归并

该函数的目的是通过外部归并排序，将大文件 file 按照块处理，逐块排序并归并，最终生成一个有序文件。

开始之前，我们先来了解两个函数：
remove：
在这里插入图片描述
在这里插入图片描述

rename:
在这里插入图片描述
在这里插入图片描述

用这两个函数就可以有效删除和重命名我们的文件，合理运用返回值增强代码健壮性，还可以当作判断条件

  1. 文件打开：

    FILE* fout = fopen(file, "r");
    • 以只读模式打开要排序的文件 file，如果打开失败，程序退出。

  2. 定义临时文件：

    const char* file1 = "file1";
const char* file2 = "file2";
const char* mfile = "mfile";
    • file1 和 file2 用于存储分块后的数据，mfile 是临时文件，存储归并后的数据。

  3. 内存分配：

    int* a = (int*)malloc(sizeof(int) * n);
    • 为数组 a 分配大小为 n 的内存空间，用于存储从文件中读取的数据。n 是每次读取数据的大小，取决于内存可用空间。

  4. 数据分块并排序：

    int readCount1 = ReadNNumSortToFile(fout, a, n, file1);
int readCount2 = ReadNNumSortToFile(fout, a, n, file2);
    • 调用 ReadNNumSortToFile 函数，从 file 中读取 n 个数据，排序后分别写入 file1 和 file2。
    • 读取的结果存储在 readCount1 和 readCount2，如果两个文件都没有数据，直接退出函数。

  5. 循环归并：

    while (1)
    • 进入循环，将 file1 和 file2 中的数据归并到 mfile 中。

  6. 文件处理：

    • 归并：

      MergeFile(file1, file2, mfile);
      • 调用 MergeFile 函数，将 file1 和 file2 的内容按顺序归并到 mfile。

    • 删除与重命名：

      remove(file1);
remove(file2);
rename(mfile, file1);
      • 删除 file1 和 file2，然后将 mfile 重命名为 file1，为下一次归并做准备。

  7. 继续读取数据并归并：

    if (ReadNNumSortToFile(fout, a, n, file2) == 0)
{
    break;
}
    • 再次读取 n 个数据排序并存储到 file2，如果无法再读取数据，说明归并结束，退出循环。

  8. 结束处理：

    fclose(fout);
free(a);
    • 关闭文件并释放内存。

核心思想：

  • 通过逐块读取数据到内存进行排序，随后将多个排序好的块文件进行归并，最终得到一个有序的文件。每次归并后的文件会循环处理，直至所有数据排序完成。

也就是我们一开始画的这张图，是我们整个文件归并的大框架
在这里插入图片描述

代码实现：

// MergeSortFile的第⼆个是每次取多少个数据到内存中排序，然后写到⼀个⼩⽂件进⾏归并
// 这个n给多少取决于我们有多少合理的内存可以利⽤，相对⽽⾔n越⼤，更多数据到内存中排序后，
// 再⾛⽂件归并排序，整体程序会越快⼀些。
void MergeSortFile(const char* file, int n)
{
	// 以写的方式打开文件 file
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen file fail!");
		exit(-1);
	}

	// 定义三个文件 file1, file2, mfile
	const char* file1 = "file1";
	const char* file2 = "file2";
	const char* mfile = "mfile";

	// 分割成⼀段⼀段数据，内存排序后写到，⼩⽂件
	int* a = (int*)malloc(sizeof(int) * n);
	if (a == NULL)
	{
		perror("malloc fail!");
		exit(-1);
	}

	
	int readCount1 = ReadNNumSortToFile(fout, a, n, file1);
	int readCount2 = ReadNNumSortToFile(fout, a, n, file2);

	if (readCount1 == 0 && readCount2 == 0) {
		fclose(fout);
		free(a);
		return; // 如果两个文件都没有数据，直接返回
	}

	//循环归并获取元素
	while (1)
	{
		// file1和file2⽂件归并到mfile⽂件中
		MergeFile(file1, file2, mfile);

		//删除file1和file2
		if (remove(file1) != 0 || remove(file2) != 0)
		{
			perror("Error deleting file");
			exit(-1);
		}

		//重命名mfile为file1
		if (rename(mfile, file1) != 0)
		{
			perror("Error renaming file");
			exit(-1);
		}

		// 读取N个数据到file2，继续⾛归并
        // 如果⼀个数据都没读到，则归并结束了
		if (ReadNNumSortToFile(fout, a, n, file2) == 0)
		{
			break;
		}
	}

	printf("%s 文件成功排序到%s\n", file, file1);
	// 别忘了关闭文件，释放a空间
	fclose(fout);
	free(a);
}

八、文件归并完整代码总结

1. 运行代码

到这里我们所有的框架都搭建完了，现在要做的就是将他们结合起来

完整代码实现：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>




// 创建有 N 个数据的文件，并同时创建 file1 和 file2
void CreatNData()
{
	// 随机数造数据
	int n = 1000000;
	srand(time(0));
	const char* file = "data.txt";
	const char* file1 = "file1";
	const char* file2 = "file2";

	// 打开文件(写数据)
	FILE* fin = fopen(file, "w");
	// 判断文件是否打开成功
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}

	// 循环开始写数据
	for (int i = 0; i < n; i++)
	{
		int x = rand() + i;
		fprintf(fin, "%d\n", x);
	}

	// 关闭大文件
	fclose(fin);

	// 清空 file1 和 file2，以便后续使用
	FILE* f1 = fopen(file1, "w");
	FILE* f2 = fopen(file2, "w");
	if (f1 == NULL || f2 == NULL)
	{
		perror("fopen file1 or file2 fail!");
		return;
	}

	// 关闭 file1 和 file2
	fclose(f1);
	fclose(f2);
}

//先把堆排拿过来备用
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		// 选出左右孩⼦中⼤的那⼀个
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int* a, int n)
{
	// 建堆 -- 向下调整建堆 -- O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}
	// O(N*logN)
	
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[end], &a[0]);
		AdjustDown(a, end, 0);
		--end;
	}
}

// file1⽂件的数据和file2⽂件的数据归并到mfile⽂件中
void MergeFile(const char* file1, const char* file2, const char* mfile)
{
	//创立三个文件，以读的方式打开file1和file2，以写的方式打开mfile
	FILE* fout1 = fopen(file1, "r");
	if (fout1 == NULL)
	{
		perror("fopen file1 fail!");
		exit(-1);
	}

	FILE* fout2 = fopen(file2, "r");
	if (fout2 == NULL)
	{
		perror("fopen file2 fail!");
		exit(-1);
	}

	FILE* fin = fopen(mfile, "w");
	if (fin == NULL)
	{
		perror("fopen mfile fail!");
		exit(-1);
	}

	// 这⾥跟内存中数组归并的思想完全类似，只是数据在硬盘⽂件中⽽已
    // 依次读取file1和file2的数据，谁的数据⼩，谁就往mfile⽂件中去写
    // file1和file2其中⼀个⽂件结束后，再把另⼀个⽂件未结束⽂件数据，
    // 依次写到mfile的后⾯
	int num1, num2;
	int ret1 = fscanf(fout1, "%d\n", &num1);
	int ret2 = fscanf(fout2, "%d\n", &num2);

	while (ret1 != EOF && ret2 != EOF)
	{
		if (num1 < num2)
		{
			fprintf(fin, "%d\n", num1);
			ret1 = fscanf(fout1, "%d\n", &num1);
		}
		else
		{
			fprintf(fin, "%d\n", num2);
			ret2 = fscanf(fout2, "%d\n", &num2);
		}
	}

	while (ret1 != EOF)
	{
		fprintf(fin, "%d\n", num1);
		ret1 = fscanf(fout1, "%d\n", &num1);
	}
	while (ret2 != EOF)
	{
		fprintf(fin, "%d\n", num2);
		ret2 = fscanf(fout2, "%d\n", &num2);
	}

	///打开文件后记得关闭
	fclose(fout1);
	fclose(fout2);
	fclose(fin);
}

// 返回读取到的数据个数,并排序,读 N 个数据返回给文件,并返回读到数据的个数
int ReadNNumSortToFile(FILE* fout, int* a, int n, const char* file)
{
	//数据读到 x 中
	int x = 0;

	// i 表示读到数据的个数
	int i = 0;

	while (i < n && fscanf(fout, "%d\n", &x) != EOF)
	{
		a[i++] = x;
	}

	//如果一个数据都没读到，不用排序了，返回0
	if (i == 0)
	{
		return i;
	}

	//读到的数据堆排序
	HeapSort(a, i);

	//把排序过的数组放回文件中去
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen file fail!");
		exit(-1);
	}

	for (int j = 0; j < i; j++)
	{
		fprintf(fin, "%d\n", a[j]);
	}

	//记得关闭文件
	fclose(fin);
	return i;
}

// MergeSortFile的第⼆个是每次取多少个数据到内存中排序，然后写到⼀个⼩⽂件进⾏归并
// 这个n给多少取决于我们有多少合理的内存可以利⽤，相对⽽⾔n越⼤，更多数据到内存中排序后，
// 再⾛⽂件归并排序，整体程序会越快⼀些。
void MergeSortFile(const char* file, int n)
{
	// 以写的方式打开文件 file
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen file fail!");
		exit(-1);
	}

	// 定义三个文件 file1, file2, mfile
	const char* file1 = "file1";
	const char* file2 = "file2";
	const char* mfile = "mfile";

	// 分割成⼀段⼀段数据，内存排序后写到，⼩⽂件
	int* a = (int*)malloc(sizeof(int) * n);
	if (a == NULL)
	{
		perror("malloc fail!");
		exit(-1);
	}

	
	int readCount1 = ReadNNumSortToFile(fout, a, n, file1);
	int readCount2 = ReadNNumSortToFile(fout, a, n, file2);

	if (readCount1 == 0 && readCount2 == 0) {
		fclose(fout);
		free(a);
		return; // 如果两个文件都没有数据，直接返回
	}

	//循环归并获取元素
	while (1)
	{
		// file1和file2⽂件归并到mfile⽂件中
		MergeFile(file1, file2, mfile);

		//删除file1和file2
		if (remove(file1) != 0 || remove(file2) != 0)
		{
			perror("Error deleting file");
			exit(-1);
		}

		//重命名mfile为file1
		if (rename(mfile, file1) != 0)
		{
			perror("Error renaming file");
			exit(-1);
		}

		// 读取N个数据到file2，继续⾛归并
        // 如果⼀个数据都没读到，则归并结束了
		if (ReadNNumSortToFile(fout, a, n, file2) == 0)
		{
			break;
		}
	}

	printf("%s 文件成功排序到%s\n", file, file1);
	// 别忘了关闭文件，释放a空间
	fclose(fout);
	free(a);
}

int main()
{
	//CreatNData();
	
	// 一次排100000个数据
	MergeSortFile("data.txt", 100000);
	return 0;
}

2. 运行截图

我们来运行一下吧~

先创建数据

在这里插入图片描述

在这里插入图片描述

来到我们文件中，可以看到我们初始数据，还有file1,fiel2都创建好了。

再来运行排序

打开我们的文件，可以看到在file1中数据排好了升序，代表文件归并成功~
在这里插入图片描述
数据太多了，J桑就不都给大家看啦~

总结

到这里，我们文件归并的内容就结束啦~

最重要的是要先搭建出文件归并的框架，像这样大事化小的思路，然后先把框架化为代码，再去补充其他需要用到的函数~

在这里插入图片描述

那么，就谢谢大家啦~

在这里插入图片描述

小柯J桑_
关注
专栏目录
PHP排序算法系列之归并排序详解
10-18
归并排序是一种基于分治策略的高效排序算法，它的基本思想是将大问题分解为小问题来解决。在归并排序中，我们将一个大的无序序列分割成若干个小的有序序列，然后将这些有序序列逐步合并，最终得到完全有序的大序列。...
【算法系列 | 4】深入解析排序算法之——归并排序
热门推荐
颜淡慕潇
06-10 2万+
排序算法是很常见的一类问题，主要是将一组数据按照某种规则进行排序。以下是一些常见的排序算法：冒泡排序（Bubble Sort）插入排序（Insertion Sort）选择排序（Selection Sort）归并排序（Merge Sort）快速排序（Quick Sort）堆排序（Heap Sort）归并排序（Merge Sort）是一种基于分治思想的排序算法，它将待排序的数组分成两部分，分别对这两部分递归地进行排序，最后将两个有序子数组合并成一个有序数组。
【数据结构】文件的归并排序
最新发布
m0_74044018的博客
07-17 719
如果一个文件中很多数据，需要你排序，内存空间又不太多的情况下该如何利用好归并排序的问题。（便于深入理解文件知识）
大文件 多路归并 排序
张之海的博客
09-21 6236
1 题目 这一种题目的描述，大概有以后两种： 题目1：一个大文件在一台服务器上存不下，需要存放在多台服务器上，将这个大文件的内容进行排序。 题目2：一个大文件100G，存储在磁盘上，现在需要对这个文件的内容进行排序，而内存装不下整个文件。 2 分割为小文件+多路归并排序 基本思路： step1：分割+排序 从头开始将大文件FileFileFile的一个小部分读入内存中，将这一小部分进行排序...
“深入理解”—归并排序算法
冷血之心的博客
04-30 1万+
关于归并排序的一个初步学习总结
排序算法之归并排序和外部排序
青萍之末的博客
06-11 6155
一、归并排序   归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案”修补”在一起，即分而治之)。 1、算法描述 1. 把长度为n的输入序列分成两个长度为n/2的子序列； 2. 对这两个子序列分别采...
C语言实现排序算法之归并排序详解
12-25
排序算法中的归并排序(Merge Sort)是利用”归并”技术来进行排序。归并是指将若干个已排序的子文件合并成一个有序的文件。 一、实现原理： 1、算法基本思路 设两个有序的子文件(相当于输入堆)放在同一向量中相邻的...
java 算法之归并排序详解及实现代码
08-31
归并排序是一种高效的排序算法，其核心思想是分治法。在Java中，归并排序通过将数组分为两半，分别对每一半进行排序，然后将两个已排序的半部分合并成一个完整的有序数组来实现。这种算法适用于大数据集，因为它的...
C语言开发之归并排序详解及实例
08-31
归并排序是一种高效的排序算法，基于分治策略。在C语言中实现归并排序，我们需要理解其基本原理和步骤，然后编写相应的代码。下面将详细解释归并排序的工作原理，并结合给出的实例进行分析。 **归并排序的基本原理...
java数据结构排序算法之归并排序详解
08-30
Java数据结构排序算法之归并排序详解 Java数据结构排序算法之归并排序是基于合并的思想，将两个或两个以上有序表合并成一个新的有序表。这种方法被称作是2-路归并排序（基本操作是将待排序列中相邻的两个有序子...
大数据的文件归并排序
w1724556613的博客
04-22 684
试想一个场景，如果一份很大很大的数据需要排序，如果你没有足够的内存放入数据，这样子针对内存的内部排序是无法完成的，所以我们必须依靠磁盘去解决这个问题。 第一 将数据分成若干份(我们这里以10份为例子)，每份都接近内存的最大数据量，这样子，将文件上的数据读入内存中，将它排序，结束后我们就可以得到10份有序的文件数据了。 const char* MergeFile(const char* file) { FILE* fout = fopen(file, "r");//传出文件名，打开此文件 if (fout
归并排序-图文过程
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
09-10 1690
最容易理解归并排序！！！
排序算法之归并排序法
w512的专栏
11-13 1031
归并排序算法 归并排序算法是一种外部存储设备最常用的排序算法，该排序法可以分为如下两个步骤： （1）将排序数据分为数个文件，其中每个文件的大小都是可以加载到内存空间，然后使用适当的内部排序算法进行排序，最后将排完序的数据写回文件中； （2）将第一个步骤创建的文件，两两归并称为了一个文件，最后，全部的文件都归并称为一个文件，则文件数据也就排序完成了。 如下图所示的例子： 一
大文件多路归并排序
Gikieng的奋斗路
01-05 2118
背景： 一堆小文件，每个文件中有10^6行的数字，要求将这些小文件合并成一个有序的文件。 实现思路： 先将每个小文件整理成有序，可以用多进程来处理。 同时打开排完序的文件（打开的文件数受限于系统允许打开文件数，ulimit -a 查看，ulimit -n 修改可允许打开文件数），维护一个堆，堆中元素为{文件描述符，当前偏移量，当前行值}，以当前行值比较。
文件合并排序
wzz24的专栏
01-17 824
/*********************************************************************************************************文件名称 : merge.c建立时间 : 2005-10-19版权所有 : 东软股份大连分公司电信事业开发部Author   : 中介部.吴喆喆文件描述 :   文件合并排序  修改记录
文件归并排序算法系列之合并排序
weixin_30782293的博客
05-08 323
改章节是一篇关于文件归并的帖子 归并排序（Merge sort，合并排序）是建立在归并操纵上的一种效有的排序法算。该法算是用采分治法（Divide and Conquer）的一个非常典范的用应。 一 归并操纵 基本思想 归并操纵(merge)，指的是将两个经已排序的序列合并成一个序列的操纵，归并排序法算赖依归并操纵。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值