Pila y cola de Java

1. Pila (Pila)

1.1 Concepto

Pila: una lista lineal especial que permite la inserción y eliminación de elementos solo en un extremo fijo. Un extremo donde se realizan la inserción y eliminación de datos se denomina parte superior de la pila y el otro extremo se denomina parte inferior de la pila. Los elementos de datos en la pila siguen el principio LIFO ( último en entrar, primero en salir ).

Empujar pila: La operación de inserción de la pila se llama empujar / empujar / empujar , y los datos empujados están en la parte superior de la pila .

Pop: La eliminación de la pila se llama pop. Los datos de salida están en la parte superior de la pila.

 1.2 Implementación

1. Use la tabla de secuencias para lograr, es decir, use el método de inserción de cola + eliminación de cola

2.  Use la lista enlazada para lograr, entonces tanto la cabeza como la cola pueden ser

En términos relativos, la implementación de la tabla de secuencias es más sencilla, por lo que preferimos usar la tabla de secuencias para implementar la pila.

Pila secuencial basada en matriz, el código de implementación es el siguiente:

import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;

/**
 * 基于数组的顺序栈实现
 * @param <E>
 */
public class MyStack<E> {
    // 当前栈的数据个数
    private int size;
    // 实际存储数据的动态数组 - ArrayList
    private List<E> data=new ArrayList<>();

    //入栈
    public void push(E val){
        //尾插
        data.add(val);
        size++;
    }

    //出栈，并返回栈顶元素
    public E pop(){
        if(isEmpty()){
            // 栈为空，没有栈顶元素
            throw new NoSuchElementException("stack is empty! cannot pop!");
        }
        // 删除栈顶元素
        E val = data.remove(size - 1);
        size --;
        return val;
        // 等同于 return data.remove(--size);
    }

    //只返回栈顶元素
    public E peek(){
        if(isEmpty()){
            // 栈为空，没有栈顶元素
            throw new NoSuchElementException("stack is empty! cannot peek!");
        }
        return data.get(size-1);
    }

    //判断栈是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    @Override
    public String toString() {
        StringBuilder sb=new StringBuilder();
        sb.append("[");
        for (int i = 0; i < size; i++) {
            sb.append(data.get(i));
            if(i!=size-1){
                // 此时还没到栈顶，还没到数组末尾
                sb.append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

El método de referencia es el siguiente:

public class StackTest {
    public static void main(String[] args) {
        MyStack<Integer> stack=new MyStack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        //打印栈所有元素
        System.out.println(stack);
        //打印栈顶元素
        System.out.println(stack.peek());
        //出栈，并打印栈顶元素
        stack.pop();
        System.out.println(stack);
    }
}

En base a los resultados de entrada anteriores son los siguientes:

2. Cola _

2.1 Concepto 

Cola: una tabla lineal especial que solo permite operaciones de inserción de datos en un extremo y operaciones de eliminación de datos en el otro extremo.La cola tiene una cola de entrada de primero en entrar, primero en salir (FIFO) (primero en entrar, primero en salir): el final de la operación de inserción se llama la cola de la cola ( Tail/ Rear ) fuera de la cola: el final de la operación de eliminación se llama la cabeza de la cola

primero en llegar y primero en salir

2.2 Implementación

La cola también se puede implementar en la estructura de una matriz y una lista enlazada.Es mejor usar la estructura de una lista enlazada, porque si se usa la estructura de una matriz, la eficiencia de la eliminación de la cola y la salida de datos en la cabeza de la matriz será relativamente baja.

La cola básica implementada en función de la lista vinculada, el código de implementación es el siguiente:

Clase de interfaz:

public interface IQueue<E> {
    // 入队
    void offer(E val);
    //出队
    E poll();
    //返回队首元素
    E peek();
    //判断队列是否为空
    boolean isEmpty();
}

Clase de cola:

import stack_queue.queue.IQueue;

import java.util.NoSuchElementException;

/**
 * 基于链表实现的基础队列
 * @param <E>
 */
public class MyQueue<E> implements IQueue<E> {
    // 链表的每个节点
    private class Node{
        E val;
        Node next;

        public Node(E val){
            this.val=val;
        }
    }

    // 当前队列中的元素个数
    private int size;
    // 队首
    private Node head;
    //队尾
    private Node tail;

    @Override
    public void offer(E val) {
        Node node=new Node(val);
        if(head==null){
            // 此时链表为空
            head=tail=node;
        }else {
            tail.next=node;
            tail=node;
        }
        size++;
    }

    @Override
    public E poll() {
        if(isEmpty()){
            throw new NoSuchElementException("queue is empty! cannot poll");
        }
        Node node=head;
        head=node.next;
        // 将原来头节点脱钩
        node.next=null;
        size--;
        return node.val;
    }

    @Override
    public E peek() {
        if(isEmpty()){
            throw new NoSuchElementException("queue is empty! cannot peek");
        }
        return head.val;
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public String toString() {
        StringBuilder sb=new StringBuilder();
        sb.append("[");
        // 链表的遍历
        for(Node x=head;x!=null;x=x.next){
            sb.append(x.val);
            if(x.next!=null){
                // 还没走到链表尾部
                sb.append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

El método de referencia es el siguiente:

import stack_queue.queue.impl.MyQueue;

public class QueueTest {
    public static void main(String[] args) {
        IQueue iQueue=new MyQueue();
        iQueue.offer(1);
        iQueue.offer(2);
        iQueue.offer(3);

        System.out.println(iQueue);
        System.out.println(iQueue.peek());
        iQueue.poll();
        System.out.println(iQueue);
    }
}

En base a los resultados de entrada anteriores son los siguientes: