Algoritmos de clasificación comunes: selección, burbuja, inserción, rápido, combinación
No he mirado el código durante mucho tiempo. Recientemente planeé revisar Java y de repente pensé en los algoritmos de clasificación. Escribí varios algoritmos de clasificación comunes en Java. Aquí, las secuencias desordenadas. unificado de pequeño a pequeño. Gran arreglo.
La clasificación por selección es un algoritmo de clasificación simple e intuitivo. Su principio de funcionamiento es: primero seleccione el elemento más pequeño de los elementos de datos que se van a ordenar y guárdelo en la posición inicial de la secuencia, luego busque el elemento más pequeño de los elementos restantes sin clasificar y continúe colocándolo en la siguiente posición. , hasta que el número de elementos a ordenar sea 0.
El código de clasificación de selección es el siguiente:
public void Select_sort(int[] arr) {
int temp, index
índice = i;
for(int j = i 1; j lt; 10; j) {
if(arr[j] lt; arr[index])
index = j
}
/*
temperatura = arr[i];
arr[i] = arr[índice];
arr[índice] =
* /
p>swap(arr, i, index);
}
System.out.print("Después de la clasificación por selección: "); p>
for(int i = 0; i lt; 10; i)
System.out.print( arr[i] " "); .println(" ");
}
La clasificación de burbujas es un algoritmo de clasificación relativamente básico. La idea es comparar elementos adyacentes en pares, con los elementos más grandes detrás y los más pequeños. al final, los elementos se colocan al frente, de modo que después de un ciclo, el elemento más grande volverá a su posición. Si el número de elementos en la matriz es n, luego de (n-1) veces, todos los elementos serán. ordenados de pequeño a grande. Todo el proceso es como si las burbujas subieran, por eso se llama clasificación de burbujas.
El código de clasificación de selección es el siguiente:
public void Bubble_sort(int[] arr) {
int temp
for (int i = 0; i lt; 9; i) {
for(int j = 0; j lt; 10 - i - 1; j) {
if(arr [j] gt; arr[j 1]) {
/*
temp = arr[j]; 1];
arr[j 1] = temp;
*/
intercambiar(arr, j, j 1); > }
}
}
System.out.print("Después de la clasificación de burbujas:"); = 0; yo lt; 10; yo)
System.out.print( arr[i] " "); p >
}
La clasificación por inserción también es un algoritmo de clasificación común. La idea de la clasificación por inserción es crear una matriz tan grande como la matriz que se va a ordenar y eliminar un elemento de la misma. matriz que se va a ordenar a la vez. Luego, insértelo en la posición adecuada en la nueva matriz para que los elementos de la nueva matriz permanezcan en orden de pequeño a grande.
El código de clasificación de inserción es el siguiente:
public void Insert_sort(int[] arr) {
int length = arr.length
;int[] arr_sort = new int[longitud];
int recuento = 0;
for(int i = 0; i lt; longitud; i ) {
if(count == 0) {
arr_sort[0] = arr[0];
}else if(arr[i] gt; = arr_sort[ recuento - 1 ]) {
arr_sort[count] = arr[i]
}else if(arr[i] lt; arr_sort[0]) {
insert(arr, arr_sort, arr[i], 0, count);
}else {
for(int j = 0; j lt; count - 1; j ) {
if(arr[i] gt; = arr_sort[j] amp; arr[i] lt; arr_sort[j 1]) {
insert(arr, arr_sort , arr[i], j 1, contar);
romper
}
}
}
contar;
}
System.out.print("Después de la inserción ordenar: "); 10; i)
System.out.print( arr_sort[i] " "
System.out.println("");
public void insert(int[] arr, int[] arr_sort, int value, int index, int count) {
for(int i = count; i gt; index; i--)
arr_sort[i] = arr_sort[i-1];
arr_sort[index] = valor
}
<; p> La eficiencia de la clasificación rápida ha mejorado enormemente en comparación con el algoritmo de clasificación de burbujas. Porque cuando se utiliza la clasificación por burbujas, un bucle externo solo puede devolver un valor, y si hay n elementos, el bucle externo debe ejecutarse como máximo (n-1) veces. Cuando se utiliza la clasificación rápida, todos los elementos se pueden dividir en dos pilas según el tamaño a la vez, lo que significa que, en promedio, se necesitan varias rondas para completar la clasificación.La idea de la clasificación rápida es: seleccionar un valor de referencia en cada paso de clasificación (aquí, el primer elemento es el valor de referencia), luego comparar todos los elementos con el valor de referencia y dividirlos en la izquierda. y pilas correctas según el tamaño. Luego, el proceso se realiza de forma recursiva hasta que todos los elementos estén ordenados.
public void Quick_sort(int[] arr, int left, int right) {
if(left gt; = right)
return; >
int temp, t;
int j = derecha;
int i = izquierda
temp = arr[izquierda]; >
while(i lt; j) {
while(arr[j] gt; = temp amp; amp; i lt; j)
j--; /p>
while(arr[i] lt; = temp amp; amp; i lt; j)
i
if(i lt; j) {
t = arr[i];
arr[i] = arr[j];
arr[j] =
}
arr[izquierda] = arr[i];
arr[i] = temp
Quick_sort( arr, left, i - 1);
Quick_sort(arr, i 1, right);
}
La clasificación de combinación se basa en la operación de combinación. Algoritmo de clasificación efectivo, la clasificación por fusión agrupa los elementos de la secuencia en la mitad capa por capa, y luego comienza la comparación y clasificación desde el grupo más pequeño, cada dos grupos pequeños se fusionan en un grupo grande, y el proceso se realiza capa por capa. Al final, todos los elementos son secuenciales.
public void Mergesort(int[] arr, int left, int right) {
if(right - left gt; 0) {
int[] arr_1 = nuevo int[(derecha - izquierda)/2 1];
int[] arr_2 = nuevo int[(derecha - izquierda 1)/2];
int j = 0;
int k = 0;
for(int i = izquierda; i lt; = derecha; i ) {
if(i lt; = (derecha izquierda)/2) {
arr_1[j ] = arr[i]
}else {
arr_2[k ] = arr[i ];
}
}
Mergesort(arr_1, 0, (derecha - izquierda)/2
Mergesort(arr_2); , 0, (derecha - izquierda - 1)/2
Merge(arr_1, arr_2, arr);
public void Merge(int[] arr_1, int[] arr_2, int[] arr) {
int i = 0
int j = 0; >
int k = 0;
int L1 = arr_1.longitud
int L2 = arr_2.longitud
while(i lt; L1; amp; amp; j lt; /p>
i;
}else {
arr[k] = arr_2[j]
j; > }
k ;
}
if(i == L1) {
for(int t = j; j lt ; L2; j )
arr[k ] = arr_2[j];
}else {
for(int t = i; i lt; L1 ; i )
arr[k ] = arr_1[i];
}
}
Aquí uso izquierda para ordenar por combinación. , derecha y otras variables para hacerlas universales y no tan claras como el uso directo de números, por lo que se proporciona el pseudocódigo relevante para una fácil comprensión.
Mergesort(arr[0...n-1])
//Entrada: una matriz ordenable arr[0...n-1]
//Salida: matriz no descendente arr[0...n-1]
if ngt 1
copiar arr[0...n/2- 1] to arr_1[0...(n 1)/2-1]//Asegurar el número de elementos en arr_1 gt; = el número de elementos en arr_2
//Cuando el número total es impar número, arr_1 tiene un elemento más que arr_2; cuando el número total es un número par, no hay ningún efecto
copia arr[n/2...n-1] a arr_2[0... n/2- 1]
Mergesort(arr_1[0...(n 1)/2-1])
Mergesort(arr_2[0...n/2- 1])
Fusionar(arr_1, arr_2, arr)
Fusionar(arr_1[0...p-1], arr_2[0...q-1], arr [0.. .p q-1])
//Entrada: dos matrices ordenadas arr_1[0...p-1] y arr_2[0...q-1]
//Salida: fusionar las matrices arr_1 y arr_2 en arr
int ilt;-0;jlt;-0;klt;-0
while i lt;p span= "" dolt;="" j
if arr_1[i] lt;= arr_2[j]
arr[k] lt;- arr_1[i]
ilt;-i 1
else arr[k] lt;- arr_2[j];jlt;-j 1
klt;-k 1
si i=p
copia arr_2[j...q-1] a arr[k...p q-1]
en caso contrario copia arr_1[i... p-1] para arr[k...p q-1]
paquete test_1
import java.util.Scanner
public class Test01; {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in
int[] arr_1 = new); int[10];
for(int i = 0; i lt; 10; i)
arr_1[i] = sc.nextInt(); > Sort demo_1 = new Sort();
//1~5 solo se puede ejecutar uno a la vez. Si se ejecutan varios al mismo tiempo, solo el primero es válido y los siguientes. son una clasificación no válida. Porque el primero en ejecutarse ya ordenó la matriz ordenada.
demo_1.Select_sort(arr_1); //-----------------------1
//demo_1 .Bubble_sort(arr_1); //---------------------2
/* //--------- ------------3
demo_1.Quick_sort(arr_1, 0, arr_1.length - 1);
System.out.print("Después Después de ordenar rápidamente: ");
for(int i = 0; i lt; 10; i)
System.out.print( arr_1[i] " ");
System.out.println("");
*/
//demo_1.Insert_sort(arr_1); -------------4
/* //------------------------- -5
demo_1.Mergesort(arr_1, 0, arr_1.length - 1);
System.out.print("Después de ordenar por combinación: "); p> for(int i = 0; i lt; 10; i)
System.out.print( arr_1[i] " "); "");
*/
}
}
clase Ordenar {
intercambio vacío público ( int arr[], int a, int b) {
int t
t = arr[a];
arr[a] = arr[ b];
p>
arr[b] = t;
}
public void Select_sort(int[] arr) {
int temp, índice
for( int i=0; ilt; 10; i) {
índice =
for( int j = i 1; j lt; 10 ; j ) {
if(arr[j] lt; arr[índice])
índice =
}
/*
temp = arr[i]
arr[i] = arr[index]; arr[índice] = temp;
*/
swap(arr, i, índice
}
System.out); .pri
nt("Después de ordenar por selección: ");
for(int i = 0; i lt; 10; i)
System.out.print( arr[i] " "
System.out.println("");
}
public void Bubble_sort(int[] arr) {
int temp;
for(int i = 0; i lt; 9; i) {
for(int j = 0; j lt; 10 - i - 1; j ) {
if(arr[j] gt; arr[j 1]) {
/*
temp = arr[j]; > p>
arr[j] = arr[j 1];
arr[j 1] = temp
*/
intercambiar( arr , j, j 1);
}
}
}
System.out.print("Después de la clasificación de burbujas: ");
for(int i = 0; i lt; 10; i)
System.out.print( arr[i] " ");
System.out.println("");
}
public void Quick_sort(int[] arr, int izquierda, int derecha) {
if(izquierda gt; = derecha)
retorno
int temp, t
int j = derecha
int i; = izquierda;
temp = arr[left];
while(i lt; j) {
while(arr[j] gt; = temp amp ; amp; i lt; j)
j--;
while(arr[i] lt; = temp amp; i lt; j)
i;
if(i lt; j) {
t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
arr[izquierda] = arr[i]; >
p>
arr[i] = temp
Quick_sort(arr, izquierda, i - 1
Quick_sort(arr, i 1, derecha) ;
}
voi público
d Insert_sort(int[] arr) {
int longitud = arr.length
int[] arr_sort = nuevo int[longitud]
int count; = 0;
for(int i = 0; i lt; longitud; i ) {
if(count == 0) {
arr_sort[0 ] = arr[0];
}else if(arr[i] gt; = arr_sort[count - 1]) {
arr_sort[count] = arr[i];
}else if(arr[i] lt; arr_sort[0]) {
insert(arr, arr_sort, arr[i], 0, count
);}else {
for(int j = 0; j lt; count - 1; j ) {
if(arr[i] gt; = arr_sort[j] amp;amp; arr[i] lt; arr_sort[j 1]) {
insertar(arr, arr_sort, arr[i], j 1, contar
romper);
}
}
}
recuento
}
Sistema. out.print("Después de la inserción ordenar:");
for(int i = 0; i lt; 10; i)
System.out.print( arr_sort[i ] " ");
System.out.println("");
}
public void insert(int[] arr, int[] arr_sort, int valor, int índice, int recuento) {
for(int i = recuento; i gt; índice; i--)
arr_sort[i] = arr_sort[i- 1 ];
arr_sort[index] = valor;
}
public void Mergesort(int[] arr, int izquierda, int derecha) {
}
p>
if(derecha - izquierda gt; 0) {
int[] arr_1 = new int[(derecha - izquierda)/2 1 ];
int[] arr_2 = nuevo int[(derecha - izquierda 1)/2];
int j = 0
int k = 0; ;
para(int i =lef
t;i lt;= derecha;i) {
if(i lt;= (derecha izquierda)/2) {
arr_1[j] = arr[i]; /p>
}else {
arr_2[k ] = arr[i]
}
}
Mergesort; (arr_1, 0, (derecha - izquierda)/2
Mergesort(arr_2, 0, (derecha - izquierda - 1)/2); , arr);
}
}
public void Merge(int[] arr_1, int[] arr_2, int[] arr) {
int i = 0;
int j = 0;
int k = 0;
int L1 = arr_1.longitud >
int L2 = arr_2.length;
while(i lt; L1 amp; amp; j lt; L2) {
if(arr_1[i] lt; = arr_2[j]) {
arr[k] = arr_1[i];
i ; más {
arr; [k] = arr_2[j];
j
}
k
}
if(i == L1) {
for(int t = j; j lt; L2; j )
arr[k ] = arr_2[j];
}else {
for(int t = i; i lt; L1; i )
arr[k ] = arr_1[i]; > }
}
}
Si hay algún error, por favor corríjame, se lo agradecería mucho.