Ejemplo de código de clasificación de fusión
El principio de ordenación por fusión
El principio de funcionamiento de la ordenación por fusión es el siguiente (suponiendo que la secuencia *** tiene n elementos):
Para cada dos elementos en la secuencia Los números vecinos se fusionan para formar una secuencia de límite inferior (n/2). Después de ordenar, cada secuencia contiene dos elementos.
Las secuencias anteriores se fusionan nuevamente para formar una secuencia de límite inferior (n/). 4) secuencia. Cada secuencia contiene cuatro elementos
Repita el paso 2 hasta que todos los elementos estén ordenados
Código de muestra
Ir a func?mergeSort(r?[] int) ?[]int?{longitud:=?len(r)si?longitud?<=?1?{retorno?(resultado?[]int)?{l, r:=?0,?0para?l? * Fusión bidireccional* Principio: fusionar dos listas ordenadas y una lista ordenada* * * @ param a * @param s * La primera lista ordenada Subíndice inicial * @param m * Subíndice inicial de la segunda lista ordenada * @param t * Subíndice final de la segunda lista ordenada * */private static void merge(int[] a, int s, int m, int t) {int[] tmp = nuevo int [t - s + 1]; int i = s, j = m, k = 0; while (i < m && j <= t) {si (a[i] <= a[j]) {tmp[k] = a[i];k++;i++;} else {tmp[k] = a[j];j++;k++;}}mientras (i < m) {tmp[k] = a[i ];i++;k++;}mientras (j <= t) {tmp[k] = a[j];j++;k++;}System.Arraycopy(tmp)arraycopy(tmp, 0, a, s, tmp.length) ;}/** * * @param a * @param s * @param len * La longitud del conjunto ordenado durante cada fusión*/public static void mergeSort(int[] a, int s, int len) {int size = a.length; int mid = size / (len << 1); int c = size & ((len < ; < 1) - 1);// ---- --- Finaliza el algoritmo cuando solo hay uno. ordenado establecido a la izquierda ------- //if (mid == 0)return; // ------ Realizar una combinación y ordenar ------- -- //for (int i = 0; i < medio; ++i) {s = i * 2 * len;merge( a, s, s + len, (len <
;< 1) + s - 1);}// ------- Utilice el conjunto inverso del conjunto ordenado para fusionar los números restantes -------// if (c != 0)merge (a, tamaño - c - 2 * len, tamaño - c, tamaño - 1);// ------- Ejecutar recursivamente el siguiente tipo de combinación ------// mergeSort(a, 0, 2 * len);}public static void main(String[] args) {int[] a = new int[] { 4, 3, 6, 1, 2, 5 };mergeSort(a, 0, 1);for ( int i = 0; i < a. longitud; ++i) {Sr.length; ++i) {System.out.print(a[i] + );}}Lenguaje Python def?MergeSort(listas):if ?MergeSort (listas[:num])derecha?=?MergeSort(listas[num:])return?Merge(izquierda,?derecha) def?Merge(izquierda,derecha):r,?l=0,?0result=[ ]mientras ?l eArr,?tempArr,?startIndex,?midIndex,?endIndex);}}int?{50, 10, 20, 30, 70, 40, 80, 60};int?i,?b[8];MergeSort(a ,?b,?0,?7);for(i=0;?i<8;?i++)printf(%d?,?a[i]);printf(\n);return?;}Lenguaje PHP // La función de combinación fusiona y ordena las dos matrices ordenadas especificadas (arr1arr2,) // Podemos encontrar la tercera matriz y luego tomar los datos del principio de las dos matrices por turno. Los datos que sean más pequeños se tomarán primero. y luego elimine los datos que acaba de tomar ////functional_merge($arrA,$arrB){$arrC?=?array(); while(count($arrA)? &&?count($arrB)){// en Aquí juzgamos constantemente qué valor es menor, y el valor más pequeño se le dará a arrC, pero al final definitivamente quedarán algunos valores, // ya sea en arrA o arrB, y estos valores ordenados deben es mayor que todos los valores en arrC, así que use $arrC[]?$arrA['0']?$arrB['0'] array_shift($arrA)? :?array_shift($arrB);}returnarray_merge($ arrC ,? $arrA,? $arrB);}//Programa principal normalizado funcional_merge_sort($arr){$len=count($arr);if($len?<=?1)return?$arr;//Fin de recursividad Condición, cuando se llega a este paso, solo queda un elemento en la matriz, es decir, la matriz es con $arrC, $arrA, $arrB);}returnarray_merge($arrC, $arrB);}// Condición final recursiva, cuando se alcanza este paso En un paso, solo queda un elemento en la matriz, es decir, la matriz se separa de $ arrC. mid?=?intval($len/2);//Obtener la parte media de la matriz $left_arr?=?array_slice($arr,?0,? $mid);//dividir la parte 0-media de la matriz al left_arr$right_arr?=?array_slice($arr,? $mid);//dividir la porción del extremo medio de la matriz al right_arr $left_arr?=?al_merge_sort($left_arr);//lado izquierdo después del inicio de la división fusionando recursivamente $right_arr?=?al_merge_sort($right_arr);//Una vez completada la división derecha, comience a moverse recursivamente hacia arriba $arr=al_merge($left_arr,? $right_arr);//Fusione las dos matrices y continúe recursivamente return?$arr;} $arr?=?array(12,?5,?4,?7,?8,?3,?4,?2,?6,?4,?9);print_r(al_merge_sort( $arr));Programa de lenguaje Pascal mergesort_1;const maxn=7;escriba arr=array[1.maxn] de entero;var a,b,c:arr;i:integer;procedimiento merge(r:arr;l,m ,n:integer;varrr2 :arr);var i, j,k,p:integer;begin i:=l; j:=m+1; k:=l-1; j<=n) comience k：=k+1; si r[i]<=r[j] entonces comience r2[k]:=r[i]; ]:=r[j ]; j:=j+1; si i<=m entonces para p:=i a m comience k:=k+1; ; fin; si j< =n entonces para p:=j an comenzar k：=k+1; r2[k]:=r[[p]; var r,r1:arr ;s,t:integer);var k:integer;c:arr;comenzar si s=t entonces r1[s]:=r[s] si no, comenzar k：=(s+t)div2 ; fusionar (r,c,s,k); fusionar(r,c,k+1,t); fusionar(c,s,k,t,r1) fin;fin;comenzar escritura('Ingresar datos:'); para i:=1 a maxn haga read(a[i]); mergesort(a,b,1,maxn); para i:=1 a maxn haga write(b[i]:9); /===== ========================================programa mergesort_2;const max =100000;var a, r. matriz[1...max] de long int;n,i:long int;procedimiento msort(s,t:longint);var m,i,j,k:long int;b comenzar si s=t luego salir; m:=(s+t)div2; msort(s,m); ; mientras que (i<=m) y (j<=t) comienzan si a[i] El código que usa recursividad es el siguiente. La ventaja es que el proceso del algoritmo se describe claramente, pero la desventaja es que cuando se usa la recursividad, la función mergeSort() se llamará a sí misma con frecuencia. Una matriz de longitud n terminará llamando a la función mergeSort() 2n-1 veces, lo que significa que las matrices de más de 1500 causarán un error de desbordamiento de pila en Firefox. Considere utilizar la iteración para lograr la misma funcionalidad. función fusionar(izquierda,?derecha){var resultado=[]; while(left.length>0?&&?right.length>0){if(left[0] */result.push(left.shift());}else{result.push(right.shift());}}return.concat(left).concat(right);}función mergeSort(items){ if( items.length?==?1){return items;}var middle?=?Math.floor(items.length/2),left?=?items.slice(0,?middle),right?=?items. rebanada(medio);return merge(items);return result.push(derecha).);return merge(mergeSort(izquierda),?mergeSort(derecha));} Algoritmo no recursivo (C++) #include ata?=?nuevo int[n]; if(!data) exit(1); int k?=?n; while(k--){ cin>>data[n-k-1]; reloj(); MergeSort(datos,?n); reloj_t e?=?reloj(); mientras(k--){ cout< ConstFI='in.txt';FO= 'out .txt';MaxN=10000;TypeTIndex=Longint;TDat=Array[0...MaxN]OfTIndex;VarN:TIndex;Dat:TDat;Tmp:TDat;ProcedureMerge(L,Mid,R:TIndex);VarP1 ,P2 :TIndex;E1,E2:TIndex;P:TIndex;I:TIndex;BeginP1:=L;P2:=Mid+1;P:=L;RepeatIf(Dat[P1]<=Dat[P2])ThenBeginTmp [P ]:=Dat[P1];Inc(P1);Inc(P);EndElseBeginTmp[P]：=Dat[P2];Inc(P2);Inc(P);Fin;Hasta(P1=Mid+1 )O (P2=R+1);Si(P1=Mid+1) ThenBeginE1:=P2;E2:=R;EndElseBeginE1:=P1;E2:=Mid;End;ForI:=E1ToE2DoBeginTmp[P]:=Dat [I ];Inc(P);End;End;ProcedureSort(L,R:TIndex); VarMid:TIndex=0;BeginMid：=(L+R)Shr1;If(L Ejemplo de código fuente completo de clasificación de combinación de Delphi:/Procedimiento de subfunción de combinaciónTForm1.MergePass(vardatas:arrayofInteger;left,mid,right:Integer);vartmpArr:arrayofInteger;arrLen:Integer ;i, k:Entero;comienzo1,comienzo2,end1,end2:Entero r;beginarrLen：=derecha-izquierda+1;SetLength(tmpArr,arrLen);begin1:=izquierda;end1:=mid;begin2:=mid+1;end2:=right;k:=0; while(( begin1< =end1)and(begin2<=end2))dobeginif(datas[begin1]