使用堆栈

Question

这是家庭作业的问题：

  

使用两个堆栈实现FIFO队列。

     

在最坏的情况下，Enqueue和Dequeue函数的总运行时间应为O（n）。另外，分析算法的运行时间。

我做了什么：

void Enqueue(T *value)
{
s1.Push(value);
}

T *Dequeue()
{
    if (s2.size > 0)
        return s2.Pop();
    else if (s1.size > 0)
    {
        for (int i = 0; i < s1.size; i++)
            s2.Push(s1.Pop());

        return s2.Pop();
    }
    else return NULL;
}

算法分析：

一个Enqueue的运行时间是Theta（1）。所有Enqueue函数的总运行时间为n * Theta（1）= Theta（n）。

在最坏的情况下，Dequeue的运行时间是Theta（n）（当你在最后一个Enqueue之后调用它时，即插入所有项目时）。在所有其他情况下，运行时间是Theta（1）。

所以，总运行时间是： O（n）+ O（n）+ n * O（1）= 3 * O（n）= O（n）

这是对的吗？

Answer 1

  

因此，总运行时间为：O（n）+ O（n）+ n * O（1）= 3 * O（n）=   为O（n）

您正朝着正确的方向前进，但是您通常不会分析＆＃34;总运行时间＆＃34;，您将其分为平均摊销，最差情况和最佳案例 - 并对其进行分析对于每个操作。

在您的算法中，很容易看到：

对于所有情况，
• enqueue()在Theta（1）中运行。
• dequeue()在Theta(n)最差情况和Theta(1)最佳情况下运行。

Noe，对于棘手的部分 - 我们需要分析dequeue()摊销分析。

首先请注意，在每个Theta(n)（最差情况）dequeue()之前，您必须清空列表，并插入n个元素。
这意味着，为了使最坏的情况发生，您必须至少完成n enqueue()次操作，每次Theta(1)。

这给我们摊销时间：

T(n) = (n*CONST1      +    CONST2*n)             /(n+1)
          ^                 ^                      ^
     n enqueues      1 "espansive" dequeue        #operations

很容易看出T(n)位于Theta(1)，为您提供Theta(1)摊销的时间复杂度。

TL; DR：

入队：Theta（1）所有案件
出列：Theta（1）摊销，Theta（n）最坏情况

Answer 2

import java.util.Stack;

公共课Q5_ImplementQueueUsingStack {

/**
 * @param args
 * Implement a MyQueue class which implements a queue using two stacks.
 */
public static Stack<Integer> s1 = new Stack<Integer>();
public static Stack<Integer> s2 = new Stack<Integer>();
public static void main(String[] args) {
    int[] array = {2,5,10,3,11,7,13,8,9,4,1,6};
    for(int i=0;i<5;i++){
        enQueue(array[i]);
    }
    System.out.println(deQueue());
    System.out.println(deQueue());
    System.out.println(deQueue());
    System.out.println(deQueue());
    System.out.println(deQueue());
    for(int i=0;i<4;i++){
        enQueue(array[i+5]);
    }
    System.out.println(deQueue());
    for(int i=0;i<3;i++){
        enQueue(array[i+9]);
    }
    System.out.println(deQueue());
    System.out.println(deQueue());
    System.out.println(deQueue());
    System.out.println(deQueue());
    System.out.println(deQueue());
    System.out.println(deQueue());
}
public static void enQueue(int data){
    s1.push(data);
}
public static int deQueue(){
    if(s2.isEmpty())
        while(!s1.isEmpty()) 
            s2.push(s1.pop());
    return s2.pop();
}

}

Answer 3

使用堆栈执行队列的以下操作。

push（x）-将元素x推到队列的后面。

pop（）-从队列前面删除该元素。

peek（）-获取前端元素。

empty（）-返回队列是否为空。

 class MyQueue {

  Stack<Integer> input;
  Stack<Integer> output;

  /** Initialize your data structure here. */
  public MyQueue() {
    input = new Stack<Integer>();
    output = new Stack<Integer>();
  }

  /** Push element x to the back of queue. */
  public void push(int x) {
    input.push(x);
  }

  /** Removes the element from in front of queue and returns that element. */
  public int pop() {
    peek();
    return output.pop();
  }

  /** Get the front element. */
  public int peek() {
    if(output.isEmpty()) {
        while(!input.isEmpty()) {
            output.push(input.pop());
        }
    }
    return output.peek();
  }

  /** Returns whether the queue is empty. */
  public boolean empty() {
    return input.isEmpty() && output.isEmpty();
  }
}