排序算法总结 数据结构_排序算法总结

作者fredal

https://www.jianshu.com/p/28d0f65aa6a1

所有内部排序算法的汇总表

现在Tb1和Tb2都包含一些连续的字符串。我们取出每盘磁带的第一个顺序字符串，并将它们组合起来，并将结果写入Ta1，Ta1是一个双长度的顺序字符串。然后，我们从每盘磁带中取出下一个连续的字符串，将其合并并写入Ta2。继续此过程，直到Tb1或Tb2为空。继续这个过程，直到我们得到一个长度为n的连续字符串

如果我们有额外的磁带，我们可以减少对输入数据进行排序的次数，我们可以通过将基本的(2路)合并扩展到(k路)合并来做到这一点。这叫做多路合并

上面讨论的k- way合并方案需要使用2k磁带。事实上，我们只需要使用k+1个磁带就可以完成排序工作，这就是所谓的多阶段合并。以三盘磁带完成双向合并为例:

这里序列的初始分布是个关键问题，其实斐波那契数是最好的。

对于序列的构造，也可以采用排列选择排序，采用堆的思想，有特殊的价值。

接下来，实现完整的外部排序

package com . fredal . structure；

import Java . io . file；

import Java . io . FileInputStream；

import Java . io . FileNotFoundException；

import Java . io . FileOutputStream；

import Java . io . IOexception；

import Java . util . ArrayList；

import Java . util . arrays；

import Java . util . iterator；

import Java . util . random；

publicclassExternalSort{

publicationstatintbuffer _ SIZE = 10；

公共文件排序(文件文件)抛出异常{

ArrayList<。文件>files = split(file)；

returnprocess(文件)；

}

//递归方法来合并列表，直到我们剩下一个

//单个合并列表

私有文件进程(数组列表& lt文件>list)throwsIOException {

if(list.size() == 1) {

return list . get(0)；

}

ArrayList<。文件>inter = newArrayList<。文件>();

for(迭代器& lt文件>itr = list . iterator()；itr . HasNeXt()；) {

file one = itr . next()；

if(itr.hasNext()) {

file two = itr . next()；

inter.add(合并(一、二))；

} else{

returnone

}

}

return process(inter)；

}

/**

*将原始文件分割成多个子文件。

*/

privateArrayList<。文件>分割(文件文件)抛出异常{

ArrayList<。文件>files = newArrayList & lt文件>();

int[]BUFFER = new int[BUFFER _ SIZE]；

FileInputStream fr = NewFileInputStream(文件)；

booleanfileComplete = false

while(！fileComplete) {

intindex = buffer.length

for(inti = 0；i <。缓冲区长度& amp& amp！fileCompletei++) {

buffer[I]= ReadInt(fr)；

if(buffer[i] == - 1) {

fileComplete = true

index = I；

}

}

if(缓冲区[ 0]>;- 1) {

Arrays.sort(buffer，0，index)；

File f = newFile( "set"+ newRandom()。nextInt())；

file output stream writer = NewFileoutput stream(f)；

for(intj = 0；j <。指数；j++) {

writeInt(buffer[j]，writer)；

}

writer . close()；

files . add(f)；

}

}

fr . close()；

returnfiles

}

/**

*将两个已排序的文件合并为一个文件。

*

* @paramone

* @paramtwo

* @返回

* @throwsIOException

*/

私有文件合并(文件一，文件二)抛出异常{

FileInputStream fis 1 = NewFileInputStream(一)；

file inputstream fis 2 = new file inputstream(两个)；

文件输出= newFile("合并"+ newRandom()。nextInt())；

file output stream OS = NewFileoutput stream(输出)；

inta = ReadInt(fis 1)；

int b = ReadInt(fis 2)；

booleanfinished = false

while(！完成){

if(a！=-1 & amp；& ampb！= - 1) {

if(a & lt；b) {

writeInt(a，OS)；

a = ReadInt(fis 1)；

} else{

writeInt(b，OS)；

b = ReadInt(fis 2)；

}

} else{

finished = true

}

if(a = =-1 & amp；& ampb！= - 1) {

writeInt(b，OS)；

b = ReadInt(fis 2)；

} else if(b = =-1 & amp；& ampa！= - 1) {

writeInt(a，OS)；

a = ReadInt(fis 1)；

}

}

OS . close()；

returnoutput

}

privatevoidwriteInt(intvalue，合并文件输出流)

throwsIOException {

merged . write(value)；

merged . write(value & gt；>。8);

merged . write(value & gt；>。16);

merged . write(value & gt；>。24);

merged . flush()；

}

private InTeradint(FileInputStream fis)throwSioException {

int buffer = fis . read()；

if(缓冲== - 1) {

return-1；

}

buffer | =(fis . read()& lt；& lt8);

buffer | =(fis . read()& lt；& lt16);

buffer | =(fis . read()& lt；& lt24);

returnbuffer

}

/**

* @paramargs

* @throwsIOException

*/

public static void main(String[]args)throwSioException {

file file = New FIle(" main set ")；

random random = new random(system . current timemillis())；

file output stream fw = NewFileoutput stream(文件)；

for(inti = 0；i <。BUFFER _ SIZE * 3；i++) {

int ger = random . Nextint()；

ger = ger <。0?-ger:ger；

fw . write(ger)；

fw . write(ger & gt；>。8);

fw . write(ger & gt；>。16);

fw . write(ger & gt；>。24);

}

fw . close()；

ExternalSort sort = new ExternalSort()；

system . out . println(" Original:")；

dumpFile(排序，文件)；

file f = sort . sort(file)；

system . out . println(" Sorted:")；

dumpFile(sort，f)；

}

私有静态无效转储文件(外部排序，文件f)

throwsFileNotFoundException，IOException {

FileInputStream fis = NewFileInputStream(f)；

inti = sort . readint(fis)；

while(i！= - 1) {

system . out . println(Integer . ToString(I))；

I = sort . readint(fis)；

}

}

}

长的

根据

接近

填充