Prefacio: La idea original de enamorarse de Java nunca se ha olvidado: "Compartir los resultados de mi aprendizaje, no importa cuán profunda sea la tecnología posterior, es importante sentar una buena base".
Intercambiador de clase de herramienta, esta clase de herramienta se utilizará en algoritmos posteriores:
Copie el código de código de la siguiente manera:
paquete com.meritit.sortord.util;
/**
* Una utilidad para intercambiar el elemento de remolque de Array
*
* @autor ysjian
* @versión 1.0
* @correo electrónico [email protected]
*@QQ 646633781
*@teléfono 18192235667
* @csdnBlog http://blog.csdn.net/ysjian_pingcx
* @createTime 2013-12-20
* @copyRight Mérito
*/
Intercambiador de clase pública {
intercambio privado() {
}
/**
* Intercambiar dos elementos de la matriz.
*
* @param oneIndex
* un índice
* @param otro índice
* otro índice
* matriz @param
* la matriz a intercambiar
* @exception NullPointerException
* si la matriz es nula
*/
public static <T extiende Comparable<T>> void swap(int oneIndex,
int otro índice, matriz T[]) {
si (matriz == nulo) {
lanzar nueva NullPointerException ("entrada de valor nulo");
}
checkIndexs (un índice, otro índice, matriz.longitud);
T temp = matriz[oneIndex];
matriz[uníndice] = matriz[otroíndice];
matriz[otroIndice] = temp;
}
/**
* Intercambiar dos elementos de la matriz.
*
* @param oneIndex
* un índice
* @param otro índice
* otro índice
* matriz @param
* la matriz a intercambiar
* @exception NullPointerException
* si la matriz es nula
*/
intercambio de vacío estático público (int un índice, int otro índice, int [] matriz) {
si (matriz == nulo) {
lanzar nueva NullPointerException ("entrada de valor nulo");
}
checkIndexs (un índice, otro índice, matriz.longitud);
int temp = matriz[oneIndex];
matriz[uníndice] = matriz[otroíndice];
matriz[otroIndice] = temp;
}
/**
* Verifique el índice si está en el arreglo.
*
* @param oneIndex
* un índice
* @param otro índice
* otro índice
* @param longitudarray
* la longitud de la matriz
* @exception IllegalArgumentException
* si el índice está fuera del rango
*/
checkIndexs vacíos estáticos privados (int oneIndex, int anotherIndex,
int longitud de la matriz) {
if (uníndice < 0 || otroíndice < 0 || uníndice >= longitudmatriz
|| otro índice >= longitud de la matriz) {
lanzar una nueva IllegalArgumentException(
"illegalArguments para índices de remolque [" + oneIndex + ","
+ unIndice + "]");
}
}
}
Ordenación por inserción directa, InsertionSortord:
Copie el código de código de la siguiente manera:
paquete com.meritit.sortord.insertion;
/**
* Orden de inserción, la complejidad del tiempo es O(n2)
*
* @autor ysjian
* @versión 1.0
* @correo electrónico [email protected]
*@QQ 646633781
*@teléfono 18192235667
* @csdnBlog http://blog.csdn.net/ysjian_pingcx
* @createTime 2013-12-31
* @copyRight Mérito
* @desde 1.5
*/
clase pública InsertionSortord {
INSTANCIA InsertionSortord final estática privada = new InsertionSortord();
Sorteo de inserción privado() {
}
/**
* Obtener la instancia de InsertionSortord, solo una instancia
*
* @return la única instancia
*/
InsertionSortord estático público getInstance() {
devolver INSTANCIA;
}
/**
* Ordena la matriz de <code>int</code> con orden de inserción
*
* matriz @param
* la matriz de int
*/
public void hacerOrdenar (int... matriz) {
if (matriz! = nulo && matriz.longitud > 0) {
int longitud = matriz.longitud;
// la circulación comienza en 1, el valor del índice 0 es referencia
para (int i = 1; i < longitud; i++) {
si (matriz[i] <matriz[i - 1]) {
// si el valor en el índice i es menor que el valor en el índice i-1
int vacante = i; // registra la vacante como i
// establece un centinela como valor en el índice i
int centinela = matriz[i];
// circulación de claves, del índice i-1,
para (int j = i - 1; j >= 0; j--) {
si (matriz[j] > centinela) {
/*
* si el valor del índice actual excede el
* centinela, luego retrocede, establece el registro del nuevo
* vacante como j
*/
matriz[j + 1] = matriz[j];
vacante = j;
}
}
// establece el centinela en la nueva vacante
matriz[vacante] = centinela;
}
}
}
}
/**
* Ordena la matriz de <code>T</code> genérico con orden de inserción
*
* matriz @param
* la matriz de genéricos
*/
público <T extiende Comparable<T>> void doSortT(T[] matriz) {
if (matriz! = nulo && matriz.longitud > 0) {
int longitud = matriz.longitud;
para (int i = 1; i < longitud; i++) {
si (matriz[i].compareTo(matriz[i - 1]) < 0) {
T centinela = matriz[i];
int vacante = i;
para (int j = i - 1; j >= 0; j--) {
if (matriz[j].compareTo(centinela) > 0) {
matriz[j + 1] = matriz[j];
vacante = j;
}
}
matriz[vacante] = centinela;
}
}
}
}
}
Prueba TestInsertionSortord:
Copie el código de código de la siguiente manera:
paquete com.meritit.sortord.insertion;
importar java.util.Arrays;
/**
* Orden de clasificación de inserción de prueba
*
* @autor ysjian
* @versión 1.0
* @correo electrónico [email protected]
*@QQ 646633781
*@teléfono 18192235667
* @createTime 2013-12-31
* @copyRight Mérito
*/
clase pública TestInsertionSortord {
público estático vacío principal (String [] argumentos) {
InsertionSortord insertSort = InsertionSortord.getInstance();
int[] matriz = {3, 5, 4, 2, 6};
System.out.println(Arrays.toString(matriz));
insertSort.doSort(matriz);
System.out.println(Arrays.toString(matriz));
System.out.println("---------------");
Entero[] matriz1 = { 3, 5, 4, 2, 6 };
System.out.println(Arrays.toString(array1));
insertSort.doSortT(array1);
System.out.println(Arrays.toString(array1));
}
}