Java 如何通过具体示例确定大O性能？

我似乎一直在努力用代码中的以下方法确定Big O性能：isEmpty（）、peek（）、pop（）、push（）和size（）

我的ArrayStack程序中的所有这些方法的性能都是大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();
   }

}

公共类ArrayStack实现堆栈{
私人电子数据；
私有int top=-1；
专用静态最终int默认_容量=10；
@抑制警告（“未选中”）
公共阵列堆栈（）{
数据=（E[]）新对象[默认容量]；
}
公共E-pop（）{
if（isEmpty（））{
抛出新的EmptyStackException（）；
}
//允许垃圾收集
E保存=数据[顶部]；
数据[top]=null；
顶部--；
返回保存；
}
公共E peek（）{
if（isEmpty（））{
抛出新的EmptyStackException（）；
}
返回数据[顶部]；
}
公共无效推送（E项）{
如果（data.length==size（））调整大小（2*data.length）；
数据[++顶部]=项目；
}
公共布尔值为空（）{
返回顶部==-1；
}
公共整数大小（）{
返回顶部+1；
}
@抑制警告（“未选中”）
专用空间大小调整（int newCapacity）{
E[]newdata=（E[]）新对象[newCapacity]；
对于（int i=0；i方法中完成的工作量不随堆栈中元素的数量而变化，也不随调用次数而变化

您可以看到，在方法中所做的功是恒定的，这正是O（1）所表示的

另一方面，如果你考虑你的“Resiz（）），当它达到某个特定大小时，您正在将已存在的每个元素复制到一个新位置。因此，所完成的工作与已存在的元素数成比例。如果存在1000个元素，则将比仅存在10个元素时需要更多的工作。因此，该调用的运行时复杂性为O（N）其中N是堆栈中已存在的元素数

但是，如果我们考虑调整大小的摊销成本，它仍然是O（1），因为在n的n次中，它在做恒定的工作。< / P>是的，它们都是O（1）。为什么？因为O（1）描述它们的渐进时间复杂性。问自己以下问题：如果堆栈包含100000000个元素，操作会花费更长的时间吗？如果答案为否，则性能为O（1）。如果需要扩展备份数组，则只有
push（）
可能会花费更长的时间，但总体上不会，与
add（）完全相同
of方法，其中性能称为摊销恒定时间，仍然是O（1）。@Andreas谢谢，这使它更容易理解！