作者丨fredal
https://www.jianshu.com/p/28d0f65aa6a1

所有內(nèi)部排序算法的一個總結(jié)表格

簡單選擇排序

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續(xù)尋找最小（大）元素，然后放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。

最差:O(n2)

最優(yōu):O(n2)

平均:O(n2)

public?void?selectSort(int[]?a){
????for(int?i=0;i<a.length-1;i++){
????????int?min=i;//最小元素所在位置
????????for(int?j=i+1;j<a.length;j++){
????????????if(a[j]<a[min])?min=j;
????????}
????????{int?temp=a[min];a[min]=a[i];a[i]=temp;}//交換元素,把最小元素放在頭部
????}
?}

冒泡排序

冒泡排序算法的運(yùn)作如下：

比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

對每一對相鄰元素作同樣的工作，從開始第一對到結(jié)尾的最后一對。這步做完后，最后的元素會是最大的數(shù)。

針對所有的元素重復(fù)以上的步驟，除了最后一個。

持續(xù)每次對越來越少的元素重復(fù)上面的步驟，直到?jīng)]有任何一對數(shù)字需要比較。

最差:O(n2)

最優(yōu):O(n)

平均:O(n2)

public?static?void?bubbleSort(int[]?a){
????for(int?i=0;i<a.length-1;i++){
????????for(int?j=0;j<a.length-i-1;j++){
????????????if(a[j]>a[j+1])?{int?temp=a[j];a[j]=a[j+1];a[j+1]=temp;}//交換元素位置?保證大的在后面
????????}
????}
?}

插入排序

一般來說，插入排序都采用in-place在數(shù)組上實現(xiàn)。具體算法描述如下：

從第一個元素開始，該元素可以認(rèn)為已經(jīng)被排序

取出下一個元素，在已經(jīng)排序的元素序列中從后向前掃描

如果該元素（已排序）大于新元素，將該元素移到下一位置

重復(fù)步驟3，直到找到已排序的元素小于或者等于新元素的位置

將新元素插入到該位置后

重復(fù)步驟2~5

最差:O(n2)

最優(yōu):O(n)

平均:O(n2)

直接插入排序:

public?static?void?insertSort(int[]?a){
????for(int?i=1;i<a.length;i++){
????????for(int?j=0;j<=i;j++){
????????????if(a[j]>=a[i]){//找到了第一個比自己大的元素,插入到該元素之前
????????????????int?temp=a[i];
????????????????for(int?k=i-1;k>=j;k--)?a[k+1]=a[k];//每個元素向后移動一格
????????????????a[j]=temp;
????????????????break;
????????????}
????????}
????}
?}

折半插入排序:?

就是尋找第一個比自己大的元素的時候用折半查找進(jìn)行優(yōu)化:

public?static?void?halfInsertSort(int[]?a){
????for(int?i=1;i<a.length;i++){
????????int?low=0;
????????int?high=i;
????????while(low<=high){
????????????int?half=(low+high)/2;
????????????if(a[half]<a[i]){//插入點(diǎn)在高半?yún)^(qū)
????????????????low=half+1;
????????????}else{//插入點(diǎn)在低半?yún)^(qū)
????????????????high=half-1;
????????????}
????????}
????????//low或者h(yuǎn)igh指向的元素就是第一個比自己大的元素?插入到之前
????????int?temp=a[i];
????????for(int?k=i-1;k>=low;k--)?a[k+1]=a[k];//每個元素向后移動一格
????????a[low]=temp;
????}
?}

快速排序

快速排序使用分治法策略來把一個序列（list）分為兩個子序列（sub-lists）。

步驟為：

從數(shù)列中挑出一個元素，稱為"基準(zhǔn)"（pivot)

重新排序數(shù)列，所有元素比基準(zhǔn)值小的擺放在基準(zhǔn)前面，所有元素比基準(zhǔn)值大的擺在基準(zhǔn)的后面（相同的數(shù)可以到任一邊）。在這個分區(qū)結(jié)束之后，該基準(zhǔn)就處于數(shù)列的中間位置。這個稱為分區(qū)（partition）操作。

遞歸地（recursive）把小于基準(zhǔn)值元素的子數(shù)列和大于基準(zhǔn)值元素的子數(shù)列排序。

最差:O(n2)

最優(yōu):O(n log n)

平均:O(n log n)

//這里left取0,right取a.length-1
?public?static?void?quickSort(int[]?a,int?left,int?right){
????if(left<right){//遞歸出口條件
????????int?i=left;//左指針
????????int?j=right;//右指針
????????int?x=a[left];//選擇第一個元素作為標(biāo)尺
????????while(i<j){
????????????while(i<j?&&?a[j]>=x)?j--;//從右向左找第一個小于x的數(shù)
????????????if(i<j)?a[i++]=a[j];
????????????while(i<j?&&?a[i]<x)?i++;//從左向右找第一個大于等于x的數(shù)
????????????if(i<j)?a[j--]=a[i];
????????}
????????a[i]=x;//插入標(biāo)尺
????????quickSort(a,left,i-1);//遞歸左邊
????????quickSort(a,?i+1,?right);//遞歸右邊
????}
?}

當(dāng)前選取第一個元素作為標(biāo)尺是比較不好的,一種安全的做法是隨記選取,但是也不好.我們一般采用三數(shù)中值分割法,就是使用左端,右端,中心位置上的三個元素的中位數(shù)作為標(biāo)尺進(jìn)行排序.

public?static?void?quickSortS(int[]?a,int?left,int?right){
????if(left<right){//遞歸出口條件
????????????int?i=left;//左指針
????????????int?j=right;//右指針
????????????int?center=(left+right)/2;
????????????//三數(shù)中值分割法選取標(biāo)尺
????????????if((a[left]<=a[center]&&a[center]<=a[right])||(a[right]<=a[center]&&a[center]<=a[left])){
????????????????int?tmp=a[left];
????????????????a[left]=a[center];
????????????????a[center]=tmp;//記得交換噢
????????????}else?if((a[left]<=a[right]&&a[right]<=a[center])||(a[center]<=a[right]&&a[right]<=a[left])){
????????????????int?tmp=a[left];
????????????????a[left]=a[right];
????????????????a[right]=tmp;
????????????}
????????????int?x=a[left];//標(biāo)尺
????????????while(i<j){
????????????????while(i<j?&&?a[j]>=x)?j--;//從右向左找第一個小于x的數(shù)
????????????????if(i<j)?a[i++]=a[j];
????????????????while(i<j?&&?a[i]<x)?i++;//從左向右找第一個大于等于x的數(shù)
????????????????if(i<j)?a[j--]=a[i];
????????????}?
????????????a[i]=x;//插入標(biāo)尺
????????????quickSortS(a,left,i-1);//遞歸左邊
????????????quickSortS(a,?i+1,?right);//遞歸右邊
????????}
??}

希爾排序

希爾排序，也稱遞減增量排序算法，是插入排序的一種更高效的改進(jìn)版本。希爾排序是非穩(wěn)定排序算法。

根據(jù)步長進(jìn)行分組,對每一組進(jìn)行插入排序.

最差:O(因步長各異,最好的n log2 n)

最優(yōu):O(n)

平均:O(因步長各異)

public?static?void?shellSort(int[]?a){
????int?igap=a.length;//初始化步長,第一次步長為數(shù)組長度的一半
????for(int?gap=igap/2;gap>0;gap/=2){//步長
????????for(int?i=0;i<gap;i++){//共做步長次插入排序
????????????for(int?j=i+gap;j<a.length;j+=gap){//直接插入排序算法
????????????????for(int?k=i;k<=j;k++){
????????????????????if(a[k]>=a[j]){//找到了第一個比自己大的元素,插入到該元素之前
????????????????????????int?temp=a[j];
????????????????????????for(int?p=j-1;p>=k;p--)?a[p+1]=a[p];//每個元素向后移動一格
????????????????????????a[k]=temp;
????????????????????????break;
????????????????????}
????????????????}
????????????}
????????}
????}
?}

歸并排序

原理如下（假設(shè)序列共有n個元素）：

將序列每相鄰兩個數(shù)字進(jìn)行歸并操作，形成floor(n/2)個序列，排序后每個序列包含兩個元素

將上述序列再次歸并，形成floor(n/4)個序列，每個序列包含四個元素

重復(fù)步驟2，直到所有元素排序完畢

最差:O(n logn)

最優(yōu):O(n)

平均:O(n log n)

public?static?void?mergeSort(int[]?a,int?first,int?last){
????if(first<last){
????????int[]?temp=new?int[a.length];
????????int?middle=(first+last)/2;
????????mergeSort(a,?first,?middle);//遞歸左邊
????????mergeSort(a,?middle+1,?last);//遞歸右邊
????????//將兩個有序數(shù)列合并
????????int?i=first;
????????int?j=middle+1;
????????int?k=0;
????????while(i<=middle&&j<=last){
????????????if(a[i]<=a[j]){
????????????????temp[k++]=a[i++];
????????????}else{
????????????????temp[k++]=a[j++];
????????????}
????????}
????????while(i<=middle){
????????????temp[k++]=a[i++];
????????}
????????while(j<=last){
????????????temp[k++]=a[j++];
????????}
????????//將排好的temp重新賦給a
????????for(i=0;i<k;i++){
????????????a[first+i]=temp[i];
????????}
????}
?}

樹形選擇排序

樹形選擇排序（Tree Selection Sort），又稱錦標(biāo)賽排序（Tournament Sort），是一種按照錦標(biāo)賽思想進(jìn)行選擇排序的方法。

首先對n個記錄的關(guān)鍵字進(jìn)行兩兩比較，然后在其中[n/2]（向上取整）個較小者之間再進(jìn)行兩兩比較，如此重復(fù)，直至選出最小關(guān)鍵字的記錄為止。

這個過程可以用一顆有n個葉子節(jié)點(diǎn)的完全二叉樹表示,每個非終端節(jié)點(diǎn)都是左右孩子中的較小值,這樣根節(jié)點(diǎn)就是所有葉子節(jié)點(diǎn)中的最小值了.把這個值輸出后,將葉子節(jié)點(diǎn)中的最小值改為"最大值",然后從該葉子節(jié)點(diǎn)開始,和其左右兄弟進(jìn)行比較,修改從葉子節(jié)點(diǎn)到根節(jié)點(diǎn)的路徑上各節(jié)點(diǎn)的值,則根節(jié)點(diǎn)的值為次小值.同理,可從小到大排出所有值.

雖然說樹,但是通常由數(shù)組實現(xiàn),父節(jié)點(diǎn)i的左子節(jié)點(diǎn)在位置(2i+1);父節(jié)點(diǎn)i的右子節(jié)點(diǎn)在位置(2i+2);子節(jié)點(diǎn)i的父節(jié)點(diǎn)在位置floor((i-1)/2)

時間復(fù)雜度為O(n log n)

缺點(diǎn)是輔助存儲空間太多,并且與"最大值"進(jìn)行了多余的比較.

public?static?int[]?TreeSelectSort(int[]?data){
????????int?dlong=data.length;
????????int?tlong=2*dlong-1;
????????int?low=0;
????????int[]?tree=new?int[tlong];
????????int[]?ndata=new?int[dlong];

????????for(int?i=0;i<dlong;i++){
????????????tree[tlong-i-1]=data[i];
????????}

????????for(int?i=tlong-1;i>0;i-=2){
????????????tree[(i-1)/2]=(tree[i]<tree[i-1]?tree[i]:tree[i-1]);
????????}

????????int?minIndex;
????????while(low<dlong){
????????????int?min=tree[0];
????????????ndata[low++]=min;
????????????minIndex=tlong-1;
????????????//找到最小值
????????????while(tree[minIndex]!=min){
????????????????minIndex--;
????????????}
????????????tree[minIndex]=Integer.MAX_VALUE;
????????????//找到其兄弟節(jié)點(diǎn)
????????????while(minIndex>0){//有父節(jié)點(diǎn)
????????????????if(minIndex%2==0){//是右節(jié)點(diǎn)
????????????????????tree[(minIndex-1)/2]=(tree[minIndex]<tree[minIndex-1]?tree[minIndex]:tree[minIndex-1]);
????????????????????minIndex=(minIndex-1)/2;
????????????????}else{//是左節(jié)點(diǎn)
????????????????????tree[minIndex/2]=(tree[minIndex]<tree[minIndex+1]?tree[minIndex]:tree[minIndex+1]);
????????????????????minIndex=minIndex/2;
????????????????}
????????????}
????????}
????????return?ndata;

????}

堆排序

堆排序是對樹形選擇排序的一種優(yōu)化,建立在"二叉堆"這種數(shù)據(jù)結(jié)構(gòu)上,二叉堆屬于完全二叉樹,除此之外還需滿足所有父節(jié)點(diǎn)都要大于或小于左右子樹.

父節(jié)點(diǎn)大于左右孩子的叫最大二叉堆,父節(jié)點(diǎn)小于左右孩子的叫最小二叉堆.

以最大二叉堆為基礎(chǔ)進(jìn)行排序,就是先構(gòu)建成一個最大堆,接著取出根節(jié)點(diǎn),然后將剩下的數(shù)組元素在建成一個最大二叉堆,再取出根節(jié)點(diǎn),如此循環(huán)直到所有元素都被取光.

和樹形選擇排序一樣也是由數(shù)組實現(xiàn),參考上一節(jié).

最壞,最優(yōu)和平均的時間復(fù)雜度都是nlogn.

public?static?void?heapSort(int[]?a){
????????//建立最大堆
????????int?size=a.length;
????????for(int?i=(size-1-1)/2;i>=0;i--){
????????????maxHeap(i,a,size);
????????}

????????for(int?i=a.length-1;i>0;i--){
????????????//將根節(jié)點(diǎn)上的最大值不斷與最后一個交換,并將最后一個篩選出來,指向最后的指針向前推進(jìn)
????????????int?temp=a[i];
????????????a[i]=a[0];
????????????a[0]=temp;
????????????size--;
????????????//保證根節(jié)點(diǎn)最大特性,其他節(jié)點(diǎn)都已經(jīng)保持了
????????????maxHeap(0,?a,size);
????????}
????}

????//保持堆的最大特性
????private?static?void?maxHeap(int?i,int[]?a,int?size)?{
????????int?left=2*i+1;
????????int?right=2*i+2;
????????int?largest=i;
????????//分別與左右子樹比較,取最大值
????????if(left<=size-1&&a[left]>a[i]){
????????????largest=left;
????????}
????????if(right<=size-1&&a[right]>a[largest]){
????????????largest=right;
????????}
????????if(largest!=i){
????????????//交換根節(jié)點(diǎn)與最大值
????????????int?temp=a[i];
????????????a[i]=a[largest];
????????????a[largest]=temp;
????????????//遞歸
????????????maxHeap(largest,?a,size);
????????}

????}

桶排序

桶排序(Bucket Sort)的原理很簡單，它是將數(shù)組分到有限數(shù)量的桶子里。

假設(shè)待排序的數(shù)組a中共有N個整數(shù)，并且已知數(shù)組a中數(shù)據(jù)的范圍[0, MAX)。在桶排序時，創(chuàng)建容量為MAX的桶數(shù)組r，并將桶數(shù)組元素都初始化為0；將容量為MAX的桶數(shù)組中的每一個單元都看作一個"桶"。

在排序時，逐個遍歷數(shù)組a，將數(shù)組a的值，作為"桶數(shù)組r"的下標(biāo)。當(dāng)a中數(shù)據(jù)被讀取時，就將桶的值加1。例如，讀取到數(shù)組a[3]=5，則將r[5]的值+1。

桶排序的時間復(fù)雜度為O(n+k),k為取值范圍,在特殊情況下提供了排序的下界.

public?static?void?bucketSort(int[]?a,int?max){
????????int[]?buckets;
????????if(a==null||max<1){
????????????return;
????????}
????????buckets=new?int[max];//創(chuàng)建一個容量為max的數(shù)組?并將其數(shù)據(jù)都初始化為0

????????//計數(shù)
????????for(int?i=0;i<a.length;i++){
????????????buckets[a[i]]++;
????????}
????????//排序
????????for(int?i=0,j=0;i<max;i++){
????????????while((buckets[i]--)>0){
????????????????a[j++]=i;
????????????}
????????}

????????buckets=null;
????}

基數(shù)排序(多關(guān)鍵字排序)

基數(shù)排序已經(jīng)不再是一種常規(guī)的排序方式，它更多地像一種排序方法的應(yīng)用，基數(shù)排序必須依賴于另外的排序方法。基數(shù)排序的總體思路就是將待排序數(shù)據(jù)拆分成多個關(guān)鍵字進(jìn)行排序，也就是說，基數(shù)排序的實質(zhì)是多關(guān)鍵字排序。

多關(guān)鍵字排序時有兩種解決方案：

最高位優(yōu)先法（MSD）(Most Significant Digit first)

最低位優(yōu)先法（LSD）(Least Significant Digit first)

這里我們采用LSD,對關(guān)鍵字的排序采用桶排序,那么實質(zhì)上就變成了多次桶排序.

時間復(fù)雜度為O(d(n+k),d為關(guān)鍵字個數(shù),k為取值范圍

數(shù)字是四位數(shù)之內(nèi),所以四個關(guān)鍵字為個十百千位的值.

//假定四位數(shù)字內(nèi)比較,有四個關(guān)鍵字,個十百千位,同一關(guān)鍵字使用桶排序
????public?static?void?radixSort(int[]?a,int?max,int?d){
????????int?rate=1;//表示關(guān)鍵字層級
????????int[]?buckets=new?int[max];//存放個位數(shù),十位數(shù),百位數(shù)....
????????List<Integer>[]?temp=new?List[max];//存放緩存數(shù)字
????????for(int?i=0;i<d;i++){

????????????//清空操作
?????????????Arrays.fill(buckets,?0);
?????????????Arrays.fill(temp,?null);

?????????????//計算每個待排序數(shù)據(jù)的子關(guān)鍵字
????????????for(int?j=0;j<a.length;j++){
????????????????int?subKey=(a[j]/rate)%max;//取得個位數(shù),十位數(shù),百位數(shù)...
????????????????if(temp[subKey]==null)?temp[subKey]=new?ArrayList<Integer>();//用list數(shù)組來存放緩存數(shù)字
????????????????temp[subKey].add(a[j]);
????????????????buckets[subKey]++;//計數(shù)+1
????????????}

????????????//進(jìn)行排序,就是按順序取
????????????for(int?j=0,k=0;j<max;j++){
????????????????int?t=0;
????????????????while((buckets[j]--)>0){
????????????????????a[k++]=temp[j].get(t);
????????????????????t++;
????????????????}
????????????}

????????????rate*=max;
????????}
????}

由于數(shù)組操作起來是比較麻煩,非要通過數(shù)組存儲的話只能存儲次數(shù)不能存儲整個數(shù)字,那取出來的時候我還沒想到好的方法把它還原成數(shù)字了.所以我就采取了很笨的方法,再用一個緩存list數(shù)組存數(shù)字...

當(dāng)然這很浪費(fèi)空間,也很麻煩,直接用鏈表簡單很多

public?static?void?linkedRadixSort(int[]?a,int?max,int?d){
????????ArrayList<ArrayList>?list=new?ArrayList<ArrayList>();
????????int?rate=1;

????????for(int?i=0;i<d;i++){????
????????????list.clear();
????????????for(int?j=0;j<max;j++){
????????????????list.add(new?ArrayList<Integer>());
????????????}
????????????for(int?j=0;j<a.length;j++){
????????????????int?num=a[j];
????????????????int?subKey=(num/rate)%max;
????????????????list.get(subKey).add(num);
????????????}????
????????????for(int?j=0,k=0;j<max;j++){
????????????????while(list.get(j).size()>0?&&?list.get(j)!=null){
????????????????????a[k]=(Integer)?list.get(j).remove(0);
????????????????????k++;
????????????????}????
????????????}

????????????rate*=max;
????????}
????}

雖然說是用鏈表的,但是收集起來的時候仍然是放數(shù)組的,仍要開辟許多空間.于是我們采用鏈?zhǔn)交鶖?shù)排序

所謂鏈?zhǔn)?就是用鏈表存儲,前一個分組的尾指針指向下一個分組的頭指針這樣,這樣鏈表很容易做到.

public?static?void?linkedRadixSortS(Integer[]?a,int?max,int?d){
????????List<Integer>?slist=new?ArrayList<Integer>();
????????ArrayList<ArrayList>?list=new?ArrayList<ArrayList>();
????????int?rate=1;
????????slist.addAll(Arrays.asList(a));

????????for(int?i=0;i<d;i++){????
????????????list.clear();
????????????for(int?j=0;j<max;j++){
????????????????list.add(new?ArrayList<Integer>());
????????????}
????????????while(slist.size()>0){
????????????????int?num=slist.remove(0);
????????????????int?subKey=(num/rate)%max;
????????????????list.get(subKey).add(num);
????????????}????
????????????for(int?j=0;j<max;j++){
????????????????slist.addAll(list.get(j));????
????????????}
????????????rate*=max;
????????}


????????a=slist.toArray(a);
????}

上面三種只是空間上的優(yōu)化,對于時間復(fù)雜度是沒有影響的.

外部排序

之前所有的排序算法都屬于內(nèi)部排序,需要將輸入數(shù)據(jù)裝入內(nèi)存中.然而在一些應(yīng)用程序中,它們的輸入數(shù)據(jù)量太大裝不進(jìn)內(nèi)存,這時候就需要外部排序了.

基本外部排序算法使用歸并排序.設(shè)有四盤磁帶,Ta1,Ta2,Tb1,Tb2,磁帶a和磁帶b或者用作輸入磁帶,或者用于輸出磁帶.從輸入磁帶一次讀入M(我們?nèi)?)個記錄,在內(nèi)部將這些記錄排序,然后再交替地寫到Tb1或Tb2上,將每組排過序的記錄叫做一個順串.

現(xiàn)在Tb1和Tb2都包含了一些順串.我們將每個磁帶的第一個順串取出將兩者合并,把結(jié)果寫到Ta1上,該結(jié)果是一個二倍長的順串.然后我們再從每盤磁帶取出下一個順串,合并然后寫到Ta2上.繼續(xù)這個過程直達(dá)Tb1或Tb2為空.繼續(xù)這個過程直到得到長為N的一個順串,這個算法需要log(N/M)趟工作,見下圖

如果我們有額外的磁帶,那么我們可以減少將輸入數(shù)據(jù)排序的趟數(shù),將基本的(2-路)合并擴(kuò)充為(k-路)合并就可以做到這一點(diǎn).這就是所謂的多路合并

上面討論的k-路合并方案需要使用2k盤磁帶,其實我們通過只使用k+1盤磁帶也可以完成排序的工作,就是所謂的多相合并.以三盤磁帶完成2-路合并為例:

這兒順串最初的分配是一個關(guān)鍵的問題,其實采用斐波那契數(shù)是最優(yōu)的.
對于順串的構(gòu)造還可以采用置換選擇排序,采用堆的思想構(gòu)建,具有特別的價值.

接下來實現(xiàn)完整的外部排序

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;

public?class?ExternalSort?{

????public?static?int?BUFFER_SIZE?=?10;

????public?File?sort(File?file)?throws?IOException?{
????????ArrayList<File>?files?=?split(file);
????????return?process(files);
????}

????//?recursive?method?to?merge?the?lists?until?we?are?left?with?a
????//?single?merged?list
????private?File?process(ArrayList<File>?list)?throws?IOException?{
????????if?(list.size()?==?1)?{
????????????return?list.get(0);
????????}
????????ArrayList<File>?inter?=?new?ArrayList<File>();
????????for?(Iterator<File>?itr?=?list.iterator();?itr.hasNext();)?{
????????????File?one?=?itr.next();
????????????if?(itr.hasNext())?{
????????????????File?two?=?itr.next();
????????????????inter.add(merge(one,?two));
????????????}?else?{
????????????????return?one;
????????????}
????????}
????????return?process(inter);
????}

????/**
?????*?Splits?the?original?file?into?a?number?of?sub?files.?
?????*/
????private?ArrayList<File>??split(File?file)?throws?IOException?{
????????ArrayList<File>?files?=?new?ArrayList<File>();
????????int[]?buffer?=?new?int[BUFFER_SIZE];
????????FileInputStream?fr?=?new?FileInputStream(file);
????????boolean?fileComplete?=?false;
????????while?(!fileComplete)?{
????????????int?index?=?buffer.length;
????????????for?(int?i?=?0;?i?<?buffer.length?&&?!fileComplete;?i++)?{
????????????????buffer[i]?=?readInt(fr);
????????????????if?(buffer[i]?==?-1)?{
????????????????????fileComplete?=?true;
????????????????????index?=?i;
????????????????}
????????????}
????????????if?(buffer[0]?>?-1)?{
????????????????Arrays.sort(buffer,?0,?index);
????????????????File?f?=?new?File("set"?+?new?Random().nextInt());
????????????????FileOutputStream?writer?=?new?FileOutputStream(f);
????????????????for?(int?j?=?0;?j?<?index;?j++)?{
????????????????????writeInt(buffer[j],?writer);
????????????????}
????????????????writer.close();
????????????????files.add(f);
????????????}

????????}
????????fr.close();
????????return?files;
????}

????/**
?????*?Merges?two?sorted?files?into?a?single?file.
?????*?
?????*?@param?one
?????*?@param?two
?????*?@return
?????*?@throws?IOException
?????*/
????private?File?merge(File?one,?File?two)?throws?IOException?{
????????FileInputStream?fis1?=?new?FileInputStream(one);
????????FileInputStream?fis2?=?new?FileInputStream(two);
????????File?output?=?new?File("merged"?+?new?Random().nextInt());
????????FileOutputStream?os?=?new?FileOutputStream(output);
????????int?a?=?readInt(fis1);
????????int?b?=?readInt(fis2);
????????boolean?finished?=?false;
????????while?(!finished)?{
????????????if?(a?!=?-1?&&?b?!=?-1)?{
????????????????if?(a?<?b)?{
????????????????????writeInt(a,?os);
????????????????????a?=?readInt(fis1);
????????????????}?else?{
????????????????????writeInt(b,?os);
????????????????????b?=?readInt(fis2);
????????????????}
????????????}?else?{
????????????????finished?=?true;
????????????}

????????????if?(a?==?-1?&&?b?!=?-1)?{
????????????????writeInt(b,?os);
????????????????b?=?readInt(fis2);
????????????}?else?if?(b?==?-1?&&?a?!=?-1)?{
????????????????writeInt(a,?os);
????????????????a?=?readInt(fis1);
????????????}
????????}
????????os.close();
????????return?output;
????}

????private?void?writeInt(int?value,?FileOutputStream?merged)
????????????throws?IOException?{
????????merged.write(value);
????????merged.write(value?>>?8);
????????merged.write(value?>>?16);
????????merged.write(value?>>?24);
????????merged.flush();
????}

????private?int?readInt(FileInputStream?fis)?throws?IOException?{
????????int?buffer?=?fis.read();
????????if?(buffer?==?-1)?{
????????????return?-1;
????????}
????????buffer?|=?(fis.read()?<<?8);
????????buffer?|=?(fis.read()?<<?16);
????????buffer?|=?(fis.read()?<<?24);
????????return?buffer;
????}

????/**
?????*?@param?args
?????*?@throws?IOException
?????*/
????public?static?void?main(String[]?args)?throws?IOException?{
????????File?file?=?new?File("mainset");
????????Random?random?=?new?Random(System.currentTimeMillis());
????????FileOutputStream?fw?=?new?FileOutputStream(file);
????????for?(int?i?=?0;?i?<?BUFFER_SIZE?*?3;?i++)?{
????????????int?ger?=?random.nextInt();
????????????ger?=?ger?<?0???-ger?:?ger;
????????????fw.write(ger);
????????????fw.write(ger?>>?8);
????????????fw.write(ger?>>?16);
????????????fw.write(ger?>>?24);
????????}
????????fw.close();
????????ExternalSort?sort?=?new?ExternalSort();
????????System.out.println("Original:");
????????dumpFile(sort,?file);
????????File?f?=?sort.sort(file);
????????System.out.println("Sorted:");
????????dumpFile(sort,?f);

????}

????private?static?void?dumpFile(ExternalSort?sort,?File?f)
????????????throws?FileNotFoundException,?IOException?{
????????FileInputStream?fis?=?new?FileInputStream(f);
????????int?i?=?sort.readInt(fis);
????????while?(i?!=?-1)?{
????????????System.out.println(Integer.toString(i));
????????????i?=?sort.readInt(fis);
????????}
????}

}

總結(jié)

以上是生活随笔為你收集整理的数据结构_排序算法总结的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。