在 JavaScript 中仅使用两个堆栈实现入队和出队？

在本文中，我们将在 JavaScript 中仅使用两个堆栈（以普通数组的形式）来实现队列的操作（入队和出队）。在直接理解问题陈述之前，让我们简要了解堆栈到底是什么以及队列到底是什么。

堆栈是一种线性数据结构，它采用后进先出 (LIFO) 的概念，其中最后出现的元素将首先被移除或移除。同样，队列也是一种线性数据结构，它采用先进先出 (FIFO) 的概念，其中首先出现的元素将首先被删除或退出。为了更好地理解堆栈的概念，一些现实生活中的示例包括：将盘子相互排列，直到最后一个盘子放在上面等。类似地，站在一个收集电影票的行中，一个人将首先收集电影票，直到那个人离开了那排，下一个人就不能去取电影票了，就是一个排队的例子。

现在您已经简要了解了堆栈和队列，让我们清楚地理解问题陈述，并进一步了解问题陈述本身的解决方案。以下图形表示将清楚地描述问题陈述，即仅使用两个堆栈来实现队列操作（入队和出队）-

上面的图形表示表示使用插入堆栈（以普通数组的形式声明）的几个元素（如 a、b、c 等）执行的入队操作。

上面的图示表示了使用多个元素以及两个堆栈执行的出队操作，我们将首先从第一个堆栈中弹出（删除）最后一个元素，然后将删除的元素添加到另一个堆栈中并进一步删除或从另一个堆栈中弹出元素。基本上删除和添加到另一个堆栈是这样工作的，这与堆栈的工作原理相反，或者我们可以说这里进行了反转，以使我们的逻辑类似于队列功能，而不是作为堆栈本身工作。

现在您已经非常清楚地理解了问题陈述，让我们继续看看解决上述问题陈述的方法。

方法一：

• 在这种方法中，我们将首先初始化两个堆栈（以两个普通数组的形式）。
• 此后，我们将使用用户自己给定的几个元素对第一个堆栈执行入队操作。
• 在执行入队操作之后，我们将为上述插入的元素定义出队操作到第一个堆栈中。
• 对于出队操作，我们首先必须从第一个堆栈中弹出或删除最后一个元素。
• 然后在从第一个堆栈中删除或弹出最后一个元素后，我们将把弹出的元素添加到另一个堆栈中（也是数组的形式）。
• 然后在将元素添加到新数组之后，我们将从下一个堆栈中弹出或删除该元素，这样我们就可以执行出队操作。

例子：

Javascript

  
    // 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();

输出：

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

方法二：

• 这种方法动态地适用于多个入队和出队操作。
• 在这里，我们将处理多种情况，例如是否在入队之前调用了出队，或者调用了多个出队，或者在出队之后才调用入队，或者在出队之后仅调用了单个操作。
• 与这里的第一种方法类似，我们也将为入队和出队操作创建两个单独的函数或方法。
• 在这两个单独的方法中，我们将分别执行入队和出队的各个逻辑。

例子：

Javascript

    // 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");

输出：

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