Método de burbuja C salida serial. Clasificación de burbujas y todo-todo-todo. Algoritmo de clasificación mejorado en Pascal

Colocamos una matriz de arriba a abajo, desde el elemento cero hasta el último.

La idea del método: el paso de clasificación consiste en el paso desde la parte inferior de la matriz. En el camino hay pares de elementos vecinos. Si los elementos de algunos pares están en el orden incorrecto, los cambiamos en lugares.

Después de cero pasaje por matriz "TOP" resulta ser el elemento más "ligero", desde aquí una analogía con una burbuja. El siguiente pasaje se realiza al segundo elemento desde arriba, por lo que el segundo elemento más grande se eleva a la posición correcta ...

Hacemos pasajes para toda la parte inferior disminuyenda de la matriz hasta que solo un elemento permanezca en él. En esta clasificación termina, ya que la secuencia se ordena ascendiendo.

Plantilla. Void Bubblesort (T A, tamaño largo) (largo i, j; t x; para (I \u003d 0; i< size; i++) { // i - un número de paso para (j \u003d talla 1; j\u003e i; j--) ( // Ciclo de paso interno if (a\u003e a [j]) (x \u003d a; a \u003d a [j]; a [j] \u003d x;))))))

El número promedio de comparaciones e intercambios tiene un orden cuadrático de crecimiento: Theta (n 2), desde aquí, puede concluir que el algoritmo de burbujas es muy lento y es ineficaz.
Sin embargo, tiene una gran ventaja: es simple y puede mejorarse de ninguna manera. Lo que ahora vamos.

Primero, considere la situación cuando no ocurrió ningún intercambio en ninguno de los pases. ¿Qué significa?

Esto significa que todos los pares están ubicados en el orden correcto, por lo que la matriz ya está ordenada. Y para continuar el proceso no tiene sentido (¡especialmente si la matriz se ordenó desde el principio!).

Por lo tanto, la primera mejora del algoritmo es recordar si se hizo ningún intercambio en este pasaje. Si no, el algoritmo termina funciona.

El proceso de mejora se puede continuar si recuerda no solo el hecho de intercambio, sino también el índice del último intercambio de k. De hecho: todos los pares del paquete de elementos con índices, más pequeños k, ya están ubicados en el orden deseado. Se pueden completar más pasajes en el índice K, en lugar de pasar a la versión del límite superior que instalé de antemano.

Cualitativamente, otra mejora en el algoritmo se puede obtener a partir de la siguiente observación. Aunque la burbuja de luz de la parte inferior se levantará en un solo paso, las burbujas pesadas se reducen a una velocidad mínima: un paso para la iteración. Por lo tanto, la matriz 2 3 4 5 6 1 se clasificará en 1 pase, y la clasificación de la secuencia 6 1 2 3 4 5 requerirá 5 pases.

Para evitar un efecto similar, puede cambiar la dirección de la siguiente por otros pases. El algoritmo resultante a veces se llama " clasificación de la coctelera".

Plantilla. Void Shakersort (T A, tamaño largo) (Long J, K \u003d Tamaño-1; Long LB \u003d 1, UB \u003d Tamaño-1; // los límites de la parte insustuida de la matriz T x; hacer ( // pase de nuevo Para (j \u003d ub; j\u003e 0; j--) (si (a\u003e a [j]) (x \u003d a a; a \u003d a [j]; a [j] \u003d x; k \u003d j;)) lb \u003d k + 1; // pasar de arriba a abajo para (j \u003d 1; j<=ub; j++) { if (a > a [j]) (x \u003d a; a \u003d a [j]; a [j] \u003d x; k \u003d j;)) UB \u003d K-1; ) Mientras (lb< ub); }

¿Cómo se describen los cambios afectados la efectividad del método? El número promedio de comparaciones, aunque disminuyó, pero sigue siendo O (n 2), mientras que el número de intercambios no cambió en absoluto de ninguna manera. El promedio (es lo peor) El número de operaciones sigue siendo cuadrático.

Obviamente no se requiere memoria adicional. El comportamiento de un método mejorado (pero no inicial) es bastante natural, la matriz casi ordenada se ordenará mucho más rápido. Ordenar por burbuja es estable, pero la clasificación de la coctelera pierde esta calidad.

En la práctica, el método de la burbuja, incluso con mejoras, obras, alas, demasiado lento. Y por lo tanto, casi no se aplica.

Método de burbuja

Clasificación intercambios simples , ordenar por burbuja (Esp. ordenamiento de burbuja.) - Un algoritmo de clasificación simple. Para comprender e implementar este algoritmo, el más simple, pero es efectivo solo para pequeñas matrices. La complejidad del algoritmo: O ( nORTE.²).

El algoritmo se considera educativo y prácticamente no se aplica fuera de la literatura educativa, en lugar de ella en la práctica, se aplican inserciones.

Algoritmo

Ejemplo de clasificación por una lista de burbujas de números aleatorios.

El algoritmo consiste en pasillos repetitivos en la matriz ordenada. Para cada pasada, los elementos se comparan constantemente en parejas y, si el orden es incorrecto, se cumple el intercambio de elementos. Los pases de matriz se repiten hasta el siguiente pasaje, resulta que los intercambios ya no son necesarios, lo que significa: se ordena una matriz. Con el paso del algoritmo, el elemento, que no está en su lugar, "aparece" a la posición deseada como una burbuja en agua, de ahí el nombre del algoritmo.

A veces, a cada paso, la matriz es visible desde el principio, luego desde el final. Esto se llama clasificación de coctelera.

Ejemplos de implementación

Pitón

DEF SWAP (ARR, I, J): arr [I], arr [j] \u003d Arr [J], arr [I], ARR [I] DEF BUBLE_SORT (ARR): i \u003d len (ARR) mientras estoy\u003e 1: para j en xrange (I - 1): IFR [J]\u003e Arr [J + 1]: SWAP (ARR, J, J + 1) I - \u003d 1

VBA.

Sub Sort Sort (Mus () MUESTRO MÁS LARGO) DIM N Tan largo, tan largo, TMP mientras lo hago mientras (yo< UBound (Mus) ) If Mus(i) > MUS (I + 1) Luego TMP \u003d MUS (I) MUS (I) \u003d MUS (I + 1) MUS (I + 1) \u003d TMP Si i\u003e 1, entonces i \u003d i - 1 más i \u003d i + 1 final si Otra cosa i \u003d i + 1 end si el subd de bucle sub

Algoritmo de clasificación mejorado en Pascal

P: \u003d verdadero; (Hay una permutación) K: \u003d 1; (Ver número) Mientras que p comienza P: \u003d FALSO; Para i: \u003d 1 a n - k hacer si x [i]\u003e x [i + 1], entonces comienza a: \u003d x [i]; X [i]: \u003d x [i + 1]; X [i + 1]: \u003d a; P: \u003d verdadero; Final; k: \u003d k + 1; Final;

PHP.

$ Talla \u003d cuenta ($ arr) -1; Para ($ i \u003d $ tamaño; $ i\u003e \u003d 0; $ i -) (para ($ j \u003d 0; $ j<=($i -1 ) ; $j ++) if ($arr [ $j ] >$RR [$ J +1]) ($ K \u003d $RR [$ J]; $RR [$ J] \u003d $RR [$ J +1]; $RR [$ J +1] \u003d $ K;))

Además, no se considera el método más rápido, además, cierra la lista de las formas más lentas de ordenar. Sin embargo, ella tiene sus ventajas. Entonces, clasificación por el método de burbuja, lo que más no existe una solución lógica y natural al problema, si es necesario colocar los elementos en un determinado orden. Una persona ordinaria manualmente, por ejemplo, se aprovechará de ellos, solo en la intuición.

¿De dónde viene un nombre tan inusual?

El nombre del método se inventó utilizando una analogía con burbujas de aire en agua. Esta es una metáfora. Al igual que las burbujas de aire pequeñas se alzan, después de todo, su densidad es mayor que cualquier líquido (en este caso - agua), y cada elemento de la matriz, cuanto menos valorea, cuanto más lo haga, gradualmente hace sus formas hasta el comienzo de la Número de números.

Descripción del algoritmo.

Ordenar por burbuja se realiza de la siguiente manera:

primer paso: los elementos de la matriz de números se toman dos y también comparan pares. Si en algunos dos elementos, el primer valor es más que el segundo, el programa produce su intercambio de campo;
en consecuencia, la matriz cae en el final. Mientras que todos los demás elementos permanecen, como lo fueron, en orden caótico y requieren más clasificación;
por lo tanto, la segunda pasada es necesaria: se realiza mediante analogía con la anterior (ya descrita) y tiene una serie de comparaciones, menos una;
pasaje número tres comparaciones por unidad menos que la segunda y dos veces que la primera. Etc;
resumamos que cada pasaje tiene (valores totales en una matriz, un número específico) menos (número de pasaje) de comparaciones.

En resumen, el algoritmo del futuro programa se puede escribir de la siguiente manera:

se verifica una matriz de números hasta que se encuentren dos números, el segundo de ellos debe ser más que el primero;
ubicado incorrectamente en relación con los demás elementos de los cambios de programa de matriz en lugares.

Pseudocódigo basado en el algoritmo descrito

La implementación más simple se realiza de la siguiente manera:

Procedimiento Sortirovka_puzirkom;

Comienzo

ciclo para j. de nachalnii_index antes de konechii_index;

ciclo para i. de nachalnii_index antes de konechii_index-1.;

si un massiv [I]\u003e Massiv

(cambiar los valores en los lugares);

el fin

Por supuesto, aquí la simplicidad solo agrava la situación: cuanto más simple sea el algoritmo, especialmente en ella, se manifieste todas las fallas. El costo del tiempo es demasiado grande incluso para una pequeña matriz (hay una cuestión de relatividad: para el promedio, la cantidad de tiempo puede parecer pequeña, pero en el programador del programador, cada segundo o incluso milisegundo en la cuenta).

Tomó mejor la realización. Por ejemplo, teniendo en cuenta el intercambio de valores en la matriz por parte de los lugares:

Procedimiento Sortirovka_puzirkom;

Comienzo

sortirovka. \u003d verdad;

ciclo sortirovka. \u003d verdad;

sortirovka. \u003d falso;

ciclo para i. de nachalnii_index antes de konechii_index-1.;

si un massiv [I]\u003e Massiv (El primer elemento es mayor que el segundo), entonces:

(cambiando elementos en lugares);

sortirovka. \u003d verdad; (Denote que se produjo el intercambio).

El fin.

Desventajas del método.

El principal menos es la duración del proceso. ¿Cuánto tiempo se realiza por una burbuja?

El tiempo de ejecución se calcula desde el cuadrado del número de números en la matriz, el resultado final es proporcional a él.

En el caso de la peor versión, la matriz se pasará tantas veces, ya que está en el elemento de TI menos un valor. Esto se debe a que, en última instancia, solo hay un elemento que no tiene nada que comparar, y el último paso del macizo se está volviendo inútil.

Además, el método de clasificación por intercambios simples, como también se llama, solo para pequeñas matrices. No se procesará grandes volúmenes de datos con él: el resultado será errores o el fallo del programa.

Dignidad

Ordenar por burbuja es muy simple para la comprensión. En los programas curriculares de las universidades técnicas, al estudiar la matriz de elementos de matriz, se necesita primero. El método se implementa fácilmente como en el idioma. programación de Delphi. (D (Delphi) y C / C ++ (SI Plus Plus), un algoritmo increíblemente simple para la ubicación de los valores en el orden correcto y en la clasificación por la burbuja es ideal para principiantes.

Debido a las deficiencias, el algoritmo no se aplica en fines extracurriculares.

Principio de la clasificación de la clasificación.

Vista inicial de la matriz 8 22 4 74 44 37 1 7

Paso 1 8 22 4 74 44 37 1 7

8 22 4 74 44 1 37 7

8 22 4 74 1 44 37 7

8 22 4 1 74 44 37 7

8 22 1 4 74 44 37 7

8 1 22 4 74 44 37 7

1 8 22 4 74 44 37 7

Paso 2. 1 8 22 4 74 44 7 37

1 8 22 4 74 7 44 37

1 8 22 4 7 74 44 37

1 8 4 22 7 74 44 37

1 4 8 22 7 74 44 37

Paso 3. 1 4 8 22 7 74 37 44

1 4 8 22 7 37 74 44

1 4 8 7 22 37 74 44

1 4 7 8 22 37 74 44

Paso 4. 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

Paso 5. 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

Paso 6. 1 4 7 8 22 37 44 74

1 4 7 8 22 37 44 74

Paso 7. 1 4 7 8 22 37 44 74

Ejemplo de clasificación por burbuja en Pascal

Ejemplo:

const kol_mas \u003d 10;

var massiv: matriz de entero;

a, b, k: entero;

writeln ("entrada", kol_mas, "Elementos de la matriz");

para A: \u003d 1 a kol_mas, Readln (Massiv [A]);

para a: \u003d 1 a kol_mas-1 comienza

para B: \u003d A + 1 a KOL_MAS comienza

si Massiv [A]\u003e Massiv [B] luego comienza

k: \u003d massiv [a]; Massiv [A]: \u003d Massiv [B]; Masivo [b]: \u003d k;

final;

writeln ("despues de ordenar");

para a: \u003d 1 a kol_mas do writeln (massiv [a]);

Ejemplo de clasificación por una burbuja en un idioma con (SI)

#Incluir.

iNT principal (int argc, char * argv)

int Massiv \u003d (36, 697, 73, 82, 68, 12, 183, 88), I, FF;

por (;) (

FF \u003d 0;

para (i \u003d 7; i\u003e 0; i -) (

Si (Massiv [I]< massiv) {

Swap (massiv [i], massiv);

if (ff \u003d\u003d 0) se rompe;

getch (); // retardo de la pantalla

Etiquetas: Ordenar por burbuja si, si clasificación de burbujasOrdenar por burbuja matriz bidimensional

Ordenar por burbuja

Y el acto del algoritmo es muy simple. Vamos a través de la matriz de números y verificamos el pedido (el siguiente número debe ser más e igual al anterior), tan pronto como se encontraron con una violación del pedido, intercambiar de inmediato elementos en lugares, llegamos al final de la Array, y luego comienza primero.

Ordenar la matriz (1, 5, 2, 7, 6, 3)
Vamos al macizo, revisamos el primer número y segundo, van en orden ascendente. A continuación, hay una violación de la orden, cambiamos estos elementos.
1, 2, 5, 7, 6, 3
Seguimos pasando por la matriz, 7 más de 5, pero 6 menos, así que intercambiamos fuera de lugares
1, 2, 5, 6, 7, 3
3 viola la orden, cambia de lugares de 7
1, 2, 5, 6, 3, 7
Regresamos al comienzo de la matriz y hagamos lo mismo.

1, 2, 5, 3, 6, 7
1, 2, 3, 5, 6, 7

Se dice que esto es similar a la "flotación" de los elementos más "pulmones", como las burbujas, por lo que el algoritmo y recibió un nombre de este tipo. Void Bubblesort (tamaño int * a, size_t) (size_t i, j; int tmp; para (i \u003d 1; i< size; i++) { for (j = 1; j < size; j++) { if (a[j] > a) (tmp \u003d a [j]; a [j] \u003d a; a \u003d tmp;))))

Este algoritmo siempre hará (N-1) 2 pasos, independientemente de los datos de entrada. Incluso si la matriz está ordenada, aún se pasará (N-1) 2 veces. Además, los datos ya ordenados se verificarán una vez más.

Deja que sea necesario ordenar la matriz 1, 2, 4, 3

1 2 4 3
1 2 4 3
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4

Después de que se cambió en lugares de elemento A y no más necesidad de pasar esta sección de la matriz. Tomamos en cuenta y al presunto algoritmo.

Void Bubblesort2 (int * a, size_t tamaño) (size_t i, j; int tmp; para (i \u003d 1; i< size; i++) { for (j = i; j > 0; j--) (si (a [j]< a) { tmp = a[j]; a[j] = a; a = tmp; } } } }

Otra implementación

Void bubblesort2b (tamaño int * a, size_t) (size_t i, j; int tmp; para (i \u003d 1; i< size; i++) { for (j = 1; j <= size-i; j++) { if (a[j] < a) { tmp = a[j]; a[j] = a; a = tmp; } } } }

En este caso, habrá medio punto menos, pero aún así el problema de clasificar los restos de matriz ya ordenados: debe hacerlo para que la matriz ordenada se vea una vez. Para hacer esto, ingrese la variable de la bandera: se omitirá (bandera \u003d 0) si la matriz se ordena. Tan pronto como vamos a violar el pedido, la bandera se elevará (bandera \u003d 1) y comenzaremos a ordenar la matriz como de costumbre.

Void Bubblesort3 (int * a, size_t tamaño) (size_t i; int tmp; char bandera; haz (bandera \u003d 0; para (i \u003d 1; i< size; i++) { if (a[i] < a) { tmp = a[i]; a[i] = a; a = tmp; flag = 1; } } } while (flag); }

En este caso, la complejidad también es aproximadamente N 2, pero en el caso de una matriz ordenada, solo será un pasaje.

Ahora mejora el algoritmo. Escribiremos la función de la forma general para que ordenó una matriz de tipo vacío. Dado que no se conoce el tipo de variable, será necesario transmitir además el tamaño de un elemento de matriz y la función de comparación.

INT Intsort (Const Void * A, Const Void * B) (retorno * (((INT *) a)\u003e * ((INT *) B);) Void BubblesORT3G (VOID * A, TEVER_T ARTÍCULO, TAMAÑO TEVER_T, INT (* CMP) (Const Void *, Const Void *)) (size_t i; void * tmp \u003d null; bandera de carbón; tmp \u003d malloc (artículo); haz (bandera \u003d 0; para (i \u003d 1; i< size; i++) { if (cmp(((char*)a + i*item), ((char*)a + (i-1)*item))) { memcpy(tmp, ((char*)a + i*item), item); memcpy(((char*)a + i*item), ((char*)a + (i-1)*item), item); memcpy(((char*)a + (i-1)*item), tmp, item); flag = 1; } } } while (flag); free(tmp); }

La función se ve fea: a menudo se calcula la dirección del elemento actual y anterior. Resaltamos variables separadas para esto.

Void Bubblesort3GI (VOID * A, TAMAÑO_T ARTÍCULO, TAMAÑO DE TAMAÑO_T, INT (* CMP) (Const Void *, Const Void *)) (size_t i; void * tmp \u003d null; Void * Prev, * Cur; Bandera de char; tmp \u003d malloc (artículo); haz (bandera \u003d 0; i \u003d 1; Anterior \u003d (char *) a; cur \u003d (char *) Prev + elemento; mientras que (i< size) { if (cmp(cur, prev)) { memcpy(tmp, prev, item); memcpy(prev, cur, item); memcpy(cur, tmp, item); flag = 1; } i++; prev = (char*)prev + item; cur = (char*)cur + item; } } while (flag); free(tmp); }

Ahora con estas funciones, puede ordenar las matrices de cualquier tipo, por ejemplo,

Nulo principal () (int a \u003d (1, 0, 9, 8, 7, 6, 2, 3, 4, 5); int i; bubblesort3gi (a, sizeof (int), 10, intsort); para (i \u003d 0; yo< 10; i++) { printf("%d ", a[i]); } _getch(); }

Clasificación de la matriz multidimensional

Una matriz de multidimensional estática es esencialmente no diferente de la clasificación unidimensional. Puede usar la propiedad que las matrices unidimensionales y multidimensionales estáticas tienen la misma vista en la memoria.

Nulo principal () (int a \u003d \u003d (1, 9, 2, 8, 3, 7, 4, 6, 5); int i, j; bubblesort3gi (a, sizeof (int), 9, intsort); para (i \u003d 0; yo< 3; i++) { for (j = 0; j < 3; j++) { printf("%d ", a[i][j]); } } } Сортировка динамически созданного двумерного массива может быть произведена двумя способами. Во-первых, можно по определённому алгоритму находить индекс i-го и j-го элемента по порядковому номеру k от 0 до n * m. #include #Incluir. #Incluir. #Incluir. Void Bubblesort2D (int ** a, size_t m, size_t n) (int tmp; size_t i, j, k, jp, ip; size_t talla \u003d m * n; bandera de char; haz (bandera \u003d 0; para (k \u003d 1 k.< size; k++) { //Вычисляем индексы текущего элемента j = k / m; i = k - j*m; //Вычисляем индексы предыдущего элемента jp = (k-1) / m; ip = (k-1) - jp*m; if (a[i][j] > a) (tmp \u003d a [i] [j]; a [i] [j] \u003d a; a \u003d tmp; bandera \u003d 1;))) mientras (bandera); ) #Define size_x 3 #define size_y 4 void principal () (int ** a \u003d nulo; int i, j; a \u003d (int **) malloc (sizeof (int *) * size_x); para (i \u003d 0; I.< SIZE_X; i++) { a[i] = (int*) malloc(sizeof(int) * SIZE_Y); for (j = 0; j < SIZE_Y; j++) { a[i][j] = rand(); printf("%8d ", a[i][j]); } printf("\n"); } printf("\nafter sort\n"); bubbleSort2d(a, SIZE_X, SIZE_Y); for (i = 0; i < SIZE_X; i++) { for (j = 0; j < SIZE_Y; j++) { printf("%8d ", a[i][j]); } printf("\n"); } for (i = 0; i < SIZE_X; i++) { free(a[i]); } free(a); _getch(); }

En segundo lugar, primero puede mover la matriz a uno dimensional, ordena la matriz unidimensional, luego vuelva a volver a la bidimensional.

Void Bubblesort3GI2D (Void ** a, size_t item, size_t m, size_t n, int (* cmp) (Const Void *, Const Void *)) (Tamaño Tamaño \u003d M * N, sub_size \u003d n * item; size_t i, j , K; Void * Arr \u003d Malloc (Tamaño * Artículo); char * p1d \u003d (char *) arr (char * p2d \u003d (char *) a; // Copie un tipo de vacío bidimensional en un dimensionario para (i \u003d 0; yo< m; i++) { memcpy(p1d + i*sub_size, *((void**)(p2d + i*item)), sub_size); } bubbleSort3gi(arr, item, size, cmp); //Копируем одномерный массив обратно в двумерный for (i = 0; i < m; i++) { memcpy(*((void**)(p2d + i*item)), p1d + i*sub_size, sub_size); } }

Si esta función lo confunde, use el teclado. Llamada desde el ejemplo anterior.

Se estimó que hasta cuarto de tiempo. computadoras centralizadas Se paga a la clasificación de datos. Esto se debe a que es mucho más fácil encontrar un valor en una matriz que se haya ordenado con anticipación. De lo contrario, la búsqueda es un poco como una búsqueda de agujas en un pajar.

Hay programadores que se llevan a cabo todas las horas de trabajo en el estudio e implementación de algoritmos de clasificación. Esto se debe a que la abrumadora mayoría de los programas de negocios incluye la gestión de la base de datos. Las personas están buscando información en bases de datos todo el tiempo. Esto significa que los algoritmos de búsqueda están muy en demanda.

Pero hay uno "pero". Los algoritmos de búsqueda trabajan mucho más rápido con las bases de datos que ya están ordenadas. En este caso, solo se requiere una búsqueda lineal.

Si bien las computadoras están sin usuarios en algunos puntos de tiempo, los algoritmos de clasificación continúan trabajando con las bases de datos. Nuevamente, los usuarios que buscan, y la base de datos ya está ordenada, en función de un objetivo de búsqueda en particular.

Este artículo proporciona ejemplos de la implementación de algoritmos de clasificación estándar.

Sorto de selección (Sección de selección)

Para ordenar la matriz en orden ascendente, sigue cada iteración para encontrar el artículo con el valor más alto. Con él necesitas intercambiar el último elemento. El siguiente elemento con el mayor valor se convierte en el penúltimo lugar. Esto debería estar sucediendo hasta que los elementos que se encuentren en los primeros lugares en las matrices no sean correctamente.

Código C ++

void selección :: selección (datos INT, int lend) (int j \u003d 0; int tmp \u003d 0; para (int i \u003d 0; i datos [k]) (J \u003d k;)) TMP \u003d DATOS [I]; DATOS [I] \u003d DATOS [J]; Datos [J] \u003d TMP; ))

Ordenamiento de burbuja

Con la clasificación de burbujas, los elementos adyacentes se comparan y cambian en lugares si el siguiente elemento es menor que el anterior. Se requieren varios pasajes. Durante la primera pasada, los dos primeros elementos en la matriz están luchando. Si no están en orden, cambian de lugar y luego comparan elementos en el siguiente par. Con la misma condición, también cambian de lugar. Por lo tanto, la clasificación se produce en cada ciclo hasta que se logrará el final de la matriz.

Código C ++

void StandalGo :: Bubblesort (datos INT, INT LEND) (INT TMP \u003d 0; para (int i \u003d 0; i \u003d (i + 1); j -) (si (datos [j]

Ordenador de inserción (ordenador de inserción)

Al clasificar insertos, la matriz se divide en dos áreas: ordenada y desordenada. Inicialmente, la matriz completa es un área desordenada. En la primera pasada, el primer elemento de una región desordenado está cubierta y se coloca en la posición correcta en un área ordenada.

En cada pasaje, el tamaño de un área ordenada aumenta en 1, y el tamaño de la región desordenada se reduce en 1.

El ciclo principal opera en el rango de 1 a N-1. En la iteración J-TH, el elemento [I] se inserta en la posición correcta en el área ordenada. Esto se hace cambiando todos los elementos de un área ordenada, que son mayores que [I], una posición a la derecha. [I] se inserta en el intervalo entre los elementos que son menos que [I], y los que son mayores [I].

Código C ++

void StandalGo :: Inspertionsort (INT DATA, INT LEND) (tecla INT \u003d 0; int i \u003d 0; para (int j \u003d 1; j \u003d 0 && Datos [I]\u003e Tecla) (DATOS \u003d DATOS [I]; I \u003d I-1; DATA \u003d CLAVE;))))

Merge Sort (Merge Sort)

Código C ++

void Classalgo :: Mergesort (datos INT, INT PERSE) (IF (PERMITENTE\u003e 1) (INT MEDIODO \u003d LEND / 2; INT REM \u003d LEND-MIDERO; INT * L \u003d nuevo int; int * r \u003d nuevo int; para ( int i \u003d 0; i

Ordenación rápida

La clasificación rápida usa el algoritmo "dividir y conquide". Comienza con la división de la matriz original en dos áreas. Estas partes están ubicadas a la izquierda y a la derecha del elemento marcado llamado la referencia. Al final del proceso, una parte contendrá elementos más pequeños que el soporte, y la otra parte contendrá los elementos más de referencia.

Código C ++

void Classalgo :: QuickSort (INT * DATA, INT Const LEN) (INT Const LEND \u003d LEN; INT PIVOT \u003d 0; INT IND \u003d LEND / 2; INT I, J \u003d 0, K \u003d 0; if (lend\u003e 1) (int * l \u003d nuevo int; int * r \u003d nuevo int; pivot \u003d datos; para (i \u003d 0; i