Dos colas para lograr una pila + dos pilas para lograr una cola (implementación de Java)

Dos colas implementan una pila

1. Hay dos colas q1 y q2, y los elementos se agregan a q1 cuando se colocan en la pila.
2. Al abrir la pila, primero juzgue si q1 está vacío, porque los elementos en q1 siempre son los últimos en entrar, los últimos en entrar son los primeros en salir, excepto el último elemento de la cola, agregue otros elementos a q2, y el último elemento de q1 se quita de la cola
3. Al salir de la pila, si se juzga que q1 está vacío en 2, excepto por el último elemento de q2, agregue otros elementos en q2 a q1, y luego el último elemento en q2 se quita de la cola

Código Java completo:

public class MyStack {
    
    

    private Queue<Integer> q1 = new LinkedList<>();
    private Queue<Integer> q2 = new LinkedList<>();

    public MyStack() {
    
    
    }

    public boolean push(Integer num) {
    
    
        return q1.offer(num);
    }

    public Integer pop() {
    
    
        if (q1.isEmpty() && q2.isEmpty()) {
    
    
            return null;
        }
        // 先判断 q1 是否为空 
        if (!q1.isEmpty()) {
    
    
            int size = q1.size();
            for (int i = 0; i < size - 1; i++) {
    
    
                q2.offer(q1.poll());
            }
            return q1.poll();
        } else {
    
    
            int size = q2.size();
            for (int i = 0; i < size - 1; i++) {
    
    
                q1.offer(q2.poll());
            }
            return q2.poll();
        }
    }

    public Integer size() {
    
    
        return q1.size() + q2.size();
    }


    public static void main(String[] args) {
    
    
        MyStack stack = new MyStack();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);

        int size = stack.size();
        for (int i = 0; i < size; i++) {
    
    
            System.out.print(stack.pop() + " ");
        }
        System.out.println();
        stack.push(6);
        System.out.println(stack.pop());
    }
}

Cola de implementación de dos pilas

Similar a la implementación de la cola, pero mucho más simple que las dos pilas de implementación de la cola.

1. Hay dos pilas stack1 y stack2
2. Simplemente agregue elementos a stack1 al ingresar a la cola
3. Al salir de la cola, primero juzgue si stack2 está vacío Los elementos en stack2 son los primeros en entrar, primero en entrar, primero en salir. Si stack2 no está vacío, saca el elemento superior de stack2 directamente. Si está vacío, agregue el elemento de stack1 a stack2, y luego saque el elemento superior de stack2

Mira el código de Java:

public class MyQueue {
    
    
    private Stack<Integer> stack1 = new Stack<>();
    private Stack<Integer> stack2 = new Stack<>();

    /**
     * 添加元素到队列
     *
     * @param num
     * @return
     */
    public Integer add(Integer num) {
    
    
        return stack1.push(num);
    }

    /**
     * 队列弹出元素
     *
     * @return
     */
    public Integer poll() {
    
    
        if (stack1.isEmpty() && stack2.isEmpty()) {
    
    
            return null;
        }
        // 先判断 stack2
        if (!stack2.isEmpty()) {
    
    
            return stack2.pop();
        }
        // 将 stack1 的元素放入 stack2
        int size = stack1.size();
        for (int i = 0; i < size; i++) {
    
    
            stack2.push(stack1.pop());
        }
        return stack2.pop();
    }

    public int size() {
    
    
        return stack1.size() + stack2.size();
    }


    public static void main(String[] args) {
    
    
        MyQueue queue = new MyQueue();
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);
        queue.poll();
        queue.add(5);
        int size = queue.size();

        for (int i = 0; i < size; i++) {
    
    
            System.out.print(queue.poll() + " ");
        }
        System.out.println();
    }
}