Question

我实现了一个具有两个堆栈的队列，如下所示：

class QueueTwoStacks {
  constructor() {
    this.stack1 = []
    this.stack2 = []
  }
  enqueue(item) {
    this.stack1.push(item)
    const lastItem = this.stack1.pop()
    this.stack2.push(lastItem)
    const lastItem2 = this.stack2.pop()
    this.stack1.push(lastItem2)
  }

  dequeue() {
    if(this.stack1.length === 0) throw Error
    return this.stack1.shift();
  }
}

我正在学习的课程对此给出了答案：

class QueueTwoStacks {
  constructor() {
    this.inStack = [];
    this.outStack = [];
  }

  enqueue(item) {
    this.inStack.push(item);
  }

  dequeue() {
    if (this.outStack.length === 0) {

      // Move items from inStack to outStack, reversing order
      while (this.inStack.length > 0) {
        const newestInStackItem = this.inStack.pop();
        this.outStack.push(newestInStackItem);
      }

      // If outStack is still empty, raise an error
      if (this.outStack.length === 0) {
        throw new Error("Can't dequeue from empty queue!");
      }
    }
    return this.outStack.pop();
  }
}

一个比另一个更好，如果是，为什么？我觉得我的解决方案更好，因为您不必循环，但是也许您不应该在enqueue方法中执行所有操作？

Answer 1

问题是您的实现每次dequeue的时间复杂度为O（n），因为您要调用shift。另一方面，pop是O（1）运算。有关更多详细信息，您可以签出this question。

请注意，在您的实现中，您几乎可以完全摆脱stack2，它仍然可以正常工作（当然，缺点是您拥有O（n）dequeue ）：

class QueueTwoStacks {
  constructor() {
    this.stack1 = []
    // this.stack2 = []
  }
  enqueue(item) {
    this.stack1.push(item)
    // const lastItem = this.stack1.pop()
    // this.stack2.push(lastItem)
    // const lastItem2 = this.stack2.pop()
    // this.stack1.push(lastItem2)
  }

  dequeue() {
    if(this.stack1.length === 0) throw Error
    return this.stack1.shift();
  }
}

第二种实现只是偶尔将元素移动到outStack（即，仅当它为空时）并将pop用于其dequeue操作。因此，尽管最坏的情况仍然是O（n），但在一般情况下，此实现中的dequeue应该是O（1），这比O（n）好得多，尤其是当您要多次打电话。

有两个堆栈的队列

1 个答案: