¿Implementar enqueue y dequeue usando solo dos pilas en JavaScript?

En este artículo, implementaremos las operaciones de la cola (poner y quitar la cola) utilizando solo dos pilas (en forma de arrays simples) en JavaScript. Antes de pasar directamente a comprender la declaración del problema, comprendamos brevemente qué es exactamente una pila y también qué es exactamente una cola.

Una pila es una estructura de datos lineal que funciona con el concepto de último en entrar, primero en salir (LIFO) en el que el elemento que llega, al final, será eliminado o eliminado al principio. De manera similar, una cola también es una estructura de datos lineal que funciona con el concepto de Primero en entrar, primero en salir (FIFO) en el que el elemento que llega primero se eliminará o saldrá primero. Algunos ejemplos de la vida real para comprender mejor el concepto de la pila incluyen: colocar los platos uno encima del otro hasta que el último plato quede encima, etc. esa persona sale de la fila, la siguiente persona no podrá recoger las entradas de cine, es un ejemplo de una cola.

Ahora que ha entendido brevemente acerca de las pilas y las colas, comprendamos claramente la declaración del problema y, además, veremos la solución para la declaración del problema en sí. Las siguientes representaciones pictóricas describirán claramente la declaración del problema, que es implementar operaciones de cola (poner y quitar cola) usando solo dos pilas:

La representación pictórica anterior representa la operación de puesta en cola que se estaba realizando con varios elementos (como a, b, c, etc.) que se insertan en la pila (declarada en forma de array simple).

La representación pictórica anterior representa la operación de eliminación de la cola que se estaba realizando utilizando varios elementos, así como dos pilas mediante las cuales primero sacaremos (eliminaremos) el último elemento de la primera pila y luego agregaremos ese elemento eliminado en otra pila y lo eliminaremos más. o sacar el elemento de la otra pila. Básicamente, la eliminación y la adición a otra pila se realizan para que esto funcione a la inversa de lo que funciona exactamente la pila, o podríamos decir que la inversión se realiza aquí para que nuestra lógica sea similar a la funcionalidad de la cola en lugar de funcionar como una pila en sí misma.

Ahora que ha entendido muy claramente el enunciado del problema, avancemos para ver los enfoques para resolver el enunciado del problema ilustrado anteriormente.

Enfoque 1:

• En este enfoque, primero inicializaremos dos pilas (en forma de dos arrays simples).
• A partir de entonces, realizaremos la operación de puesta en cola en la primera pila con varios elementos proporcionados por el propio usuario.
• Además, después de realizar la operación de puesta en cola, definiremos la operación de puesta en cola para los elementos insertados anteriores en la primera pila.
• Para la operación de eliminación de cola, primero tendremos que extraer o eliminar el último elemento de la primera pila.
• Luego, después de eliminar o extraer el último elemento de la primera pila, agregaremos ese elemento extraído a otra pila (que también tiene forma de array).
• Luego, después de agregar el elemento a la nueva array, extraeremos o eliminaremos ese elemento de la siguiente pila y de esta manera podríamos realizar la operación de eliminación de cola.

Ejemplo:

<script>
  
    // Two stacks declared in the form of plain array
    let stack1 = [];
    let stack2 = [];
  
    // Method that will perform our enqueue operation
    function enqueue(element) {
        stack1.push(element);
        console.log("Stack-1 elements are enqueue: ", stack1);
    }
  
    // Method that will perform our dequeue operation
    function dequeue() {
        if (stack2.length === 0) {
            if (stack1.length === 0) {
                console.log(
            "Dequeue not possible because queue is empty..");
            }
            while (stack1.length > 0) {
                let x = stack1.pop();
                stack2.push(x);
            }
        }
        console.log("Element after Dequeue: " + stack2.pop());
    }
  
    enqueue("a");
    enqueue("b");
    enqueue("c");
    dequeue();
    dequeue();
</script>

Producción:

Stack-1 elements are enqueue:  [ 'a' ]
Stack-1 elements are enqueue:  [ 'a', 'b' ]
Stack-1 elements are enqueue:  [ 'a', 'b', 'c' ]
Element after Dequeue: a
Element after Dequeue: b

Enfoque 2:

• Este enfoque funciona dinámicamente para múltiples operaciones de poner y quitar de la cola.
• Aquí manejaremos múltiples casos como si se llamara a dequeue antes de poner en cola, o si se llamaran múltiples de queue, o si solo se llamara a enqueue después de dequeue o solo se llamara a una sola operación después de dequeue.
• De manera similar al primer enfoque aquí, también vamos a crear dos funciones o métodos separados para las operaciones de poner y sacar de la cola.
• En estos dos métodos separados, realizaremos las lógicas individuales de enqueue y dequeue respectivamente.

Ejemplo:

<script>
    // Two stacks declared in array form
    let stack1 = [];
    let stack2 = [];
  
    // Method to implement enqueue operation
    function enqueue(element) {
  
        // if dequeue was called before actual
        // enqueue operation
        if (stack2.length > 0) {
            let len = stack2.length;
            for (let i = 0; i < len; i++) {
                let p = stack2.pop();
                stack1.push(p);
            }
        }
        stack1.push(element);
        console.log("Elements after Enqueue: ", stack1);
    }
  
    // Method to implement dequeue operation......
    function dequeue() {
  
        // If dequeue was called consecutively, all
        // the elements would be in stack2
        if (stack2.length > 0) {
            console.log("Element after dequeue : "
                + stack2.pop());
        }
  
        // If enqueue was called right before
        // this dequeue, stack2 is empty
        else if (stack2.length === 0) {
            if (stack1.length === 0) {
  
                // If the first operation is
                // dequeue itself
                console.log("Queue is empty");
            } else if (stack1.length === 1) {
  
                // If a single operation as
                // enqueue was performed
                console.log(stack1.pop());
            }
  
            // If enqueue was called before this
            // operation, all the elements are in
            // stack1, so pop them and push the 
            // elements into stack2,  then pop()
            else if (stack1.length > 0) {
                let len = stack1.length;
                for (let i = 0; i < len; i++) {
                    let p = stack1.pop();
                    stack2.push(p);
                }
                console.log("Element after dequeue: "
                    + stack2.pop());
            }
        }
    }
    enqueue("a");
    enqueue("b");
    enqueue("c");
    dequeue();
    enqueue("d");
    enqueue("e");
    dequeue();
    dequeue();
    dequeue();
    enqueue("f");
</script>

Producción:

Elements after Enqueue:  [ 'a' ]
Elements after Enqueue:  [ 'a', 'b' ]
Elements after Enqueue:  [ 'a', 'b', 'c' ]
Element after dequeue: a
Elements after Enqueue:  [ 'b', 'c', 'd' ]
Elements after Enqueue:  [ 'b', 'c', 'd', 'e' ]
Element after dequeue: b
Element after dequeue : c
Element after dequeue : d