外排序中的归并排序

原创 已于 2025-01-09 00:38:09 修改 · 726 阅读 · 23 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#排序算法 #算法 #c语言 #归并排序

于 2024-11-22 12:03:03 首次发布

外排序中的归并排序

7.11 外排序中的归并排序

外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。（下文也称外排序）

例如 1 G = = 102 4 3 b y t e 1G==1024^3 byte 1G==10243byte，一个int型整数4byte，100亿（ 1 0 10 10^{10} 1010）个int型整数占用空间为37G左右，针对这100亿个数据的排序已无法用常见的排序算法去操作。因为内存无法容纳如此庞大的数据，这些数据必定是保存在磁盘中。

归并排序是将数据分割成若干个细小的单位，再将这些细小的单位合并成一个整体，合并的时候按照某种排序规则进行。所以归并排序不仅可以做内排序，还能充当外排序的重要角色。

相关基础知识

外排序是针对文件操作的，所以需要掌握和文件相关的函数和命令。

测试环境是windows 11，所以命令以windows 11适用为主。

可能用到的：

  1. int scanf(const char* format[,argument]...);

scanf能将从键盘上读取的数据存放进变量。

  1. int fscanf(FILE* stream , const char* format[, argument ]...);

fscanf功能和scanf类似，但不同的是fscanf可以指定操作文件也就是形参stream。当stream为stdin（标准输入流）时和scanf几乎无区别。

  1. int sscanf(const char* buffer,const char* format[,argument] ...);

sscanf将数据读取对象从文件变成了指定字符串。

  1. int printf(const char* format [,argument*]*... );

printf能将数据以字符串的形式打印在终端控制台（windows叫cmd）。

  1. int fprintf(FILE* stream,const char* format[,argument*]*...);

fprintf能将数据以字符串的形式打印在指定文件。当stream为stdout（标准输出流）时和printf几乎无区别。

  1. int sprintf(const char* buffer,const char* format[,argument*]*...);

sprintf将数据输出的对象从文件变成了字符串。

  1. FILE* fopen(const char* filename,const char* mode);

返回文件filename的操作模式为mode的文件指针。

  1. int system(const char* command);

system能调用命令行让cmd执行各种操作。

  1. int snprintf(char* s,size_t n,const char *format,...);

和sprintf相比，它能指定输出n个字符到字符串s，并返回成功输出的字符数。于是我们可以这样操作：int name_len = snprintf(NULL,0,"midFile_%d_%d.txt",level,fnum);，这个函数可以返回文件名的长度，因为是指定输出0个字符到NULL地址处的“字符串”，所以函数内部并没有产生实质性的指针调用操作。

  1. windows OS，cmd的命令：

    1. move src dis 将src路径的某文件改名并移动到dis路径。
    2. del file 删除file文件。
    3. md route 创建路径（目录）。
    4. rd route 删除路径（目录）。

原理

  1. 将数据存放在一个可读的文本文件中（其他的拓展名应该也行，关键是程序和自己都能识别）。
  2. 读取这个文件的数据，读完一段数据之后，用内排序处理，将处理完的数据输出为中间文件。

中间文件的命名不唯一，我选择的格式是midFile_level_num.txt，level是级别，num是文件的编号，这样一来，每个level级的中间文件都是由level-1级的文件合并而来。

中间文件最好放在一个文件夹中统一保存。

  1. 将所有的中间文件两两归并，生成更高一级的中间文件，并删除参与归并的低一级的文件（磁盘容量充裕的话可忽略）。

偶数个中间文件归能全部归并完成并删除，奇数个中间文件会留一个，那个文件改名成高一级的中间文件即可。

  1. 重复3的操作，直到只剩最后一个文件，那个文件即为排序好的数据。

也可不用生成高一级的文件，因为频繁的文件打开和关闭操作会使得实际耗时更长。这里仅作为一次个人能力的体现，后续如果有机会再优化。

原理其实和归并排序差不多，但有磁盘作为存储数据的介质，可操作空间非常大。
请添加图片描述

最终参考程序

测试环境windows 11，visual studio 2019和vscode（gcc版本8.1.0）。

fileSort.h

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

typedef int Datatype;

//创造数据
void createData(int num);

//判断数据是否有序
int judgSort(Datatype* a, int n);

//用归并算法将文件中的数据进行排序
void mergeSortFile(const char* st);

fileSort.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"fileSort.h"

//交换函数
void Swap(Datatype* a, Datatype* b) {
	Datatype t = *a;
	*a = *b;
	*b = t;
}

//创造数据
void createData(int num) {
	srand((size_t)(0));
	char st[] = "beforeSortData.txt";
	FILE* fout = fopen(st, "w");
	int i = 0;
	for (i = 0; i < num; i++)
		fprintf(fout, "%d\n", rand() * rand() + 1);
	fclose(fout);
}

//判断数据是否有序
int judgSort(Datatype* a, int n) {
	int i = 0;
	for (i = 0; i < n - 1; i++)
		if (a[i] > a[i + 1])
			break;
	return i == n - 1;
}

//插入排序
void insertSort(Datatype* a, int n) {
	int i = 0;
	for (i = 0; i < n - 1; ++i) {
		int end = i;
		int tmp = a[i + 1];

		while (end >= 0) {
			if (a[end] > tmp) {
				a[end + 1] = a[end];
				--end;
			}
			else
				break;
		}
		a[end + 1] = tmp;
	}
}

//生成中间文件
void buyMidFile(Datatype* a, int n, int level, int* fnum) {
	int nlen = 64;//中间文件名字最大长度
	char* midFileName = (char*)malloc(sizeof(char) * nlen);
	if (midFileName == NULL) {
		printf("buyMidFile malloc 1");
		perror("");
		exit(-1);
	}

	//生成1个文件数，计数变量增加
	(*fnum)++;
	//文件名长度
	int flen = snprintf(NULL, 0,
		".\\sub\\midFile_%d_%d.txt", level, *fnum);
	while (flen > nlen) {
		char* tmp = (char*)realloc(midFileName, nlen * 2 * sizeof(char));
		if (tmp == NULL) {
			printf("buyMidFile realloc 2");
			perror("");
			exit(-1);
		}
		midFileName = tmp;
		nlen *= 2;
	}

	flen = sprintf(midFileName,
		".\\sub\\midFile_%d_%d.txt", level, *fnum);
	FILE* fout = fopen(midFileName, "w");
	if (fout == NULL) {
		system("md sub");//可能是文件夹不存在的情况
		fout = fopen(midFileName, "w");
		if (fout == NULL) {
			printf("%s打开失败", midFileName);
			exit(-1);
		}
	}

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


	free(midFileName);
	fclose(fout);
}

//切割文件
int inciseFile(const char* st) {
	//打开源文件
	FILE* srcData = fopen(st, "r");
	if (srcData == NULL) {
		printf("%s打开失败", st);
		exit(-1);
	}

	//申请数组
	Datatype* a = (Datatype*)malloc(sizeof(Datatype) * 10);
	if (a == NULL) {
		printf("inciseFile malloc 1");
		perror("");
		exit(-1);
	}
	int ai = 0;//和a配套的指针变量
	int srcp = 0;//文件阅读进度标记
	int tnum = 0;//临时变量
	int fnum = 0;//生成的文件数
	while (srcp = fscanf(srcData, "%d", &tnum), srcp != EOF) {
		a[ai++] = tnum;
		if (ai == 10) {//读满10就排序
			insertSort(a, ai);
			buyMidFile(a, ai, 1, &fnum);
			ai = 0;
		}
	}
	if (ai != 0) {
		insertSort(a, ai);
		buyMidFile(a, ai, 1, &fnum);
		ai = 0;
	}
	return fnum;
}

//归并文件
int mergeFile(int level, int last_num) {
	int this_num = 0;//记录这一层生成的文件数
	FILE* file1 = NULL, * file2 = NULL;//参与归并的两个文件

	int fnlen = 64;//文件名的最大长度
	char* file_name = (char*)malloc(sizeof(char) * fnlen);
	if (file_name == NULL) {
		printf("mergeFile malloc 1");
		perror("");
		exit(-1);
	}

	int i = 1;
	int n1 = 0, n2 = 0, p1 = 0, p2 = 0;//临时变量n，文件阅读追踪变量p
	for (i = 1; i < last_num; i += 2) {//枚举上一层的文件
		int name_len =
			snprintf(NULL, 0,
				"sub\\midFile_%d_%d.txt", level - 1, i);

		//扩容兼检查容量
		while (fnlen < name_len) {
			char* tmp = (char*)realloc
			(file_name, fnlen * 2 * sizeof(char));
			if (tmp == NULL) {
				printf("mergeFile realloc 2");
				perror("");
				exit(-1);
			}
			file_name = tmp;
			fnlen *= 2;
		}

		//打开三个要操作的文件
		sprintf(file_name, "sub\\midFile_%d_%d.txt", level - 1, i);
		file1 = fopen(file_name, "r");
		if (file1 == NULL) {
			printf("%s打开失败", file_name);
			exit(-1);
		}

		sprintf(file_name, "sub\\midFile_%d_%d.txt", level - 1, i + 1);
		file2 = fopen(file_name, "r");
		if (file2 == NULL) {
			printf("%s打开失败", file_name);
			exit(-1);
		}

		sprintf(file_name, "sub\\midFile_%d_%d.txt", level, ++this_num);
		FILE* final_file = fopen(file_name, "w");
		if (final_file == NULL) {
			printf("%s打开失败", file_name);
			exit(-1);
		}

		//文件归并
		p1 = fscanf(file1, "%d", &n1);
		p2 = fscanf(file2, "%d", &n2);
		while (p1 != EOF && p2 != EOF) {
			if (n1 < n2) {
				fprintf(final_file, "%d\n", n1);
				p1 = fscanf(file1, "%d", &n1);
				//读完最后一个数后file1表示文件结束，
				//下次读入数据时是EOF
			}
			else {
				fprintf(final_file, "%d\n", n2);
				p2 = fscanf(file2, "%d", &n2);
			}
		}
		while (p1 != EOF) {
			fprintf(final_file, "%d\n", n1);
			p1 = fscanf(file1, "%d", &n1);
		}
		while (p2 != EOF) {
			fprintf(final_file, "%d\n", n2);
			p2 = fscanf(file2, "%d", &n2);
		}

		fclose(file1);
		fclose(file2);
		file1 = file2 = NULL;
		fclose(final_file);

		//删除上一级的中间文件
		sprintf(file_name, "del .\\sub\\midFile_%d_%d.txt", level - 1, i);
		system(file_name);
		sprintf(file_name, "del .\\sub\\midFile_%d_%d.txt", level - 1, i + 1);
		system(file_name);
	}

	//处理奇数个中间文件的情况
	if (i == last_num) {
		int name_len = snprintf(NULL, 0, 
			"move .\\sub\\midFile_%d_%d.txt .\\sub\\midFile_%d_%d.txt",
			level - 1, i, level, ++this_num);
		while (fnlen < name_len) {
			char* tmp = (char*)realloc
			(file_name, fnlen * 2 * sizeof(char));
			if (tmp == NULL) {
				printf("mergeFile realloc 2");
				perror("");
				exit(-1);
			}
			file_name = tmp;
			fnlen *= 2;
		}

		sprintf(file_name,
			"move .\\sub\\midFile_%d_%d.txt .\\sub\\midFile_%d_%d.txt",
			level - 1, i, level, this_num);
		system(file_name);
	}

	free(file_name);
	return this_num;
}

//用归并算法将文件中的数据进行排序
void mergeSortFile(const char* st) {
	//1、将文件分割10个为1组的多个小文件。
	int last_num = inciseFile(st);//last num

	//2、两个文件归并成一个，归并后删除子文件。
	int level = 2;//这一层的文件数，等级
	while (last_num > 1) {
		last_num = mergeFile(level, last_num);//归并生成的等级，上层文件数
		++level;
	}
	//3、归并到最后一个，再将文件改名
	int len = snprintf(NULL, 0, 
		"move .\\sub\\midFile_%d_1.txt .\\afterSortData.txt", level - 1);
	char* tmp = (char*)malloc(sizeof(char) * len);
	if (tmp == NULL) {
		printf("mergeSortFile malloc 1");
		perror("");
		exit(-1);
	}
	sprintf(tmp, 
		"move .\\sub\\midFile_%d_1.txt .\\afterSortData.txt", 
		level - 1);
	system(tmp);
	system("rd sub");
	printf("beforeSortData.txt排序成功\n");
}

test.c

#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS 1
#endif

#include"FileSort.h"

void f0() {//生成随机数文件
	createData(114514);
}

void f1() {//文件归并
	mergeSortFile("beforeSortData.txt");//归并排序
}

int main()
{
	f0();//生成随机数文件
	f1();//文件归并
	return 0;
}
【外排序】--- 文件归并排序的实现
2301_79448270的博客
08-03 1632
外排序（External sorting）是指能够处理极⼤量数据的排序算法。外排序通常采⽤的是⼀种“排序-归并”的策略。在排序阶段，先读入能放在内存中的数据量，将其排序输出到⼀个临时文件，依此进行，将待排序数据组织为多个有序的临时文件。然后在归并阶段将这些临时文件组合为⼀个大的有序文件，也即排序结果。注意：1. 通常来说，外排序处理的数据不能一次性装入内存，只能放在读写较慢的外存储器(通常是硬盘上)。2. 我们之前常见的排序是内排，它们排序思想适应的是数据在内存中支持随机访问。
海量数据排序—外排序之归并实现外排序排序
weixin_50374599的博客
04-24 939
一，什么是外排序 1.其实外排序就是在文件中进行排序，那我们知道在文件中访问数据有很多限制，比如不可以随机访问啊，只能通过文件指针访问啊，等等。那我们为什么还要在文件中排序也就是外排序呢？ 【1.】数据量过大，比如海量数据：举个例子，比如又100亿整形需要你排序，我们算一算100亿个整形放在内存中要多大空间呢。 1KB=1024byte； 1MB=1024KB： 1G=1024MB； 我们知道一个整形是4个字节，也就是4byte； 1024*1024*1024大概估计是10亿的样子，也就是说1
3.1.2 排序 - 外排序（归并排序）
胡椒
09-05 395
外排序 - 归并算法 大致思路流程以及代码实现
数据结构 | 【排序】外部排序
"You are worthy! You can do it!"
08-11 5368
外部排序指的是大文件的排序，即待排序的记录存储在外存储器上，待排序的文件无法一次装入内存，需要在内存和外部存储器之间进行多次数据交换，以达到排序整个文件的目的。
【外排序】外排序算法（磁盘排序、磁带排序） 外存设备结构分析 败者树多路归并 最佳归并树白话讲解
这道题我不会做...不会做啊..太难了！！
06-20 6127
外排序外排序概述外排序的基本方法是归并排序法例子总结存储设备（可忽略）磁带磁带结构磁盘硬盘结构块硬盘上的数据定位磁盘排序磁盘排序过程1.生成初始顺串方法1(常规方法）：方法2：置换－选择排序方法2.处理顺串形成有序文件1.多路平衡归并2.利用败者树实现k路平衡归并过程利用败者树实现k路平衡归并的过程是：最佳归并树最佳归并树概念存在的问题当进行k路归并时最后进行归并的归并段小于k个构造步骤磁带排序磁带多路平衡归并排序磁带多阶段归并排序 外排序概述 (本章设计内容后续会具体讲解) 外排序是指数据存放在外存中，数
C++实现希尔、快速、堆排序、归并排序算法
01-21
本文将详细介绍C++中实现的希尔排序、快速排序、堆排序和归并排序这四种经典排序算法。 希尔排序，由Donald Shell于1959年提出，是一种改进的插入排序。它的基本思想是通过设置一个增量序列，将待排序的元素按照...
冒泡排序，选择排序，插入排序，希尔排序，堆排序，归并排序，快速排序源码实现
10-26
以下是关于"冒泡排序，选择排序，插入排序，希尔排序，堆排序，归并排序，快速排序"这七种常见排序算法的源码实现及相关知识点的详细解释： 1. **冒泡排序**：冒泡排序是一种简单的排序算法，它重复地遍历待排序的...
快速排序与归并排序比较(C++).rar_c++paixusuanfa_归并_归并排序_归并排序算法
09-19
快速排序和归并排序是两种常用的排序算法，它们在计算机科学和编程中有着广泛的应用。本文将详细讨论这两种排序算法的原理、实现方式以及性能对比。 快速排序是一种由C.A.R. Hoare在1960年提出的分治算法。其基本...
数据结构（十六）----外部排序
最新发布
weixin_69884785的博客
05-16 5340
数据结构（十六）----外部排序 一.外部排序 1.外部排序的原理 2.外部排序时间开销的分析 3.外部排序的优化 （1）多路归并 （2）减少初始归并段数量 二.败者树 三.置换-选择排序 四.最佳归并树
排序算法-四种常用外部排序算法
孤独的探识者的博客
07-14 1825
①　最多只能有k个段归并为一个；②　每一趟归并中，若m个归并段参与归并，经过这一趟处理得到[m/k]个新的归并段。
手把手教你外排序
weixin_61857742的博客
07-08 1453
排序总体来说分为两类，数据在内存中的叫做内排序，数据存在磁盘的叫外排序。一般而言，磁盘中存放的都是大型数据，所以，外排序主要是应用于磁盘中大型数据的。一.排序思想对于外排序而言，因为待排的数据往往远大于内存容量，所以在排序时通常将数据切分，切分成能在内存中排序的大小，将分成的小块依次在内存中排好序后按归并的思路进行整合即可。我们这里举例子说话：假设我们有一组100G的数据，已知内存最多存放20G，那么我们把这100G的数据切分成5份，每份20G。将每份数据排序后依次放入新创建的文档中。注意：此时所有的数据依
外排序入门
鸭梨的博客
05-23 366
什么是外排序? 外排序是指当待排序的数据量较大、无法一次性全部存入内存中执行排序操作时，先将待排序的数据存储在外存储器上，并将其划分为多个数据块，分批次读入内存中执行排序操作的过程，在这一排序过程中需经过多次内、外存储器之间的数据交换，才可完成排序操作。 外排序的基本方法 外排序通常使用归并排序，其排序过程大体可划分为3个阶段。 1．文件读入阶段 由于文件较大，我们首先需根据内存的大小，将文件划分为若干个子文件或段，依次读入内存中。 2．子文件排序阶段 读入内存后，我们可利用内排序中的方法对每个子文件
数据结构-外部排序-(多路归并排序、败者树、置换选择排序、最佳归并树)
CyAurora的博客
05-16 1462
按增序，开始读取3个记录，最小的(4)置换出去，并MINXMAX=4,,读取下一个，在获取最小的值是否小于MINXMAX，小于放入归并段1后面，如果大于定死这个(下次都不看)，就获取下一个最小的值并大于MINXMAX的(14)置换出去后面，并更新MINXMAX14，然后继续置换，直到3个位置的比 MINXMAX小，就重新一个归并段，在继续前面的置换流程一直结束。对r个初始归并段，做k路归并，则归并树可用k叉树表示，若树高为h，则归并趟树。有了败着树，选出最小元素，只对比灰色每层就行，比对。
排序算法之归并排序和外部排序
青萍之末的博客
06-11 6455
一、归并排序   归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案”修补”在一起，即分而治之)。 1、算法描述 1. 把长度为n的输入序列分成两个长度为n/2的子序列； 2. 对这两个子序列分别采...
外排序
Frank的专栏
11-24 2293
存储器 计算机存储器分为主存储器(内存)和外存储器 内存性能高，价格高；外存性能低，价格也低，并且便携。 外存的基本存储单位：页(page)，长度固定的存储块 文件的组织和管理 文件(file)，外存上的数据结构，由大量相同的记录组成。 记录(record ),具有独立逻辑意义的数据块，可以由字符、二进制序列、字段或域组成。 操作系统的文件：连续字符序列，没有明显结构。 数据库文件：有结构，每个记录
【C语言】外排序（归并思想）
EWIAW_ilove的博客
02-22 1088
外排序实现详解
外排序（归并排序算法）
weixin_38070782的博客
06-22 2099
本文转自https://www.cnblogs.com/huangxincheng/archive/2012/12/19/2824943.html 说到排序，大家第一反应基本上是内排序，是的，算法嘛，玩的就是内存，然而内存是有限制的，总有装不下的那一天，此时就可以来玩玩 外排序，当然在我看来，外排序考验的是一个程序员的架构能力，而不仅仅局限于排序这个层次。 一：N路归并排序 1.概序 我们知道算法中有一种叫做分治思想，一个大问题我们可以采取分而治之，各个突破，当子问题解决了，大问...
经典算法题每日演练——第十八题 外排序
weixin_34419321的博客
12-19 433
       说到排序，大家第一反应基本上是内排序，是的，算法嘛，玩的就是内存，然而内存是有限制的，总有装不下的那一天，此时就可以来玩玩 外排序，当然在我看来，外排序考验的是一个程序员的架构能力，而不仅仅局限于排序这个层次。   一：N路归并排序 1.概序     我们知道算法中有一种叫做分治思想，一个大问题我们可以采取分而治之，各个突破，当子问题解决了，大问题也就KO了，还有一点我们...
常用的外部排序方法
热门推荐
wl044090432的博客
01-23 1万+
一、定义问题       外部排序指的是大文件的排序，即待排序的记录存储在外存储器上，待排序的文件无法一次装入内存，需要在内存和外部存储器之间进行多次数据交换，以达到排序整个文件的目的。外部排序最常用的算法是多路归并排序，即将原文件分解成多个能够一次性装入内存的部分，分别把每一部分调入内存完成排序。然后，对已经排序的子文件进行多路归并排序。 二、处理过程   （1）按可用内存的大
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Darkwanderor

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值