文件归并排序简单实现

最新推荐文章于 2023-07-17 19:53:24 发布
最新推荐文章于 2023-07-17 19:53:24 发布
阅读量2k 收藏 3
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/piaopiaolanghua/article/details/9403051
版权
如果要排序的数据太多了，就不能一次性加载到内存中进行排序，只能分而治之，然后再合并。 这里参考归并排序的过程简单地实现了一下，封装的还很不好。 另外在对多个文件合并时偷了懒，感觉需要用平衡二叉树，但是实现起来比较麻烦，就先用C++标准库中的multiset的排序功能了。 stl的set、map、multiset都是有序，并且是红黑树数据结构，查找、删除等性能都是log(n).

mergesort.h


#ifndef __MERGESORT_H
#define __MERGESORT_H

namespace MyNamespace
{
	typedef int (*Comparer)(const void *a, const void *b);

	template <typename T> 
	int defaultCompare(T *a, T *b)
	{
		if (*a < *b) return -1;
		if (*b < *a) return 1;
		return 0;
	}

	template <typename T> 
	void arrayCopy(T *a, const T *b, int n)
	{
		while (--n >= 0) a[n] = b[n];
	}

	inline int minIndex(int a, int b)
	{
		return a < b ? a : b;
	}

	template <typename T>
	int mergeSort(T a[], int n, Comparer comparer)
	{
		T *b = NULL;
		int i, j, t, start1, end1, start2, end2, len;
		int cmpResult;
		
		if (n < 2)
			return 0;

		b = new T[n];
		if (b == NULL) return -1;


		//len为每次分块的大小，即按照1,2,4,6,8,...,n增长
		len = 1;
		while (len < n)
		{
			t = 0;
			i = 0;
			j = i + len;
			while (j != n)
			{
				//start1,end1,start2,end2用于表示进行比较的两个数据块下标，
				//两个分块的下标范围为[start1,end1),[start2,end2)。
				start1 = minIndex(n, i);
				end1   = minIndex(n, i + len);
				start2 = minIndex(n, i + len);
				end2   = minIndex(n, i + len + len);

				//i,j分别表示当前进行比较的两个元素的下标
				i = start1;
				j = start2;
				while (i < end1 && j < end2)
				{
					if (comparer != NULL)
						cmpResult = comparer(a+i, a+j);
					else
						cmpResult = defaultCompare(a+i, a+j);

					b[t++] = (cmpResult <= 0) ?  a[i++] : a[j++];
				}

				if (i < end1)
				{
					while (i < end1)
						b[t++] = a[i++];
				}
				else
				{
					while (j < end2)
						b[t++] = a[j++];
				}
				//assert(i == end1 && j == end2 && t == end2);
				i = t;
			}
			len = minIndex(n, len * 2);
			arrayCopy(a, b, n);
		}

		delete []b;
		b = NULL;
		return 0;
	}

	template <typename T>
	int mergeSort(T a[], int n)
	{
		return mergeSort(a, n, NULL);
	}

};

#endif //__MERGESORT_H


filemergesort.h

#ifndef __FILEMERGESORT_H
#define __FILEMERGESORT_H

#include "mergesort.h"
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <set>
#include <map>
using namespace std;


#define SORT_AND_WRITE_TO_FILE	\
	ret = MyNamespace::mergeSort(&v[0], v.size(), (MyNamespace::Comparer)strCompare);\
				if (ret != 0)\
				{\
					/* 内存中归并排序失败，可能是内存不足 */\
					return -3;\
				}\
				ret = ouputSortedPartFile(fileName, ++partCount, v, separator);\
				\
				if (ret != 0)\
				{\
					/* 写排序后的部分数据到文件失败 */\
					return -4;\
				}\
				v.clear();


typedef struct
{
	string elment;
	int fileIndex;
} FileElement;


int defaultStrComparer(const string *str1, const string *str2)
{
	//if (*str1 == *str2) return 0;
	//return *str1 < *str2 ? -1 : 1;


	//对逗号分割的第一个元素进行排序
	string sub1, sub2;
	sub1 = str1->substr(0, str1->find(","));
	sub2 = str2->substr(0, str2->find(","));

	if (sub1 == sub2) return 0;
	return sub1 < sub2 ? -1 : 1;
}

class ElementCompareClass
{
public:
	bool operator()(const FileElement &e1, const FileElement &e2)
	{
		return defaultStrComparer(&e1.elment, &e2.elment) < 0;
	}
};

class FileMergeSort
{
public:
	
	typedef int (*StrComparer)(const string *a, const string *b);

	FileMergeSort()
		: separator(DEFAULT_SEPARATOR), maxMemorySize(DEFAULT_MAX_MEMORY_SIZE), strCompare(defaultStrComparer)
	{
	}

	FileMergeSort(const string separatorIn, int maxMemorySizeIn = 1024*1024*10)
		: separator(separatorIn), maxMemorySize(maxMemorySizeIn), strCompare(defaultStrComparer)
	{
		adjustMaxMemorySize();
	}


	void setMaxMemorySize(int bytes)
	{
		maxMemorySize = bytes;
		adjustMaxMemorySize();
	}
	int getMaxMemorySize(int bytes)
	{
		return maxMemorySize;
	}

	void setSeparator(const string s)
	{
		separator = s;
	}
	string getSeparator()
	{
		return separator;
	}

	int readFile(ifstream &inFile, string &sBuffer, int maxSize)
	{
		char ch;
		int size = 0;
		while (size < maxSize)
		{
			ch = inFile.get();
			if (inFile.good())
			{
				size++;
				sBuffer += ch;
			}
			else
			{
				break;
			}
		}
		return size;
	}


	int sort(const char *fileName)
	{
		int ret;
		int partCount = 0;
		int partFileSize = 0;
		int readSize, maxReadSize = 1024;
		string sBuffer, element;
		vector<string> v;

		ifstream inFile(fileName);
		if (!inFile.is_open())
		{
			//打开读文件失败
			return -1;
		}

		string::size_type index;
		while(inFile.good())
		{
			//从文件中最多读取maxReadSize个字符到sBuffer，返回实际读取个数
			readSize = readFile(inFile, sBuffer, maxReadSize);
			if (readSize <= 0)
				break;

			//根据分隔符把读取的字符串拆分成多个元素
			while (true)
			{
				index = sBuffer.find(separator);
				if (index != string::npos)
				{
					element = sBuffer.substr(0, index);
					v.push_back(element);
					sBuffer = sBuffer.substr(index + separator.length());
					partFileSize += element.size();
				}
				else
				{
					if (sBuffer.length() > maxMemorySize/2U)
					{
						//元素太长了（由separator分隔的，或许因为分隔符写错了）
						inFile.close();
						return -2;
					}
					break;
				}
			}

			/*
				如果分块容器v中的大小已经超过设置的大小了，就对这小块进行排序，并写入分块文件
				注意：这里的内存控制不那么准，可以能还差的远，跟vector的内存分分配有关；
				另外MergeSort还需要分配与v等量的内存；实际测试大概需要内存是maxMemorySize的四倍呢
			*/

			if (partFileSize >= maxMemorySize)
			{
				SORT_AND_WRITE_TO_FILE;
				partFileSize = 0;
			}
		}
		inFile.close();

		if (sBuffer.length() > 0)
		{
			v.push_back(sBuffer);
		}

		if (!v.empty())
		{
			SORT_AND_WRITE_TO_FILE;
		}

		//--------- 至此分割文件以及对分块排序完成，并且写入分块文件(filename.N.sortedpart)------------
		//--------- 下面对各个有序的分块文件进行合并 --------------------------------------------------

		
		ret = fileMerge(fileName, partCount);
		if (ret != 0)
		{
			//对分块文件进行归并出错。可能因为打开或创建文件失败、磁盘空间不足等
			return (ret - 100);
		}

		return 0;
	}

protected:	
	virtual void adjustMaxMemorySize()
	{
		if (maxMemorySize < 10240)
			maxMemorySize = 10240;
	}

	int maxMemorySize;
	int maxLineLength;
	const static int DEFAULT_MAX_MEMORY_SIZE;
	const static string DEFAULT_SEPARATOR;
	string separator;
	StrComparer strCompare;

	int fileMerge(const char *fileName, int totalPartCount)
	{
		char sPartNo[13] = {0};
		int partFileNameLength = strlen(fileName) + strlen("..sortedpart") + 13;
		char *partFileName = new char[partFileNameLength];
		
		vector<ifstream *> inFileVector;

		int i;
		for (i = 0; i < totalPartCount; i++)
		{
			itoa(i+1, sPartNo, 10);
			memset(partFileName, 0x00, partFileNameLength);
			sprintf(partFileName, "%s.%d.sortedpart", fileName, i+1);
			
			ifstream *fin = new ifstream(partFileName);
			if (fin == NULL)
			{
				return -1;
			}
			inFileVector.push_back(fin);
			if (!inFileVector[i]->is_open())
			{
				return -2;
			}
		}


		int outFileNameLength = strlen(fileName) + strlen(".sorted") + 1;
		char *outFileName = new char[outFileNameLength];
		if (outFileName == NULL)
		{
			//内存不足
			return -3;
		}

		memset(outFileName, 0x00, outFileNameLength);
		sprintf(outFileName, "%s.sorted", fileName);
		ofstream outFile(outFileName);
		if (!outFile.is_open())
		{
			//结果文件打开失败
			return -2;
		}


		int ret;
		FileElement fileElement;

		//重要：在对多个文件合并时，为了达到log(k)的插入和查找性能，所以使用stl中的multiset（红黑树数据结构），k表示文件的分块文件的个数
		multiset<FileElement, ElementCompareClass> dataSet;
		for (i = 0; i < totalPartCount; i++)
		{
			fileElement.fileIndex = i;
			ret = getElement(inFileVector, i, fileElement.elment);
			if (ret == -2)
			{
				//元素太长,或许分隔符不正确
				return -4;
			}
			if (ret != 0)
			{
				inFileVector[i]->close();
			}

			dataSet.insert(fileElement);
		}

		while (dataSet.size() > 0)
		{
			//把最小的数据写出去，并从这个元素对应的文件再读取一个元素放进去
			//直到所有的文件都空了
		
			fileElement = *(dataSet.begin());
			outFile.write(fileElement.elment.c_str(), fileElement.elment.length());
			outFile.write(separator.c_str(), separator.length());
			dataSet.erase(dataSet.begin());

			if (inFileVector[fileElement.fileIndex]->is_open())
			{
				ret = getElement(inFileVector, fileElement.fileIndex, fileElement.elment);
				if (ret == 0)
				{
					dataSet.insert(fileElement);
				}
				else if (ret == -2)
				{
					//元素太长,或许分隔符不正确
					return -4;
				}
				else
				{
					inFileVector[fileElement.fileIndex]->close();
					
					//TODO 此时可以删除此分块文件
				}
			}
		}

		outFile.close();
		return 0;
	}

	int getElement(vector<ifstream *> &inFileVector, int fileIndex, string &element)
	{
		static map<int, string> map_strBuffer;
		static map<int, int> map_bufferSize;
		int readSize = 0;
		int index;

		if (map_bufferSize.count(fileIndex) <= 0)
		{
			map_bufferSize[fileIndex] = 0;
		}

		while (true)
		{
			index = map_strBuffer[fileIndex].find(separator);
			if (index != string::npos)
			{
				element = map_strBuffer[fileIndex].substr(0, index);
				map_strBuffer[fileIndex] = map_strBuffer[fileIndex].substr(index + separator.length());
				map_bufferSize[fileIndex] -= index +separator.length();
				return 0;
			}

			readSize = readFile(*(inFileVector[fileIndex]), map_strBuffer[fileIndex], 1024);
			if (readSize <= 0)
			{
				//读到文件结尾了
				return -1;
			}

			map_bufferSize[fileIndex] += readSize;
			if (map_bufferSize[fileIndex] > maxMemorySize/2U)
			{
				//元素太长了（由separator分隔的，或许因为分隔符写错了）
				inFileVector[fileIndex]->close();
				return -2;
			}
		}
		return 0;
	}


	int ouputSortedPartFile(const char *fileName, int partCount, vector<string> v, const string &separator)
	{
		int partFileNameLength = strlen(fileName) + strlen("..sortedpart") + 13;
		char *partFileName = new char[partFileNameLength];

		memset(partFileName, 0x00, partFileNameLength);
		sprintf(partFileName, "%s.%d.sortedpart", fileName, partCount);

		ofstream outFile(partFileName);
		if (!outFile.is_open())
		{
			return -1;
		}

		int i, size = v.size();
		for (i = 0; i < size; i++)
		{
			outFile.write(v[i].c_str(), v[i].length());
			outFile.write(separator.c_str(), separator.length());
		}
		outFile.close();
		return 0;
	}

};

const int FileMergeSort::DEFAULT_MAX_MEMORY_SIZE = 1024*1024*10;
const string FileMergeSort::DEFAULT_SEPARATOR = "\n";

#endif //__FILEMERGESORT_H


main.c

#include <stdlib.h>
#include <string>
#include <iostream>
#include "mergesort.h"
#include "filemergesort.h"

using namespace std;


int main()
{
	FileMergeSort fileMergeSort("\n", 1024*1024*10);
	int ret = fileMergeSort.sort("Quote.csv");
	std::cout << ret << std::endl;

	system("pause");
	return 0;
}


Quote.csv

1373871611,SH600000,8.56,8.57,8.56,8.55,8.71,8.41,8.49,891040704.00,1038509.00
1373871665,SH600005,2.31,2.32,2.31,2.31,2.35,2.30,2.31,45215176.00,194893.00
1373871626,SH600009,12.81,12.82,12.81,12.86,13.07,12.73,12.80,39855712.00,30992.00
1373871665,SH600010,4.08,4.09,4.08,4.05,4.13,4.01,4.05,197604608.00,485515.00
1373871607,SH600011,5.46,5.47,5.47,5.45,5.56,5.43,5.50,123869376.00,226039.00
1373871626,SH600015,9.37,9.38,9.37,9.28,9.55,9.24,9.21,290867808.00,309105.00
1373871605,SH600016,9.15,9.16,9.16,9.16,9.41,9.00,9.11,1331242880.00,1451737.00
1373871607,SH600019,4.07,4.08,4.07,4.05,4.11,4.03,4.03,73100704.00,180051.00
1373871605,SH600022,1.63,1.64,1.64,1.62,1.65,1.61,1.63,19511916.00,119705.00
1373871600,SH600027,3.14,3.15,3.15,3.12,3.20,3.12,3.13,96782808.00,307247.00
1373871605,SH600028,4.55,4.56,4.56,4.59,4.62,4.52,4.59,283333152.00,619985.00
1373871611,SH600029,2.77,2.78,2.77,2.77,2.81,2.76,2.76,52826140.00,189341.00
1373871660,SH600030,10.96,10.97,10.96,10.80,11.29,10.65,10.54,1668629248.00,1518316.00
1373871603,SH600031,7.30,7.31,7.31,7.28,7.45,7.26,7.28,211298784.00,287873.00
1373871660,SH600036,11.66,11.67,11.65,11.74,11.91,11.55,11.62,789394304.00,674696.00
1373871603,SH600037,7.18,0.00,7.18,6.60,7.18,6.55,6.53,292799488.00,416500.00

......


Quote.csv.sorted

1373871600,SH600027,3.14,3.15,3.15,3.12,3.20,3.12,3.13,96782808.00,307247.00
1373871603,SH600031,7.30,7.31,7.31,7.28,7.45,7.26,7.28,211298784.00,287873.00
1373871603,SH600037,7.18,0.00,7.18,6.60,7.18,6.55,6.53,292799488.00,416500.00
1373871605,SH600016,9.15,9.16,9.16,9.16,9.41,9.00,9.11,1331242880.00,1451737.00
1373871605,SH600022,1.63,1.64,1.64,1.62,1.65,1.61,1.63,19511916.00,119705.00
1373871605,SH600028,4.55,4.56,4.56,4.59,4.62,4.52,4.59,283333152.00,619985.00
1373871607,SH600011,5.46,5.47,5.47,5.45,5.56,5.43,5.50,123869376.00,226039.00
1373871607,SH600019,4.07,4.08,4.07,4.05,4.11,4.03,4.03,73100704.00,180051.00
1373871611,SH600000,8.56,8.57,8.56,8.55,8.71,8.41,8.49,891040704.00,1038509.00
1373871611,SH600029,2.77,2.78,2.77,2.77,2.81,2.76,2.76,52826140.00,189341.00
1373871626,SH600009,12.81,12.82,12.81,12.86,13.07,12.73,12.80,39855712.00,30992.00
1373871626,SH600015,9.37,9.38,9.37,9.28,9.55,9.24,9.21,290867808.00,309105.00
1373871660,SH600030,10.96,10.97,10.96,10.80,11.29,10.65,10.54,1668629248.00,1518316.00
1373871660,SH600036,11.66,11.67,11.65,11.74,11.91,11.55,11.62,789394304.00,674696.00
1373871665,SH600005,2.31,2.32,2.31,2.31,2.35,2.30,2.31,45215176.00,194893.00
1373871665,SH600010,4.08,4.09,4.08,4.05,4.13,4.01,4.05,197604608.00,485515.00



piaopiaolanghua
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
归并排序的实现
08-11 1412
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。 //将有序数组a[]和b[]合并到c[]中 void Meme...
归并排序(C语言简单实现)
DFGOMC的博客
11-29 7711
归并排序(C语言简单实现) 归并排序（Merging Sort）利用的就是归并的思想实现的排序方法。原理是：假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到[n/2]个长度为2或1的有序子序列；再两两归并，如此重复，直到得到一个长度为n的有序序列为止，这种排序方法称为2路归并排序 。 递归 每次都将序列分一半，比如一个数组有18个数，那么第一次分出1-9和10-18，然后分别对两组继续分半，直到最后剩下一个元素时，即分好了组（此时全都是最小的组，只含一个元
【数据结构之排序8】归并排序
偶尔e网事
10-22 2244
归并排序(Merge Sort)是利用"归并"技术来进行排序。归并是指将若干个已排序的子文件合并成一个有序的文件。 两路归并算法 1、算法基本思路 设两个有序的子文件(相当于输入堆)放在同一向量中相邻的位置上：R[low..m]，R[m+1..high]，先将它们合并到一个局部的暂存向量R1(相当于输出堆)中，待合并完成后将R1复制回R[low..high]中。 （1）
文件操作 归并排序
hello, coder~
12-21 212
题 意：两个文件里有从小到大的数 将其合并(从小到大)输出到第三个文件 Notice：数据的读入与输出 思 路：用fscanf一个一个读取两个文件的数字num1和num2，并进行比较； 取小的，并再读该文件的下一个数，直至一个文件的结尾(feof()==1)； 将含有数字多的文件的剩余部分打印到第三个文件。 #include<stdio.h> #include<stdlib.h> #include&l...
归并排序-归并排序
Code-lover's Learning Notes
08-21 1452
归并排序(Merge Sort)是利用"归并"技术来进行排序。归并是指将若干个已排序的子文件合并成一个有序的文件。 两路归并算法 1、算法基本思路 　设两个有序的子文件(相当于输入堆)放在同一向量中相邻的位置上：R[low..m]，R[m+1..high]，先将它们合并到一个局部的暂存向量R1(相当于输出堆)中，待合并完成后将R1复制回R[low..high]中。 （1）合并过
【数据结构】文件的归并排序
m0_74044018的博客
07-17 664
如果一个文件中很多数据，需要你排序，内存空间又不太多的情况下该如何利用好归并排序的问题。（便于深入理解文件知识）
go专业数据结构与算法高级
12-06
本节为go专业数据结构与算法高级，继续讲解go中的数据结构以及相关的算法。 
Java实现归并排序.rar
06-16
归并排序是一种经典的排序算法，基于分治策略。...总的来说，Java实现归并排序涉及的主要知识点包括分治策略、递归、数组操作以及合并算法的设计。通过熟练掌握这些概念，可以有效地在实际编程中实现高效的排序功能。
C++实现归并排序（MergeSort）
12-20
**二、C++实现归并排序的代码解析** 1. **合并两个有序的序列**： - `Merge`函数是归并排序的核心，它接收三个参数：原始数组`arr`，子数组的起始索引`start`，中间索引`mid`，以及结束索引`end`。 - 首先，创建...
C++实现合并排序的方法
09-03
由于其稳定性和较高的效率，它是许多高级排序算法的基础，如归并排序树和多路合并排序。 通过上述步骤，我们可以实现一个高效的C++合并排序程序。在实际应用中，可以考虑优化内存使用，例如使用自平衡二叉查找树...
Python文件操作及多路归并排序
05-05
文本文件内容排序功能： 每行是一条记录，每行可以有多列，列间按预定义的分隔符分隔； 可以按单列或多列组合排序，每列的顺序可以设置为反序或者正序； 列的数据类型可以是字符串、整数、浮点数，比较排序时按指定的数据类型比较大小； 排序算法可以单线程执行（适用于小文件），也可以多线程执行（适用于大文件，分隔排序后再归并）； 使用了如下技术要点： 命令行参数 面向对象 字符串解析 文件读取，写入 多线程、线程池、队列、线程同步 文件归并排序 命令行说明： sort.py -i -o [-d ] [-c ] [-s ] [-t ] -i 输入源文件名 -o 输出目标文件名，如果未指定，则结果覆盖到源文件 -d 可选项，文件文本行的列分隔符，默认是空格 -c 可选项，相关排序列信息，包括列号（从1开始，按出现顺序优先级排序）、数据类型（i：整数，f：浮点数，默认：字符串）、是否反序（r）， 默认按第一列字符串类型正序（升序）排序 -s 可选项，源文件分段最大行数，如果不指定则单线程执行，否则多线程执行排序 -t 可选项，线程数，指定-s参数时生效，默认值：2
Python实现的归并排序算法示例
12-24
在实际应用中，归并排序常被用于数据库系统、文件系统的排序以及大数据处理等领域，尤其是需要稳定性和高效性的场景。同时，由于归并排序的分治特性，它也常常被用作教学示例，帮助初学者理解分治算法的设计和实现。
C语言实现十大排序算法.rar
最新发布
11-21
以上就是“C语言实现十大排序算法.rar”文件中包含的排序算法介绍。通过学习这些排序算法的C语言实现，可以深入理解各种排序方法的工作原理，提高编程能力，并有助于在实际问题中选择合适的排序算法。
算法面试题- 合并排好序的小文件成一个单独的大文件
shenyanxxxy的专栏
11-20 1406
现在你有 10 个日志文件，每个日志文件大小约 300MB，每个文件里的日志都是按照时间戳从小到大排序的。你希望将这 10 个较小的日志文件，合并为 1 个日志文件，合并之后的日志仍然按照时间戳从小到大排列。如果处理上述排序任务的机器内存只有 1GB，你有什么好的解决思路，能“快速”地将这 10 个日志文件合并吗？ 解法1： 先读取每个文件的开头和结尾 timestamp，然后以中间的start 作为分界点pivot，将日志文件分拆成两份，一份是大于pivot（若干文件），一份是小于pivot（若干.
大文件 多路归并 排序
张之海的博客
09-21 6114
1 题目 这一种题目的描述，大概有以后两种： 题目1：一个大文件在一台服务器上存不下，需要存放在多台服务器上，将这个大文件的内容进行排序。 题目2：一个大文件100G，存储在磁盘上，现在需要对这个文件的内容进行排序，而内存装不下整个文件。 2 分割为小文件+多路归并排序 基本思路： step1：分割+排序 从头开始将大文件FileFileFile的一个小部分读入内存中，将这一小部分进行排序...
php对10g文件进行排序,归并排序，外排序，10G文件500M内存的排序
weixin_30135925的博客
03-11 457
归并排序可以是一种外排序，　外排序是指利用外存也就是磁盘进行排序的一种简称。典型的应用是hadoop　的 mapreduce 的merge 阶段归并排序的：　假设有n　个元素，　将n 个元素分程x　组, 然后对每一组的元素进行排序，　然后将这 x　组已经排好序的序列合并起来。说一下分成x　组的方式，　大概有两种：第一种：　递归的方式, 　这种情况你可能都不会去关心 x 大小。第二种：　每组　m　个...
排序算法之归并排序法
w512的专栏
11-13 991
归并排序算法 归并排序算法是一种外部存储设备最常用的排序算法，该排序法可以分为如下两个步骤： （1）将排序数据分为数个文件，其中每个文件的大小都是可以加载到内存空间，然后使用适当的内部排序算法进行排序，最后将排完序的数据写回文件中； （2）将第一个步骤创建的文件，两两归并称为了一个文件，最后，全部的文件都归并称为一个文件，则文件数据也就排序完成了。 如下图所示的例子： 一
大文件多路归并排序
Gikieng的奋斗路
01-05 2093
背景： 一堆小文件，每个文件中有10^6行的数字，要求将这些小文件合并成一个有序的文件。 实现思路： 先将每个小文件整理成有序，可以用多进程来处理。 同时打开排完序的文件（打开的文件数受限于系统允许打开文件数，ulimit -a 查看，ulimit -n 修改可允许打开文件数），维护一个堆，堆中元素为{文件描述符，当前偏移量，当前行值}，以当前行值比较。
log(n!) = Θ(n·log(n))
piaopiaolanghua的专栏
07-19 9119
参考：http://stackoverflow.com/questions/2095395/is-logn-nlogn 因为可以容易地证明出N^N是N!的一个上界，(N/2)^(N/2)是N!的下界。 所以N! =Θ(N^N)， 因为也就能推导出"log(n!) = Θ(n·log(n))"。 写的太粗糙了，忘了严谨的证明怎么写了，反正大概理解个思路就行。 哎，为什么要搞这个呢？
败者树实现5-路归并排序
多路归并排序是外部排序的一种常见方法，它将大文件分割成多个小文件，分别在内存中排序，然后使用败者树等方法进行多路合并。 学习排序算法时，理解每种算法的基本思想、分析其稳定性和时间复杂度是非常重要的。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

piaopiaolanghua

感谢鼓励，再接再厉！

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

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

打赏作者

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

抵扣说明：

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

余额充值