algoritmos clásicos diez (java código para lograr)

algoritmo general

Ordenando un grupo de objetos es la de reorganizar el orden de acuerdo con algún proceso lógico. Diez tipos de algoritmos de clasificación se dividen generalmente en dos categorías:

algoritmos de clasificación

Comparación de clasificación clase : determina el orden relativo entre los elementos mediante la comparación de
Comparación de las categorías no clasificadas : no determinado por el orden relativo entre el elemento de comparación, que puede romper basado en una comparación límite de tiempo ordenado, ejecute en el tiempo lineal, también conocido como el tiempo de clase comparación tipo no lineal.

complejidad del algoritmo

Términos relacionados

Tiempo Complejidad : algoritmo de tiempo sólo consume recursos, en general, es una cuestión del tamaño del algoritmo de ordenador de la función F n (n), la complejidad de tiempo del algoritmo hace referencia como T (n) = O (f (n)), complejidad de tiempo comunes son: orden constante O (1), del orden de O (log n), orden lineal O (n), el orden lineal de O (nlogn), el cuadrado de la orden O (n- ^{2) ..... K º orden O (n} K), orden exponencial O (2 ^ n). con el creciente problema de n, dicha constante de tiempo se incrementa la complejidad, menor será la eficiencia del algoritmo.
complejidad espacio : que los algoritmos de recursos espaciales requieren el consumo se contabiliza para el funcionamiento de la memoria del ordenador.
Estabilidad : si antes de antes de la clasificación, r [i] = r [ j] y r [i] antes de r [j], después de la clasificación, r [i] es todavía r [j].
Inestable : si antes de la clasificación, r [i] = r [ j] y r [i] antes de r [j], después de la clasificación, r [i] en el r [j] después.

1. Ordenar la burbuja

Ordenamiento de burbuja (Inglés: Bubble Sort) también llamado ordenamiento de burbuja, es una clasificación de algoritmo simple. Se visitó varias veces el número de columnas para ordenar, comparar los dos primeros elementos, si los ponen en el intercambio orden equivocado otra vez. El número de visitas a la obra columna se repite hasta que ya no hay necesidad de intercambio, es decir el número de columnas ya ordenados completó. El origen del nombre del algoritmo se debe a que los elementos más pequeños lentamente a través del intercambio de "flotar" a la parte superior de las columnas.

proceso de operación de 1,1 algoritmo

Comparación de elementos adyacentes. Si el primero es mayor que el segundo, los dos de ellos intercambiaron.
Hacer el mismo trabajo para cada par de elementos adyacentes, desde el principio hasta el final de la primera a la última pareja. Una vez hecho esto, el último elemento es el número más grande.
Repita estos pasos para todos los elementos, excepto el último.
Continúa repetir los pasos anteriores para cada vez menos y menos elementos, un par de números hasta que no hay necesidad de comparar.

La figura 1.2 muestra el móvil

implementar el pseudocódigo 1,3

  function bubble_sort (array, length) {
    var i, j;
        for(i from 0 to length-1){
    for(j from 0 to length-1-i){
        if (array[j] > array[j+1])
            swap(array[j], array[j+1])
    }
  }
}

1.4 Java implementación del código

 public static int[] bubbleSort(int[] array){
    int temp;
    for (int i = 0; i < array.length-1 ; i++) {
        for (int j = 0; j < array.length-1-i ; j++) {
             // 进行比较，完成数的交换
            if(array[j]> array[j+1]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
    return array;
}

2. Seleccione Ordenar

La clasificación es un simple y un manejo intuitivo algoritmo de ordenación. La principal ventaja es que con datos móvil, y si un elemento en la posición correcta no se moverá. En todo depende por completo de los elementos de conmutación para mover en el método de clasificación, selección especie perteneciente a una especie de muy buena.

proceso de operación de 2,1 algoritmo

En primer lugar, encontrar la secuencia más pequeño de elementos no seleccionados (grande), la posición de inicio se almacena en la secuencia ordenada.
De los restantes sin clasificar, a continuación, seguir buscando el elemento mínimo elemento (grande), y luego en el final de la secuencia ordenada.
Repita los pasos 1-2 hasta el final de la clasificación

La figura 2.2 muestra mueven

2.3 Java implementación del código

  public static void selectSort(Comparable[] array){
    for (int i = 0; i < array.length-1; i++) {
        int min = i;
         // 1.寻找最小元素
        for (int j = i+1; j < array.length ; j++) {
              if(less(array[j],array[min])) min = j;
        }
        
        // 2.将最小元素放到已排序的队尾
        exch(array,i,min);
        i++;
    }
}


 //=====================辅助方法============================
 // 元素的交换
 private static void exch(Comparable[] array, int i, int min) {
    Object temp = array[i];
    array[i] = array[min];
    array[min] = (Comparable) temp;
}
 // 元素的比较
 private static boolean less( Comparable i, Comparable j) {
    return i.compareTo(j) < 0;
}

3. Inserción Ordenar

Es una forma sencilla y intuitiva algoritmo de ordenación. Funciona mediante la construcción de una secuencia ordenada, para los datos sin clasificar, escanear en la secuencia ordenada de atrás hacia adelante, y encontrar las posiciones de inserción correspondientes.

proceso de operación 3.1 algoritmo

Desde el comienzo del primer elemento, el elemento se puede considerar que han sido ordenados
Un elemento de retirada inferior, desde la búsqueda de nuevo se ha descrito en la secuencia ordenada de elementos.
Si el elemento es mayor que el nuevo elemento, el elemento a la siguiente posición
Repita el paso 3 hasta que encuentra los elementos ordenados de menos de o igual a la nueva posición del elemento
Después de que el nuevo elemento se inserta en la posición
Repita los pasos 2-5.

3.2 Imágenes en Movimiento Mostrar

3.3 Java implementación del código

public static void insertSort(Comparable[] array){
    for (int i = 0; i < array.length ; i++) {
        for (int j = i; j>0 && less(array[j],array[j-1]); j++) {
            exch(array,j,j-1);
        }
    }
}

//=================辅助方法============================
 // 元素的交换
 private static void exch(Comparable[] array, int i, int min) {
    Object temp = array[i];
    array[i] = array[min];
    array[min] = (Comparable) temp;
}
 // 元素的比较
 private static boolean less( Comparable i, Comparable j) {
    return i.compareTo(j) < 0;
}

4. ordenación Shell

También conocido como algoritmos de ordenación Descendente incrementales, ordenación por inserción es una versión mejorada más eficiente. Colina clasificación algoritmo de ordenación no estacionario.

4.1 MEJORAS ordenación por inserción basada

Al seleccionar una secuencia T1 incrementales, t2, ..., tk, donde ti> TJ, tk = 1;
Incrementos el número de secuencia k, k veces la secuencia es ordenadas;
Ordenar por viaje, de acuerdo con la TI incremento correspondiente, una columna a ser ordenados en varias sub-secuencias de longitud m de cada sub-tabla para cada tipo de inserción directa. Sólo el factor delta es 1, la secuencia completa como una mesa de procesamiento, la longitud de la tabla es la longitud de toda la secuencia.

La figura 4.2 muestra mueven

4.3 Java implementación del código

   public static void shellSort(Comparable[] array){

    int n = array.length;
    int h = 1;
     
    while(h < n/4) h = 4*h+1;
     
    while(h >=1){
        for (int i = h; i < n ; i++) {
            for (int j = i; j >= h && less(array[j],array[j-h]) ; j-=h) {
                exch(array,j,j-h);
            }
        }
        // 步长为4 
        h /= 4;
    }
}

5. fusión especie

operación de combinación de tipo de combinación se crea en un algoritmo de clasificación eficiente, la eficiencia de O (n \ log n) (notación O grande) Este algoritmo es una aplicación muy típico utiliza un método de divide y vencerás, y las capas partición recursiva podrá, en el mismo tiempo.

proceso de operación de 5,1 algoritmo

Las aplicaciones espaciales, por lo que el tamaño de la suma de dos secuencias ordenadas, el espacio de almacenamiento para la secuencia fusionada
Configuración de dos punteros, inicialmente clasificado en dos posiciones, respectivamente una posición de partida de la secuencia de
Comparación de dos puntero apunta a un elemento, el elemento seleccionado en un espacio relativamente pequeño a fusionarse, y mover el puntero a la siguiente posición
Repita el paso 3 hasta que el puntero alcanza el final de la secuencia de una
Todos los elementos restantes de otra secuencia directamente copiado en el final de la secuencia se combinaron

La Figura 5.2 muestra mueven

5.3 Java implementación del código

 // 归并排序的实现，使用的递归  
 public static void mergeSort(Comparable[] array){
    Comparable[] aux = new Comparable[array.length];
     mergeSort(array,aux,0,array.length-1);
}

// 归并排序的实现
public static void mergeSort(Comparable[] array,Comparable[] tempArr,int lo,int hi){
    if(lo >= hi) return;
    int mid = (lo+hi)/2;
    mergeSort(array,tempArr,lo,mid);
    mergeSort(array,tempArr,mid+1,hi);
    merge(array,tempArr,lo,hi);
}

//====================================辅助方法================================

// 原地归并的抽象方法
 private static void merge(Comparable[] array, Comparable[] tempArr, int lo, int hi) {
     // 将 array[lo....mid] 和array[mid+1....hi]归并
    int mid = (lo+hi)/2;

    // 将array[lo..hi] 复制到tempArr[lo..hi]中
    for (int i = 0; i < array.length ; i++) {
        tempArr[i] = array[i];
    }

    // 归并回到原数组array[lo....hi]
    int i = lo,j = mid+1;
    for (int k = lo; k <= hi ; k++) {
        if(i > mid) array[k] = tempArr[j++];
        else  if(j > hi) array[k] = tempArr[i++];
        else if(less(array[j],array[i])) array[k] = tempArr[j++];
        else array[k] = tempArr[i++];
    }
}
  
     // 元素的交换
 private static void exch(Comparable[] array, int i, int min) {
    Object temp = array[i];
    array[i] = array[min];
    array[min] = (Comparable) temp;
}
 // 元素的比较
 private static boolean less( Comparable i, Comparable j) {
    return i.compareTo(j) < 0;
}

6. Ordenación rápida

intercambio Ordena, también conocida como la división, referido como fila rápido Un algoritmo de ordenación. Bajo condiciones normales, para ordenar n elementos a O (n \ log n) comparación de los tiempos. En la peor situación que necesita O (n ^ 2) comparaciones, pero esta situación no es infrecuente.

proceso de operación de 6,1 algoritmo

La selección del valor de referencia: elegir un número de elementos de la columna, llamado "punto de referencia"
Segmentación: columnas de reordenamiento, todo menor que el valor de referencia se coloca en frente del elemento de referencia, todas más grandes que los elementos de valor de referencia colocados detrás de la referencia (igual al valor de referencia puede ser cualquier número de lado). Después del final de esta división, tipo de valores de referencia se ha completado,
secuencia de clasificación recursiva: secuencia recursiva será más pequeño que el valor de referencia del elemento es mayor que el valor de referencia de la secuencia ordenada de elementos.

La Figura 6.2 muestra mueven

pseudocódigo 6.3 se dan cuenta

function quicksort(q)
{
 var list less, pivotList, greater
 if length(q) ≤ 1 
     return q
 else 
 {
     select a pivot value pivot from q
     for each x in q except the pivot element
     {
         if x < pivot then add x to less
         if x ≥ pivot then add x to greater
     }
     add pivot to pivotList
     return concatenate(quicksort(less), pivotList, quicksort(greater))
 }
}

6.4 Java implementación del código

 public static void sort(Comparable[] array, int lo, int length) {
	
	if(length <= lo) return;
	
            // 找出基准值的索引
	int j = partition(array,lo,length);
	
	 // 使用递归前部部分排序
	 sort(array,lo,j-1);
	 
	 // 后半部分排序
	 sort(array,j+1,length);
}
 
 // 找出基准值的方法
 private static int partition(Comparable[] array, int lo, int length) {
	 int i = lo,j = length+1;
	 Comparable temp = array[lo];
	 
	 // 实现左右的扫描找出这个数
	 while(true) {
		 while(less(array[++i],temp)) if(i == length) break;
		 while(less(temp,array[--j])) if(j == lo) break;
		 if(i >= j) break;
		 // 将左边大于中间值的与右边小于中间值进行交换
		 exch(array,i,j);
	 }
	 
	 // 将j放入到相应的位置
	 exch(array,lo,j);
	 return j;
}

 // 元素的交换
 private static void exch(Comparable[] array, int i, int min) {
    Object temp = array[i];
    array[i] = array[min];
    array[min] = (Comparable) temp;
}

7 pila de clasificación

Se refiere a un algoritmo de pila de clasificación para ordenar una tal estructura de datos diseñada para uso montón. La acumulación es una estructura de árbol binario completo de aproximación, mientras que el cumplimiento de las propiedades a granel: es decir, la tecla o el índice de sub-nodo es siempre menor que (o mayor que) su nodo padre.

proceso de operación de 7,1 algoritmo

La cadena de clave inicial a clasificar (R1, R2 ... .rn) construido para ser más grande que la parte superior de la pila, la pila de la región desordenada inicial;
La parte superior de la pila de elementos R [. 1] y el último elemento de R [n-] intercambiados, esta vez para obtener las nuevas regiones desordenadas (R1, R2, ...... RN-1) y las nuevas regiones ordenados (Rn de), y satisfaciendo R [1,2 ... n-1] <= R [n];
Dado que la nueva parte superior de la pila después de que el intercambio de R [1] puede estar en violación de la naturaleza de la pila, es necesario que las regiones desordenadas de corriente (R1, R2, ...... Rn-1) se ajusta a la nueva pila, y luego de nuevo R [1] y desordenado intercambiar los últimos resultados de la zona elemento en una nueva desordenada regiones (R1, R2 ... .rn-2) y las nuevas regiones ordenados (RN-1, Rn).
Este proceso se repite hasta que el número de elementos ordenados regiones de n-1, todo el proceso de clasificación es completa.

Figura 7.2 muestra mueven

7.3 Java implementación del código

    public static void sort(Comparable[] array){
    int n = array.length;

    // 实现堆化
    for (int k =n/2; k > 0 ; k--) {
        sink(array,k,n);
    }

    int k = n;
    // 实现排序
    while (k > 1){
        exch(array,1,k--);
        sink(array,1,k);
    }
 }

  // 元素的下沉
private static void sink(Comparable[] array, int k, int n) {
    while(2*k <= n){
        int j = 2*k;
        if(j<n && less(array,j,j+1)) j++;
        if(!less(array,k,j)) break;
        exch(array,k,j);
        k = j;
    }
}

private static void exch(Comparable[] array, int k, int j) {
    Object temp = array[k-1];
    array[k-1] = array[j-1];
    array[j-1] = (Comparable) temp;
}

private static boolean less(Comparable[] array, int i, int j) {
    return array[i-1].compareTo(array[j-1]) < 0 ;
}

8. secuenciación conteo

Contando secuenciación es un estable lineal algoritmo de ordenación tiempo. Contando secuenciación utilizando una matriz adicional C, donde el i-ésimo elemento es ser ordenada valor de la matriz A es igual al número de elementos i. La matriz es entonces C para ser descargado a los elementos de A en la posición correcta.

proceso de operación de 8,1 algoritmo

El array a ordenar para encontrar el elemento de mayor y menor
Contar el número de veces que cada elemento de la matriz es la aparición de i, almacenada en un conjunto de elemento i de C
Los conteos acumulados de todos (el primer elemento C comienza, y antes de cada adición a)
Reverse llenar la matriz de destino: i en cada elemento de la nueva matriz C [i] artículos, cada elemento a poner un C [i] restando 1

Figura 8.2 muestra mueven

8.3 Java implementación del código

 public static int[] countingSort(int[] A) {
    int[] B = new int[A.length];
    // 假设A中的数据a'有，0<=a' && a' < k并且k=100
    int k = 100;
    countingSort(A, B, k);
    return B;
}

private static void countingSort(int[] A, int[] B, int k) {
    int[] C = new int[k];

    // 计数
    for (int j = 0; j < A.length; j++) {
        int a = A[j];
        C[a] += 1;
    }

    // 求计数和
    for (int i = 1; i < k; i++) {
        C[i] = C[i] + C[i - 1];
    }
    // 整理
    for (int j = A.length - 1; j >= 0; j--) {
        int a = A[j];
        B[C[a] - 1] = a;
        C[a] -= 1;
    }
}

9. cubo especie

Bucket sort (Bucket especie) o el llamado cuadro de tipo es un algoritmo de clasificación, el principio es para ser asignado a un número limitado de matriz de cubo. Cada cubeta individual y luego ordenados (es posible reutilización o cualquier otro algoritmo de ordenación de forma recursiva continuar usando balde sorting). Cubo especie es un resultado resumido casillero o menos. Cuando el valor de la matriz que ser resuelto se distribuye uniformemente, cubo especie utilizando un tiempo de O lineal (n). Pero no se pueden comparar la clasificación cubo especie, que no se ve afectada por O (n \ log n) límite inferior.

proceso de operación 9.1 algoritmo

Establecer una matriz cuantitativa como un cubo vacío.
Buscar secuencia y al proyecto en un cubo correspondiente a.
Cada uno no vaciar el cubo tipo.
De la casa no es proyectos barril vacío y luego de vuelta a la secuencia original.

Figura 9.2 muestra mueven

9.3 Java implementación del código

  public void bucketSort(int[] arr) {

    int max = arr[0], min = arr[0];
    for (int a : arr) {
        if (max < a)
            max = a;
        if (min > a)
            min = a;
    }
    // 该值根据实际情况选择
    int bucketNum = max / 10 - min / 10 + 1;
    List buckList = new ArrayList<List<Integer>>();
    // 创建桶
    for (int i = 1; i <= bucketNum; i++) {
        buckList.add(new ArrayList<Integer>());
    }
    // 向桶内装入数据
    for (int i = 0; i < arr.length; i++) {
        int index = indexFor(arr[i], min, 10);
        ((ArrayList<Integer>) buckList.get(index)).add(arr[i]);
    }
    ArrayList<Integer> bucket = null;
    int index = 0;
    for (int i = 0; i < bucketNum; i++) {
        bucket = (ArrayList<Integer>) buckList.get(i);
        insertSort(bucket);
        for (int k : bucket) {
            arr[index++] = k;
        }
    }

}

// 把桶內元素插入排序
private void insertSort(List<Integer> bucket) {
    for (int i = 1; i < bucket.size(); i++) {
        int temp = bucket.get(i);
        int j = i - 1;
        for (; j >= 0 && bucket.get(j) > temp; j--) {
            bucket.set(j + 1, bucket.get(j));
        }
        bucket.set(j + 1, temp);
    }
}

private int indexFor(int a, int min, int step) {
    return (a - min) / step;
}

10. El Radix sort

Tipo de comparación es un no entero algoritmo de clasificación, el principio es el número entero de bits es cortado por números diferentes, se compararon a continuación, el número de bits para cada uno. Dado que el número entero se puede expresar cadenas de punto flotante (como el nombre o la fecha) y un formato específico, la raíz especie no sólo se utiliza para el número entero.

proceso de operación de 10.1 algoritmo

Obtener el número máximo de matriz y obtener el número de bits;
arr matriz original, comenzó a tomar cada matriz de bits radix desde el bit menos significativo;
Radix tipo de recuento (recuento de secuenciación utilizando características adecuadas varían decimal)

Figura 10.2 muestra mueven

10.3 Java implementación del código

  public void radixSort(int[] array,int d ) {
    int n=1; //代表位数对应的数：1,10,100...
    int k=0;//保存每一位排序后的结果用于下一位的排序输入
    int length=array.length;
    int[][] bucket=new int[10][length];//排序桶用于保存每次排序后的结果，这一位上排序结果相同的数字放在同一个桶里
    int[] order=new int[length];//用于保存每个桶里有多少个数字
    while(n<d)
    {
        for(int num:array) //将数组array里的每个数字放在相应的桶里
        {
            int digit=(num/n)%10;
            bucket[digit][order[digit]]=num;
            order[digit]++;
        }
        for(int i=0;i<length;i++)//将前一个循环生成的桶里的数据覆盖到原数组中用于保存这一位的排序结果
        {
            if(order[i]!=0)//这个桶里有数据，从上到下遍历这个桶并将数据保存到原数组中
            {
                for(int j=0;j<order[i];j++)
                {
                    array[k]=bucket[i][j];
                    k++;
                }
            }
            order[i]=0;//将桶里计数器置0，用于下一次位排序
        }
        n*=10;
        k=0;//将k置0，用于下一轮保存位排序结果
    }
}

Referencias y el blog

el blog de referencia

Nota: Lo anterior es parte de un contenido de imágenes en movimiento y los dos siguientes extracto blog desde, si la infracción, contacto eliminado.

https://www.cnblogs.com/onepixel/p/7674659.html
https://www.cnblogs.com/developerY/p/3172379.html
Si desea conocer la implementación especie Javascript, la visita propuesta https://www.cnblogs.com/onepixel/p/7674659.html

material de referencia

Wikipedia
hacia adelante "Algoritmo" Robert Sedgewick

Ten ordenadas aplicación java (con la figura móvil)