Una breve discusión sobre el método de clasificación de Pascal libre

De mayor a menor do

Para J: = bajo(A) a alto(A) - 1 do

si A[J] gt ;A[J 1] luego

Iniciar

intercambio(A[J],A[J 1]);

t：= A[J] ;

A[ J]：= A[J 1];

a[J 1]：= T

Fin

Fin;

//Clasificación de selección

procedimiento SelectionSort(var A: matriz de enteros);

Definir variables

I, J, T: entero;

Inicio

Para I: = Bajo(A) a Alto(A) - 1 hacer

Para J: = Alto( A) hasta I 1 do

Si A[I] gt entonces

Iniciar

Swap(A[I], A[J]);

t:= A[I];

A[I]:= A[J];

a[J]:= T;

Salir si se termina;

Fin;

Fin;

//Clasificación rápida

Proceso de clasificación rápida (variable A). : matriz de enteros);

Procedimiento QuickSortSub(var A: matriz de enteros; iLo, iHi: entero);

Definir variables

Lo, Hi, Mid, T: entero;

Inicio

lo:= iLo;

hi:= iHi;

medio:= A[(Lo Hola)div 2];

Repetir

Y A[Lo] lt; Mid do company (Lo);

Y A[Hola]> Mediados de diciembre (Hola);

p>

Si Lo lt Hola

Iniciar

Intercambio(A[Lo], A[Hi]) ;

t：= A[ Lo];

A[Lo]:= A[Hola];

a[Hola]:= T;

Aum(Lo);

p>

Dic(Feliz

);

Fin;

Hasta Lo gtHi;

Si Hola gtiLo entonces QuickSortSub(A,iLo,Hi);

si Lo ltiHi luego QuickSortSub(A, Lo, iHi);

Fin

Inicio

QuickSortSub(A, Bajo(A), Alto(A) )

Fin;

Pascal 2007-04-18 16:16 Programa Inssort

const max = 100

Escriba arr = Entero de matriz[0..max];

var a: arr;

I, n: entero;

fin: texto;

Proceso en sort(var r: arr; rn: integer); {algoritmo de ordenación por inserción directa}

var i, j: integer;

Inicio

For i:=2 to rn do

Inicio

r[0]:= r[I];{Almacenamiento que se insertará en la columna de vigilancia r[0] Registro }

j:= I-1;

while(r[0] lt; r[j])do {buscar posición de inserción}

Iniciar

r[j 1]:= r[j];{registro movido hacia atrás}

Décima sesión;

Fin;

r [j 1]:= r[0]; {Insertar el registro a insertar en la secuencia de clasificación}

Fin

Fin

Inicio

assign(fin, ' entrada . txt ');

reset(fin),

readln(fin, n

); para i:=1 a n lea(fin, a[I]);

escribir('antes de ordenar:');

Para i:=1 a n escriba (a[I]: 5); writeln

in sort(a, n);

write('Después de ordenar:

Para i :=1 a n escribir(a[I]:5); escribir

Cerrar(fin);

readln

Fin.

Fusionar ordenación [Pascal]

Tipo elemento = entero de matriz [0..10001];

var arrhead, arrend: longint;

n, I: longint;

a: elemento;

Proceso de fusión (var a: elemento; x, y, z: longint); >var temp1, temp 2: elemento;

longitudA, longitudB, I, j, recuento:

Inicio

Para i:=x a y; do temp 1[I-x 1]:= a[I];

Para j:=y 1 a z do temp 2[j-y]:= a[j];

longitud a: = y-x 1;

longitud b: = z-y;

I: = 1; j: = 1; cuenta: = x-1; while(i lt=longitudA) y (j lt=longitud B) hacen

Inicio

inc(count);

if temp 1[I] gt ; temp2[j] luego inicia un [count]: = temp 2[j]; Inc(j) De lo contrario, inicia un [count]: = temp 1[I]; ;Fin;

Fin;

Si gtlengthA entonces para i:=j a lengthB haga un[count i-j 1]:=temp2[i]

else for j:=i to lengthA hacer a[count j-I 1]:=temp 1[j];

Fin;

Clasificación de procesos (variable a: elemento; x, y : longint);

var mid: longint;

Inicio

mid:=(x y)div 2;

if mid lt gtx luego ordenar (a, x, mid);

Si mid 1 lt; gty luego ordenar (a, mid 1, y

merge (a, x, mid, y);

Fin;

Inicio

Leer como (n); ( a[I]);

arr head:= 1;

arrend:= n;

sort(a, arrhead, arrend);

Para i:=1 an n comience write(a[i], ' '); si i mod 5=0, entonces writeln termina;

Fin.

Clasificación de burbujas

Clasificación de burbujas de procedimiento (variable R: tipo de archivo)

Inicio

Para i:=1 a n-1 hacer // Realizar clasificación N-1.

no swap:= true; //Intercambiar símbolos

For j:=n-1 downto i do //Escanear de atrás hacia adelante.

Si R[j 1]. claveltR[j].

Luego presione la tecla

temp:= R[j 1];

R[j 1]:= R[j];

r[j] : = temp;

noswap:=false

endif

endfor

Si no hay intercambio, entonces // Si no se produce ningún intercambio, luego detenga el algoritmo.

Regresar;

endif

Fin

Fin;

Seleccionar ordenar directamente

Procedimiento seleccionar ordenar(var R: tipo de archivo);

Inicio

Para i:=1 a n-1 hacer

k:=I; p>

Para j: =i 1 an do

Si R[j]. claveltR[k]. Luego presione la tecla

k:=j

endif

endfor

Si k no es igual a I entonces // Maldita sea, No puedes usar ese símbolo, suficiente protección.

temp: R[I];

R[I]: = R[k]

r[k]: = temperatura

endif

End

End;

Implementación Pascal de clasificación de montón

//Este programa implementa un pequeño montón raíz ( Satisfacer la naturaleza de que el padre sea más pequeño que el hijo)

//Las funciones implementadas por el programa son: clasificación del montón, tomando el elemento más pequeño.

//La matriz eventualmente se ordenará en orden descendente.

const maxn = 1000;

var a: matriz[1..maxn]de entero largo

Tamaño: entero largo

I , n: longint;

Intercambio de procesos (var a, b: longint

var t: longint

Inicio

t：= a;

a：= b;

b：= t;

Fin

Inserción del proceso (x: longint);

var p: longint;

Inicio

inc(tamaño);

p:=tamaño;

Mientras (a[p div 2]>x) y (p gt1) comencemos

a[p]:= a[p div 2];

p := p div 2;

Fin

a[p] := x

Fin

Proceso montón (idx; : longint);

var l, r, bajo: longint;

Inicio

l:= 2 * idx; := 2 * idx 1;

si (a[l] lt; a[idx]) y (l lt=tamaño) entonces bajo:=l

si no, bajo:= idx

if (a[r] lt; a[low]) y (r lt=size) then low: = r;

Si idx lt gt● entonces comienza

intercambio(a[idx], a[bajo]);

heapfy(bajo);

Fin;

Fin;

p>

Función getmin: longint;

Inicio

Salir(a[1]);

Fin;

Función pop: longint;

Inicio

pop: = a[1];

a[1]: = a[tamaño];

dec(tamaño);

heap fy(1);

Fin;

Inicio

readln (n);

Tamaño: = 0;

Para i: = 1 a n hacer

Insertar(random(1000));

Para i:=1 a n hacer

a[n-I 1]:= pop;

Para i:=1 a n escribir(a[i],' ');

p>

escribir

Fin.