Estructura de datos: algoritmo de clasificación común (2) - clasificación de selección (clasificación de selección, clasificación de pila)

(1) Orden de selección

① Principio:

Cada vez que se selecciona el elemento más grande (o más pequeño) del intervalo desordenado y se almacena al final (o el más importante) del intervalo desordenado hasta que se organizan todos los elementos de datos que se van a ordenar.

②Implementación del código:

import java.util.Arrays;

/**
 * 选择排序
 */
public class selectSort {
    
    
    public static void main(String[] args) {
    
    
        int[] array={
    
    5,1,25,4,8,11,5,7,5,0};
        System.out.println(Arrays.toString(array));
        select(array);
        System.out.println(Arrays.toString(array));
    }
    public static void select(int[] array){
    
    
        for(int i=0;i<array.length;i++){
    
    
            for(int j=i+1;j<array.length;j++){
    
    
                if(array[j]<array[i]){
    
    
                    int tmp=array[j];
                    array[j]=array[i];
                    array[i]=tmp;
                }
            }
        }
    }
}

Ejecutar captura de pantalla:

③Análisis de rendimiento

Estabilidad: inestable

(2) Orden de montón

① Principio:

El principio básico también es seleccionar la clasificación, pero en lugar de usar el método transversal para encontrar el número más grande en el intervalo desordenado, usa el montón para seleccionar el número más grande en el intervalo desordenado.
Nota: Para orden ascendente, se deben construir pilotes grandes; para orden descendente, se deben construir pilotes pequeños.

Tipo de pila

②Implementación del código:

import java.util.Arrays;

public class HeapSort {
    
    
    //堆排序测试
    public static void main(String[] args) {
    
    
        HeapSort heapSort=new HeapSort();
        int[] array={
    
    27,15,19,18,28,34,65,49,25,37};
        System.out.println(Arrays.toString(array));
        heapSort.createBigHeap(array);
        heapSort.show();
        System.out.println();
        heapSort.heapSort();
        heapSort.show();
    }

    public int[] elem;
    public int useDsize;

    public HeapSort(){
    
    
        this.elem=new int[10];
    }
    //向下调整
    public void adjustDown(int parent,int len){
    
    
        int child=2*parent+1;
        while(child<len){
    
    
            if(child+1<len && this.elem[child]<this.elem[child+1]){
    
    
                child++;
            }
            if(this.elem[child]>this.elem[parent]){
    
    
                int tmp=this.elem[child];
                this.elem[child]=this.elem[parent];
                this.elem[parent]=tmp;
                parent=child;
                child=parent*2+1;
            }else{
    
    
                break;
            }
        }
    }
    //创建大根堆
    public void createBigHeap(int[] array){
    
    
        for(int i=0;i<array.length;i++){
    
    
            this.elem[i]=array[i];
            useDsize++;
        }
        for (int i = (this.useDsize-1-1)/2; i >=0 ; i--) {
    
    
            adjustDown(i,this.useDsize);
        }
    }
    //堆排序，先建大堆，后向下调整
    public void heapSort() {
    
    
        int end = this.useDsize - 1;
        while (end > 0) {
    
    
            int tmp = this.elem[0];
            this.elem[0] = this.elem[end];
            this.elem[end] = tmp;
            adjustDown(0, end);
            end--;
        }
    }
    //打印所排序的数组
    public void show(){
    
    
        for(int i=0;i<useDsize;i++){
    
    
            System.out.print(this.elem[i]+" ");
        }
    }
}

Ejecutar captura de pantalla:

③Análisis de rendimiento

Estabilidad : inestable