Selección de selección: selección directa y clasificación de montón

Ordenación por selección: al seleccionar el valor máximo o mínimo en la secuencia que se va a ordenar cada vez, y al eliminarlo de la cola, se envía a la nueva secuencia ordenada. Paso a paso, hasta que se seleccione el último elemento en la secuencia a ordenar, el resultado de salida es el resultado final ordenado.

Selección directa

Ordenación por selección directa, atravesando los elementos en la secuencia a ordenar cada vez, seleccionando el valor del elemento más grande o más pequeño e intercambiándolo con el elemento que debería estar en la posición, de modo que se determina la posición correspondiente del elemento. El bucle externo comienza en un cierto extremo de la secuencia, atraviesa la posición que se determinará y se ejecuta después de anidar

El diagrama de demostración dinámica es el siguiente: el

código se implementa de la siguiente manera:

import java.util.Arrays;

/**
 * @description: select sort method
 * @author: liyaguang
 * @create: 2018-12-03 13:26
 **/
public class SelectSort {
    
    public static void main(String[] args){

        int[] arrOriginal = new int[]{5, 9, 7, 4, 22, 2, 65, 1, 45};
        System.out.println("before select sort, the array is: ");
        System.out.println(Arrays.toString(arrOriginal));

        // 最小元素下标存放临时变量
        int smallestIdx;
        // 每次待确定值的索引位置
        for (int i = 0; i < arrOriginal.length - 1; i++) {
            smallestIdx = i;

            // 遍历待排序序列，选出其中最小元素
            for (int j = i+1; j < arrOriginal.length; j++) {
                if (arrOriginal[j] < arrOriginal[smallestIdx]) {
                    smallestIdx = j;
                }
            }
            
            // 将最小值移动到它对应的索引位置
            Utils.switchVal(arrOriginal, i, smallestIdx);
        }
        System.out.println("\nend select sort, the array is: ");
        System.out.println(Arrays.toString(arrOriginal));
    }
}

La complejidad temporal de la clasificación por inserción directa es O (n ² ).

Tipo de montón

Clasificación de almacenamiento dinámico : en la idea de la ordenación por selección directa, utilizando las características de la estructura de datos de almacenamiento dinámico , puede seleccionar directamente el elemento más grande o más pequeño. El montón es un tipo especial de árbol binario completo, dividido en el montón más grande o el montón más pequeño, el valor del nodo padre del montón más grande> = dos valores del nodo hijo, el valor del nodo padre del montón más pequeño <= dos valores del nodo hijo. Más tarde, el significado de montón se extendió al área de recolección de basura en lenguajes de programación.

La clave principal del algoritmo es construir una estructura de datos como un montón. A continuación se muestra el código para la ordenación del montón utilizando el montón más grande. La estructura de datos de almacenamiento dinámico máximo se implementa mediante una matriz, y el número de elementos en el almacenamiento dinámico máximo debe ser menor o igual que el número de elementos de almacenamiento, que se expresa mediante la propiedad heapSize en el objeto de clase de almacenamiento dinámico

El diagrama de demostración dinámica es el siguiente: el

código se implementa de la siguiente manera:

1. Implementación de la estructura de datos de almacenamiento dinámico máximo

/**
 * max heap data structure
 *
 * @author liyaguang
 */
public class Heap {
    private int heapSize;

    public int getHeapSize() {
        return heapSize;
    }

    public void setHeapSize(int size) {
        this.heapSize = size;
    }

    public int getParentIdx(int i) {
        return i / 2;
    }

    public int getLeftIdx(int i) {
        return 2 * i;
    }

    public int getRightIdx(int i) {
        return 2 * i + 1;
    }

    /**
     * 调整最大堆，使其符合数据结构要求
     *
     * @param arr 源数组
     * @param i   待调整元素在数组中的元素下标
     */
    public void maxHeapify(int[] arr, int i) {
        int left = getLeftIdx(i);
        int right = getRightIdx(i);
        int largest = i;
        if (left < heapSize && arr[left] > arr[largest]) {
            largest = left;
        }
        if (right < heapSize && arr[right] > arr[largest]) {
            largest = right;
        }
        if (largest != i) {
            Utils.switchVal(arr, i, largest);
            maxHeapify(arr, largest);
        }
    }

    /**
     * 构建最大堆
     *
     * @param arr 源数组
     */
    public void buildMaxHeap(int[] arr) {
        this.setHeapSize(arr.length);
        for (int i = (arr.length / 2); i >= 0; i--) {
            maxHeapify(arr, i);
        }
    }
}

2. El algoritmo principal de ordenación del montón basado en la estructura de datos del montón máximo

import java.util.Arrays;

/**
 * heap sort algorithm
 *
 * @author liyaguang
 */
public class HeapSort {

    public static void main(String[] args) {

        int[] arr = new int[]{5, 9, 7, 4, 22, 2, 65, 1, 45};
        System.out.println("before select sort, the array is: ");
        System.out.println(Arrays.toString(arr));

        // 建最大堆
        Heap heap = new Heap();
        heap.buildMaxHeap(arr);

        // 选取堆顶最大元素，放置到数组对应位置后，调整最大堆
        for (int i = arr.length - 1; i > 0; i--) {
            Utils.switchVal(arr, i, 0);
            heap.setHeapSize(heap.getHeapSize() - 1);
            heap.maxHeapify(arr, 0);
        }

        System.out.println("\nend heap sort, the array is: ");
        System.out.println(Arrays.toString(arr));
    }

}

La complejidad del tiempo de clasificación del montón es: O (nlogn)

Resumen

Al seleccionar el mejor valor cada vez, seleccione directamente el método utilizado para ordenar-atravesar, y la ordenación del montón se basa en una estructura de datos ya ordenada, y después de seleccionar el mejor valor cada vez, ajustar la estructura del montón es Sobre la base de una base ya parcialmente ordenada, se hacen muchas menos comparaciones, lo que mejora la eficiencia operativa.

Referencia:
"Introducción a los algoritmos"
Selección sort-wikiwand
Heapsort-wikiwand

Descarga de código de muestra para esta serie: bienvenido a seguir mi github