¿Cuáles son los algoritmos de clasificación más utilizados en el desarrollo de estructuras de datos en Java?
(1) Tiempo de ejecución
(2) Espacio de almacenamiento
(3) Trabajo de programación
Para una pequeña cantidad de datos, hay poca diferencia entre (1) y (2), y (3) se considera principalmente para una gran cantidad de datos, (1); es el primero.
Los principales métodos de clasificación son:
1. Clasificación por burbujas: intercambio adyacente
2. Clasificación por selección: fila más pequeña/más grande a la vez en la ubicación correspondiente. .
3. Ordenación por inserción: inserte el siguiente en la secuencia organizada.
Cuarto, clasificación de shell: reducir incremento
Verbo (abreviatura de verbo) fusionar y ordenar
Sexto, clasificación rápida
7. Clasificación de montón
8. Clasificación topológica
Primero, clasificación de burbujas
-
void BubbleSortArray()
p>{
for(int I = 1; i ltn; i )
{
for(int j = 0; i ltn- I;j )
{
if(a[j] gt;A[j 1])//Compara e intercambia elementos adyacentes.
{
Temperatura interna;
temp = a[j]; a[j]= a[j 1]; ;
}
}
}
}
-Código-
La eficiencia es O(n?), adecuada para ordenar listas pequeñas.
En segundo lugar, seleccione ordenar
-
void SelectSortArray()
{
int min _ index
for(int I = 0; i ltn-1; i)
{
min _ index = I
for ( int j = I 1;j ltn;J) //Seleccione el elemento más pequeño para cada escaneo.
if(arr[j] lt; arr[min _ index])min _ index = j;
if(min_index!=i)//Encuentra el intercambio de artículos más pequeño, Es decir, mueva el elemento a la posición correcta en la lista.
{
Temperatura interna;
temp = arr[I]; arr[I]= arr[min_index]; arr[índice mínimo]= temp;
}
}
}
-Código-
Eficiencia O(n?), Bueno para pequeñas listas ordenadas.
En tercer lugar, ordenación por inserción
-
void InsertSortArray()
{
for(int I = 1;iltn;i)//El bucle comienza desde el segundo elemento de la matriz porque arr[0] es la parte ordenada original.
{
int temp = arr[I]; //temp marca el primer elemento como desordenado.
int j = I-1;
while(j gt; = 0 amp amparr[j] gt; Temp)/*Comparar Temp con elementos ordenados de pequeño a grande, buscar determine dónde se debe insertar la temperatura */
{
arr[j 1]= arr[j];
j-;
}
arr[j 1]= temp;
}
}
-código-
Eficiencia óptima O(n); Peor eficiencia O(n?) Igual que la burbuja y la selección, adecuado para ordenar listas pequeñas.
Si la lista está básicamente ordenada, la ordenación por inserción es más eficiente que la selección de burbujas.
Cuarto, clasificación de shell: reducción de la clasificación incremental
-
void ShellSortArray()
{
para (int incr = 3; incr lt0; incr-) /// Reducción de incremento, tome el incremento 3, 2, 1 como ejemplo.
{
for(int L = 0; L lt(n-1)/incr; L ) // Repetir para cada sublista.
{
for(int I = L incr; I ltn; I =incr) //Aplicar orden de inserción a cada sublista.
{
int temp = arr[I];
int j = I-incr
mientras(j gt; = 0 amperios amparr[j] gt; temperatura)
{
arr[j incr]= arr[j];
j-= incr;
p>
}
arr[j incr]= temp;
}
}
}
}
-Código-
Adecuado para ordenar listas pequeñas.
La estimación de eficiencia o (nlog 2 n) ~ o (n 1,5) depende del tamaño inicial del valor del incremento. Se recomienda utilizar números primos para los valores de incremento porque si el valor de incremento es una potencia de 2, los mismos elementos se compararán nuevamente en la siguiente pasada.
La clasificación Shell mejora la clasificación por inserción y reduce el número de comparaciones. Es una clasificación inestable porque los elementos pueden saltar hacia adelante y hacia atrás durante el proceso de clasificación.
Verbo (abreviatura de verbo) fusionar y ordenar
-
void MergeSort(int low, int high)
{
if(lowgt=high) return; //Detener cuando quede un elemento en cada sublista.
else int mid=(low high)/2 /* Divide la lista en dos sublistas iguales. Si hay un número impar de elementos, la sublista de la izquierda es más grande que la sublista de la derecha*/
MergeSort(low, medium); //La sublista se divide aún más.
MergeSort(mid 1, high);
int[]B = new int[high-low 1] //Crea una nueva matriz para almacenar los elementos fusionados.
for(int I=low,j=mid 1,k=low;i lt=mid amp ampj lt=high;K)/*Las dos sublistas se ordenan y fusionan hasta que las dos sublistas son An fin de */
{
if(arr[I] lt; = arr[j];)
{
b [k]= arr[I];
i ;
}
Otros
{ B[k]= arr[ j ];j;}
}
for(;j lt=high;J,k)//Si todavía hay elementos en la segunda sublista, agréguelos a la nueva lista.
b[k]= arr[j];
for(; i lt= midI, k)//Si todavía hay elementos en la primera sublista, colóquelos en Agregar nueva lista.
b[k]= arr[I];
for(int z = 0; z lt high and low open 1; Z) // Todos los elementos de la matriz ordenada B Copiado a la matriz original arr.
arr[z]= B[z];
}
-Código-
Eficiencia O(nlogn), combinada Allí No hay diferencia entre la mejor, la media y la peor eficiencia de los casos de uso.
Adecuado para ordenar listas grandes, basándose en el método divide y vencerás.
Sexto, clasificación rápida
-Código-
/*Idea de algoritmo de clasificación rápida: seleccione un elemento central, divida la secuencia a ordenar, split Parte de la secuencia final es más pequeña que el elemento central y la otra parte es más grande que el elemento central, y luego se realiza el proceso anterior en las dos subsecuencias divididas. */ void swap(int a, int b){ int t; t = a; a = b = t }
int Partition(int [] arr, int bajo, int alto)
{
int pivot = arr[low]; //Utiliza el primer elemento de la subsecuencia como elemento pivote.
while(low lt; high)
{
//Encuentra el primer elemento más pequeño que el elemento pivote de la segunda mitad y la primera mitad.
while(low lt; high amparr[high]>=pivot)
{
-high;
}< / p>
//Cambie este elemento que es más pequeño que el elemento pivote a la primera mitad.
swap(arr[low], arr[high]);
//Después de ir a, busque el primer elemento en la primera mitad que sea más grande que el elemento pivote.
mientras(bajo lt; alto amparr[bajo] lt; = pivote)
{
nivel bajo;
}
swap(arr[low], arr[high]); //Cambia el elemento grande de este elemento pivote a la segunda mitad.
}
Volver a bajo; //Devuelve la posición del elemento de perspectiva.
}
clasificación rápida nula (int [] a, int baja, int alta)
{
if(baja lt alta )
{
int n=Partición (a, baja, alta
Clasificación rápida (a, baja, n
<); p>Clasificación rápida (a, n 1, alta);}
}
-Código-
Eficiencia media O( nlogn), adecuado para ordenar listas grandes.
El tiempo total del algoritmo depende de la posición del valor del pivote; elegir el primer elemento como pivote puede dar como resultado una eficiencia O(n?) en el peor de los casos. Si la cantidad está básicamente en orden, la eficiencia es la peor. Tomando el valor medio de la opción como pivote, la eficiencia es O (nlogn).
Basado en divide y vencerás.
7. Clasificación del montón
Montón máximo: las palabras clave de cualquier nodo no terminal en este último son mayores o iguales que las palabras clave de sus nodos secundarios izquierdo y derecho. del nodo superior del montón están en toda la secuencia como máximo.
Pensando:
(1) Supongamos i=l, temp = kl
(2) Calcule el hijo izquierdo de I j=2i 1;
p>
(3) Si J
(4) Compare kj y kj 1, si kj 1 gt, entonces sea j = j 1, de lo contrario j permanece sin cambios;
(5) Compare la temperatura y kj, si kj>Temp, entonces haga que ki sea igual a kj, i=j, j=2i 1, vaya a (3), de lo contrario, vaya a (6).
(6) Hacer que ki sea igual a temp y end.
-Código-
clasificación de montón vacío
{//Para la clasificación de montón de R[1...n], también podríamos usar R[0 ] Como unidad de almacenamiento temporal int I; build heap(R); //Construye R[1-n] en for(I = n;I gt1;I-)//Ordena el área desordenada actual R[1.. i ], * * * haz n-1 veces. { R[0]= R[1]; R[1]= R[I]; R[I]= R[0] //Intercambio Heapify(R, 1) entre la parte superior del montón y el último registro en el montón, I-1); //Reajusta R[1...I-1] como montón, solo R[1] puede violar las propiedades del montón}} -.
El tiempo de clasificación del montón se compone principalmente del tiempo adicional de establecer el montón inicial y el tiempo adicional de reconstruir el montón repetidamente, los cuales se implementan llamando a Heapify.
La peor complejidad temporal de la clasificación del montón es O(nlgn). El rendimiento medio de la clasificación en montón está cerca del peor rendimiento. Debido a que el montón inicial requiere más comparaciones, la clasificación del montón no es adecuada para archivos con menos registros. La clasificación del montón es una clasificación local y el espacio auxiliar es O (1), que es un método de clasificación inestable.
La diferencia entre ordenación en montón y ordenación por inserción directa;
En la ordenación por selección directa, para seleccionar el registro con la clave más pequeña...n] de R[1], es necesario comparar n-1 veces y luego seleccionar el registro con la palabra clave más pequeña de R[2]...n] y realizar n-2 comparaciones. De hecho, en las comparaciones n-2 posteriores, es posible que se hayan realizado muchas comparaciones en las comparaciones n-1 anteriores, pero dado que estos resultados de comparación no se retuvieron en la clasificación anterior, en la clasificación siguiente se repitieron estas operaciones de comparación.
La clasificación en montón puede guardar algunos resultados de comparación a través de una estructura de árbol, lo que puede reducir el número de comparaciones.
8. Clasificación topológica
Ejemplo: orden de disposición de los cursos optativos de los estudiantes
Clasificación topológica: organiza los vértices del gráfico dirigido en una secuencia lineal de acuerdo con el proceso de relación prioritaria.
Método:
Seleccione un vértice que no tenga predecesor en el gráfico dirigido y generelo.
Elimina un vértice y todos los arcos que terminan en él del gráfico.
Repita los dos pasos anteriores hasta que se hayan generado todos los vértices (la clasificación topológica es exitosa), o cuando no haya vértices sin predecesores en el gráfico (hay ciclos en el gráfico).
-Code-
Void TopologicalSort()/*Función de clasificación topológica de salida. Si G no tiene ciclo, genera la secuencia topológica de los vértices de G y devuelve OK; de lo contrario, devuelve ERROR*/
{
int in Degree[M];
int i, k, j;
char n;
int count = 0
Pila
FindInDegree; (G, en grados); //Encuentra el grado de cada vértice [0...number]
init stack(the stack); //Inicializa la pila
for( I = 0 ;myltG.numi )
Consola. WriteLine ("nodo" G.vertices[i].data "tiene el grado de "grado[i]";
for(I = 0; IltG.numi)
{
if(ingrado[i]==0)
push(la pila . vértices[I]);
}
Console. Write("La secuencia de salida de clasificación topológica es: ");
while(thestack.Peek()!=null)
{
Popup( stack.peek());
j=locatevex(G,n);
if (j==-2)
{
Console.WriteLine("Se produjo un error y el programa finalizó.");
exit();
}
Console. j].data);
count;
for(p=G.vertices[j].firstarcp!= NULLp=p.nextarc)
{
k = p . adj vex;
if (!(- grado[k]))
push(g . vértices[k] ); /p>
}
}
if(count lt; cantidad)
WriteLine("La gráfica tiene un ciclo, Error, no se puede ordenar . ");
Otros
Console. WriteLine("Clasificación exitosa.");
}
-Código-
La complejidad temporal del algoritmo es O(n e)
.