Question

我似乎一直在努力用我的代码中的这些方法来确定Big O的表现：isEmpty（），peek（），pop（），push（）忽略resize和size（）

我的ArrayStack程序中的所有这些方法都具有Big O（1）的性能。如果是这样，为什么？如果没有，为什么？

public class ArrayStack<E> implements Stack<E> {
   private E[] data;
   private int top = -1;
   private static final int DEFAULT_CAPACITY = 10;

   @SuppressWarnings("unchecked")
   public ArrayStack() {
      data = (E[]) new Object[DEFAULT_CAPACITY];
   }

   public E pop() {
      if (isEmpty()) {
         throw new EmptyStackException();
      }
      // allow garbage collection
      E save = data[top];
      data[top] = null;
      top--;
      return save;
   }

   public E peek() {
      if (isEmpty()) {
         throw new EmptyStackException();
      }
      return data[top];
   }

   public void push(E item) {
      if (data.length == size()) resize(2 * data.length);
      data[++top] = item;
   }

   public boolean isEmpty() {
      return top == -1;
   }

   public int size() {
      return top + 1;
   }

   @SuppressWarnings("unchecked")
   private void resize(int newCapacity) {
      E[] newdata = (E[]) new Object[newCapacity];
      for (int i = 0; i <= top; i++) {
         newdata[i] = data[i];
      }
      data = newdata;
   }

   public static void main(String[] args) {
      Stack<Integer> s = new ArrayStack<>();
      System.out.println("Size: " + s.size());
      for (int i = 0; i < 500; i++) {
         s.push(i*i);
      }
      System.out.println("Size: " + s.size());
      while (!s.isEmpty()) {
         System.out.print(s.pop() + " ");
      }
      System.out.println();
      System.out.println("Size: " + s.size());

      Stack<String> strings = new ArrayStack<>();
      String[] data = {"dog", "cat", "no", "geek", "computer"};
      for (String word: data) {
         strings.push(word);
      }
      while (!strings.isEmpty()) {
         System.out.print(strings.pop() + " ");
      }
      System.out.println();
   }

}

Answer 1

方法中完成的工作量不会随着堆栈中元素的数量而变化，也不会随着它们被调用的次数而变化。

您可以看到方法中完成的工作是不变的。这正是由 O（1）表示的。

另一方面，如果您考虑'resize（）'，当它达到特定大小时，您将已经存在的每个元素复制到新位置。因此，完成的工作与已经存在的元素数量成正比。如果存在1000个元素，那么将会有更多的工作，如果只存在10个元素。因此，该调用的运行时复杂度为 O（N），其中 N 是堆栈中已存在的元素数。

但是如果我们考虑调整大小的摊销成本，那么 N（1）仍然 N-1 超出 N 它正在不断努力。

如何通过具体示例确定Big O Performance？

1 个答案: