Implementación Java de pila, cola y montón

Uno, la pila

Características: Primero en entrar, primero en salir (FILO).
Implementación del código: Java recomienda oficialmente el uso de la interfaz Deque (cola de dos extremos) para implementar la pila. No use la clase Stack (subclase de clase Vector) para lograr una baja eficiencia.

Deque tiene dos clases de implementación de uso común, a saber, ArrayDeque (matriz inferior) y LinkedList (lista vinculada inferior).
¿En cuanto a cómo elegir entre estos dos? Creo que ambos tienen ventajas y desventajas.

• LinkedList implica la creación y destrucción de un Nodo cada vez que se inserta o elimina un elemento, la eficiencia es baja, la estructura de almacenamiento de LinkedList no es continua y el acceso no puede hacer un buen uso de la caché de la CPU. Puede insertar null.
• ArrayDeque es más eficiente al insertar o eliminar un elemento porque la capa inferior es una matriz. Pero cuando los datos están completamente ensamblados, es necesario copiarlos nuevamente. No se puede insertar nulo. Se
  
  recomienda usar ArrayDeque. Cuando se conoce el tamaño de la pila, es mejor pasar el tamaño al crearlo. El tamaño predeterminado (sin pasar parámetros) es 16, el mínimo es 8 y se pasan otros valores. El tamaño es mayor que el valor de 2 elevado a n, y el máximo es $2^{30}$ .

public void testStack() {
    
    
        Deque<Integer> stack = new ArrayDeque<>();

        //入栈
        stack.push(1);
        stack.push(2);

        //返回栈顶元素，但不出栈
        Integer a1 = stack.peek();
        System.out.println(a1);//2

        //出栈
        Integer a2 = stack.pop();
        System.out.println(a2);//2
        Integer a3 = stack.pop();
        System.out.println(a3);//1
        
    }

Segundo, la cola

Características: Primero en entrar, primero en salir (FIFO)

Implementación de código: use la interfaz Queue o use la interfaz Deque. Deque heredó Queue. La clase de implementación se selecciona como se indicó anteriormente.

public void test1() {
    
    
        Queue<Integer> queue = new ArrayDeque<>();

        //入队
        queue.offer(1);
        queue.offer(2);

        //出队
        Integer a1 = queue.poll();
        System.out.println(a1);//1

        //查看队首元素,但不出队
        Integer a2 = queue.peek();
        System.out.println(a2);//2
    }

3. Montón

Características:

1. El valor de cualquier nodo no hoja en el montón no es menor que (montón superior grande) ni mayor que (montón superior pequeño) el valor de sus nodos secundarios.
2. El montón es siempre un árbol binario completo.
   En resumen, conozca la pila superior grande heap[i]>=heap[2*i+1]y la heap[i]>=heap[2(i+1)]pila superior pequeña heap[i]<=heap[2*i+1]yheap[i]<=heap[2(i+1)]

Árbol binario completo: si la profundidad del árbol binario es k, el número de nodos en cada capa, excepto la capa k, ha alcanzado el número máximo, y todos los nodos de la capa k se concentran contiguamente en el lado más a la izquierda, que es un árbol binario completo. Como se muestra abajo:

Implementación del código: use la clase PriorityQueue para implementar, preste atención a que los elementos almacenados deben ser una clasificación natural (Comparable) o una clasificación personalizada (Comparator). No es posible almacenar valores nulos. El valor predeterminado es el montón superior pequeño. La capa inferior es una matriz, y el tamaño predeterminado es 11; expansión: si el tamaño de la matriz es menor que 64, se expandirá dos veces cuando esté llena, de lo contrario se expandirá en un 50%.

@Test
    public void test1() {
    
    
        //小顶堆
        PriorityQueue<Integer> heap = new PriorityQueue<>();
        heap.addAll(Arrays.asList(6, 3, 8, 9, 1));
        System.out.println(heap);//[1, 3, 8, 9, 6]

        //入堆
        heap.offer(2);
        System.out.println(heap);//[1, 3, 2, 9, 6, 8]

        //出堆
        Integer poll = heap.poll();
        System.out.println(poll);//1

        //查看堆顶元素但不出堆
        Integer peek = heap.peek();
        System.out.println(peek);//2

        //大顶堆
        PriorityQueue<Integer> heap2 = new PriorityQueue<>((o1, o2) -> -Integer.compare(o1, o2));
        heap2.addAll(Arrays.asList(6, 3, 8, 9, 1));
        System.out.println(heap2);//[9, 8, 6, 3, 1]
    }