El método de clasificación rápida usa principalmente Arrays.sort () para implementarlo.
El método de burbujas es usar matrices de transversal para comparar y atravesar los valores mínimos o máximos uno por uno a través de la comparación continua.
El método de clasificación de selección es usar los primeros datos de la matriz como el valor más grande o más pequeño, y luego emitir una matriz ordenada a través de un bucle de comparación.
La clasificación de inserción es seleccionar los datos en una matriz y ordenarlos al final insertándolo y comparándolo constantemente.
La copia del código es la siguiente:
paquete com.firewolf.sort;
clase pública mysort {
/**
* @param args
*/
public static void main (string [] args) {
int array [] = {45,32,54,12,43,65,11,3,43,6,33,90,44,1,178};
MySort mySort = new mySort ();
mysort.insertsort (matriz);
System.out.print ("Insertar el resultado de clasificación:");
mySort.prinTarray (Array);
System.out.println ();
mysort.bubblesort (array);
System.out.print ("Resultado de clasificación de burbujas:");
mySort.prinTarray (Array);
mysort.qsort (matriz);
System.out.println ();
System.out.print ("Resultado de clasificación rápida:");
mySort.prinTarray (Array);
mysort.shellsort (matriz);
System.out.println ();
System.out.print ("Resultado de clasificación de la colina:");
mySort.prinTarray (Array);
mysort.selectsort (matriz);
System.out.println ();
System.out.print ("Seleccione el resultado de clasificación:");
mySort.prinTarray (Array);
}
/**
* Sorteo de inserción directa
* Idea básica: en el conjunto de números a ordenar, suponiendo que los números anteriores (N-1) [n> = 2] ya están en orden, ahora debe insertar el enésimo número en el número ordenado en el orden anterior . Repita este ciclo hasta que todos estén dispuestos en orden
*/
public void InsertSort (int [] array) {
int temp = 0;
para (int i = 1; i <array.length; i ++) {
int j = i-1;
temp = array [i];
for (; j> = 0 && temp <Array [j]; j-) {
matriz [j+1] = matriz [j];
}
matriz [j+1] = temp;
}
}
/**
* Clasificación de burbujas
* Idea básica: en el conjunto de números que se clasificarán, compare y ajusta los dos números adyacentes de arriba a abajo para hacer que los números más grandes se hundan, los más pequeños se elevan. Es decir, cada vez que se comparan dos números adyacentes y se descubre que su clasificación es opuesta a los requisitos de clasificación, se intercambian.
*/
public void bubblesort (int [] array) {
int temp;
para (int i = 0; i <array.length; i ++) {// número de viajes
para (int j = 0; j <array.length-i-1; j ++) {// número de comparaciones
if (array [j]> array [j+1]) {
temp = array [j];
matriz [j] = array [j+1];
matriz [j+1] = temp;
}
}
}
}
/**
* Clasificación rápida
* Idea básica: seleccione un elemento de referencia, generalmente el primer elemento o el último elemento, y a través de un escaneo, divida la secuencia para clasificarse en dos partes. Elemento de referencia.
* @Param Array
*/
public void Qsort (int Array []) {
if (array.length> 1) {
_QSort (matriz, 0, array.length-1);
}
}
/**
* Clasificación rápida para un viaje
* @Param Array
*/
vacío privado _qsort (int [] array, int low, int high) {
if (bajo <alto) {
int middle = getMiddle (matriz, bajo, alto);
_qsort (matriz, bajo, medio-1);
_QSort (matriz, medio+1, alto);
}
}
/**
* Obtener el valor intermedio
*/
Private int getMiddle (int [] array, int low, int high) {
int tmp = array [bajo];
mientras (bajo <alto) {
while (bajo <high && array [high]> = tmp)
Alto--;
matriz [baja] = matriz [alta];
while (bajo <high && array [bajo] <= tmp)
bajo ++;
matriz [alto] = matriz [bajo];
}
matriz [baja] = tmp;
regresar bajo;
}
/**
* Orden de selección simple
* Idea básica: entre el conjunto de números que se clasificarán, seleccione el número más pequeño y cambie con el número en la primera posición; camino hasta que el penúltimo número se compara con el último número.
* @Param Array
*/
public void selectSort (int [] array) {
INT POSICIÓN = 0;
para (int i = 0; i <array.length; i ++) {
int j = i+1;
posición = i;
int temp = array [i];
para (; j <array.length; j ++) {
if (array [j] <temp) {
temp = array [j];
posición = j;
}
}
matriz [posición] = matriz [i];
matriz [i] = temp;
}
}
/**
* Sorteo de la colina (ordenación mínima incremental)
* Idea básica: el algoritmo primero divide el número que se clasificará en varios grupos de acuerdo con un cierto incremento d (n/2, n es el número de números que se clasificarán), y los subíndices registrados en cada grupo son diferentes de d. Para cada grupo, todos los elementos se clasifican directamente, luego se agrupan con un incremento más pequeño (d/2) y luego se clasifican directamente en cada grupo. Cuando el incremento se reduce a 1, la clasificación se completa después de que se realiza el tipo de inserción directa.
* @Param Array
*/
public void shellsort (int [] array) {
doble d1 = array.length;
int temp = 0;
while (verdadero) {
d1 = math.ceil (d1/2);
int d = (int) d1;
para (int x = 0; x <d; x ++) {
para (int i = x+d; i <array.length; i+= d) {
int j = id;
temp = array [i];
for (; j> = 0 && temp <Array [j]; j- = d) {
matriz [j+d] = array [j];
}
matriz [j+d] = temp;
}
}
if (d == 1)
romper;
}
}
/**
* Imprima todos los elementos en la matriz
*/
public void printArray (int [] array) {
para (int i = 0; i <array.length; i ++) {
System.out.print (Array [i]+"");
}
}
}
Aquí hay algunos ejemplos de métodos de clasificación utilizados por separado
Clasificación rápida utilizando el método de clasificación con matrices
La copia del código es la siguiente:
importar java.util.arrays;
Test2 de clase pública {
public static void main (string [] args) {
int [] a = {5,4,2,4,9,1};
Arrays.sort (a);
para (int i: a) {
System.out.print (i);
}
}
}
Algoritmo de clasificación de burbujas
La copia del código es la siguiente:
public static int [] bubblesort (int [] args) {// Algoritmo de clasificación de burbujas
para (int i = 0; i <args.length-1; i ++) {
para (int j = i+1; j <args.length; j ++) {
if (args [i]> args [j]) {
int temp = args [i];
args [i] = args [j];
args [j] = temp;
}
}
}
devolver args;
}
Seleccione el algoritmo de clasificación
La copia del código es la siguiente:
public static int [] selectSort (int [] args) {// Seleccione Algoritmo de clasificación
para (int i = 0; i <args.length-1; i ++) {
int min = i;
para (int j = i+1; j <args.length; j ++) {
if (args [min]> args [j]) {
min = j;
}
}
if (min! = i) {
int temp = args [i];
args [i] = args [min];
args [min] = temp;
}
}
devolver args;
}
Algoritmo de clasificación de insertar
La copia del código es la siguiente:
public static int [] InsertSort (int [] args) {// algoritmo de clasificación insertar
para (int i = 1; i <args.length; i ++) {
para (int j = i; j> 0; j-) {
if (args [j] <args [j-1]) {
int temp = args [j-1];
args [j-1] = args [j];
args [j] = temp;
} el más ruptura;
}
}
devolver args;
}
Los anteriores son cuatro métodos de clasificación en Java. Los diferentes métodos tienen diferentes eficiencias.
Sorteo de burbujas: comparación O (N2) Intercambio de datos O (N2)
Seleccione Ordenar: Compare O (N2) Intercambio de datos O (N)
Sorteo de inserción: Compare o (N2) Copiar datos o (n)
En aplicaciones prácticas, debemos intentar elegir algoritmos eficientes.