determinación de combinación vernácula especie

    En términos simples, ordenamiento por mezcla principalmente a las secuencias más ordenados en una secuencia ordenada.

    En primer vistazo a dos simples números 5, 2   , 5 y 2 será entonces la comparación directa de intercambio se convierte en la posición 2,5  . A continuación, añadir dos números 4,3  , similar, la comparación se hace intercambio de  3,4

    Ahora vamos a 2,5  y  3,4 estas dos secuencias en una secuencia ordenada, no hay ninguna base para el algoritmo de la estudiantes de primer pensamiento podría ser encontrar el número más pequeño, entonces el segundo número pequeño de tres números pequeños, etc., y finalmente convertirla en una nueva matriz para completarse.

    Pero hoy estamos hablando de una alternativa, primero dos series del primer número 2 y 3 Comparar selección más pequeña 2 en la nueva matriz, y luego pasar una después de la primera secuencia de subíndice 3 y 5 siguen comparar Selección más pequeña 3 en la nueva matriz, y luego el segundo cambio después de una secuencia subíndice 4 y 5 siguen comparar Selección más pequeña 4 en la nueva matriz, y finalmente 5 en la nueva matriz, los datos de esta nueva matriz es 2,3,4,5 secuencia ordenada. Esto se conoce como fusión especie.

Ahora nos centraremos en una especie de código de combinación:

public static void mergeSort(int arr[],int left,int right){
        if(left>=right)return;

        int mid=(right+left)/2;

        mergeSort(arr,left,mid);
        mergeSort(arr,mid+1,right);

        merge(arr,left,mid,right);

    }

    private static void merge(int[] arr, int left, int mid, int right) {

        int tmp[]=new int[right-left+1];
        int leftIndex=left;
        int rightIndex=mid+1;
        int tmpIndex=0;

        while (leftIndex<=mid && rightIndex<=right){
            if(arr[leftIndex]<=arr[rightIndex]){
                tmp[tmpIndex++]=arr[leftIndex++];
            }else{
                tmp[tmpIndex++]=arr[rightIndex++];
            }
        }

        int start=leftIndex,end=mid;

        if(rightIndex<=right){
            start=rightIndex;
            end=right;
        }

        while (start<=end){
            tmp[tmpIndex++]=arr[start++];
        }

        for(leftIndex=0;leftIndex<=right-left;leftIndex++){
            arr[left+leftIndex]=tmp[leftIndex];
        }
    }

    Los subíndices dejaron método de ordenación por fusión subíndice borde derecho de fronteras y de la matriz ordenada arr, izquierda y derecha, respectivamente arr matriz, esto es a modo de partición recursiva de la matriz y, a continuación, la operación de fusión tipo. Eso es la mitad de la matriz constantemente, hasta que el mayor margen izquierdo o igual límite derecho no puede ser la mitad hasta el momento.

  Ahora miramos a la matriz 5, 3, 2, 6, 4, un proceso de mezcla se realiza, en el que la combinación se lleva a cabo en referencia a combinación de método:

                                                 5 3 2 6 4 1 izquierda = 0 derecha = 5
                    primera recursiva 5 3 2 izquierda = 0 derecha = 2
                    segundos recursiva 5 3 izquierda = 0 derecha = 1
                    Tercer recursiva 5 izquierda = 0 derecha = 0 izquierda > = derecha, condición de terminación de retorno se alcanza
                    la cuarta recursiva 3 izquierda = 1 derecha = 1 izquierda > = derecha, condición de terminación de retorno se alcanza
                    por primera vez combinado            . 3. 5 2. 6. 1. 4 izquierda = derecha = 0 = 0. 1 MID
                    quinto recursiva 2 izquierda = 2 derecha = 2 izquierda > = derecha, se alcanza la condición de terminación de retorno
                    el segundo combinado            2356 4 1 izquierda = 0 mediados = 1 derecha = 2
                    Sexta recursiva 6 4 1 izquierda = 3 derecha = 5
                    Sexta recursiva 6 4 izquierdo = 3 derecha = 4
                    Sexta recursivas 6 izquierda = 3 derecha = 3 izquierda > = derecha, condición de terminación de retorno se alcanza
                    séptimo recursiva 4 izquierda = 4 derecha = 4 izquierda > = derecha, condición de terminación de retorno se alcanza
                    la tercera combinado. 5. 3 2 . 4. 6 . 1 = izquierda = derecha. 3. 4. 3 = MID
                    octavo recursiva 1 izquierda = 5 derecha = 5 izquierda > = derecha, se alcanza la condición de terminación de retorno
                    combinado cuarto. 3. 5 2 . 1. 4. 6                 izquierda = 3 mediados = 4 derecha = 5
                    quinto combinado            . 1 2. 5. 4. 3. 6                  izquierda = derecha = 0 MID = 2. 5

 

    Lo anterior es un procedimiento de ejecución detallada de una combinación de tipo, marcado de color rojo intercambio de datos se produce en el proceso de fusión.

    Ahora vamos a ver un detallado análisis de combinación método para fusionar última vez el ejemplo anterior, nos fijamos en el proceso de implementación de fusión:

     En primer lugar, crear una matriz tmp para el almacenamiento de datos ha sido ordenados. Entonces mediados en izquierda y derecha sub-matriz 2, respectivamente, con el centro  leftIndex y rightIndex para atravesar dos subíndices, se selecciona el número más pequeño, su correspondiente índice más 1, ad infinitum, hasta atravesado hasta el punto final. Por último, los datos sub-array restante en un tmp array, tmp los datos copiados en la lata en el arr matriz original.

 

optimización de combinación:

    Para el método de combinación, hay una manera de optimizar:

private static void mergeGuard(int[] arr, int left, int mid, int right) {
        int[] leftArr = new int[mid - left + 2];
        int[] rightArr = new int[right - mid + 1];

        for (int i = 0; i <= mid - left; i++) {
            leftArr[i] = arr[left + i];
        }
        // 第一个数组添加哨兵(最大值)
        leftArr[mid - left + 1] = Integer.MAX_VALUE;

        for (int i = 0; i < right - mid; i++) {
            rightArr[i] = arr[mid + 1 + i];
        }
        // 第二个数组添加哨兵(最大值)
        rightArr[right-mid] = Integer.MAX_VALUE;

        int i = 0;
        int j = 0;
        int k = left;
        while (k <= right) {
            // 当左边数组到达哨兵值时,i不再增加,直到右边数组读取完剩余值,同理右边数组也一样
            if (leftArr[i] <= rightArr[j]) {
                arr[k++] = leftArr[i++];
            } else {
                arr[k++] = rightArr[j++];
            }
        }
    }

   La tienda principal es el límite máximo de una matriz de enteros o menos, así que cuando la fusión, que puede ser alrededor de todos los datos en la matriz arr no son necesarios después de la finalización de los datos de comparación, los datos adicionales se ponen frontera en la nueva matriz.

 

resumen:

    Combinar tipo, esencialmente a través de la partición, una secuencia de bits se divide en un número, finalmente la fusión. Pero la mente humana es positiva, se combinan en un número de fácil de entender cuando una secuencia ordenada, a la inversa entonces Separar Combina un poco más difícil de entender. Este primer uso modo de división artículo con todos a entender la fusión del núcleo, y luego tomar paso a paso para ir comprensión en profundidad de fusión tipo.

Publicado 25 artículos originales · ganado elogios 51 · Vistas a 20000 +

Supongo que te gusta

Origin blog.csdn.net/Royal_lr/article/details/102957074
Recomendado
Clasificación