数据结构—栈

栈的实现原理为线性表，特点是只允许在固定的一段进行数据的增加和删除操作，允许增加和删除的一段成为栈顶（top）,另一端称为栈底（bottom）。

栈遵循先入后出的操作原则，即LIFO(last In First Out)。

栈的增加操作叫做压栈，在栈顶加入数据。 也叫进栈/入栈。

栈的删除操作叫做出栈，**在栈顶删除数据。**也叫弹栈。

有一组数据为：A、B、C,将这组数据按照顺序放入栈中，那么A作为最先进栈的数据是否只能最后出栈呢？

其实不然，如下所示：

情况1： A、B、C全部进栈，那么出栈的的顺序为C、B、A.

情况2：A进，A出。B进，B出，C进，C出。出栈顺序为A、B、C。

情况3：A进，B进，B出，C进，C出，A出。出栈顺序为B、C、A。

情况4：A进，A出，B进，C进，C出，B出。出栈顺序为A、C、B。

情况5：A进，B进，B出，A出，C进，C出。出栈顺序为B、A、C。

也就是说：栈只对数据的增加和删除的位置进行了限制，并没有对数据进出的顺序进行限制。

同时，由于Stack类extends了Vector类，而Vector类又implements了List接口，所以，栈也可以使用List的相关方法。

1.栈可以利用顺序表实现，使用尾插+尾删的方法实现。
2.栈可以利用链表实现，建议使用头插法实现。

import java.util.Arrays;

public class MyStack {
     private Object[] elem;//栈空间
     private int useSize;//可用元素

     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

     //不带参数的构造方法
     public MyStack(){
          this.elem=DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
     }
     public MyStack(int capactity) {
          if(capactity<0){
               throw new IllegalArgumentException("初始化容量不能为负数");
          }else if(capactity==0){
               this.elem=new Object[0];
          }else {
               this.elem=new Object[capactity];
          }
     }
     //判断栈容量是否满
     private boolean isFull(){
          return this.useSize==this.elem.length;
     }
     //判断栈是否为空
     public boolean isEmpty(){
          return this.useSize==0;
     }
     //扩容
     private void copyOf(){
          //如果栈空间为0，则空间大小初始化为5
          if(this.useSize==0){
               this.elem=Arrays.copyOf(this.elem,5);
               return;
          }
          //栈空间扩为原来的2倍
          this.elem= Arrays.copyOf(this.elem,2*this.useSize);
     }
     //进栈
     public void push(E element){
          //判断栈是否已满或是否为空，如果栈已满，扩容
          if(isFull()||isEmpty()){
               copyOf();
          }
          //进栈
          this.elem[useSize]=element;
          this.useSize++;
     }
     //删除栈顶元素
     public E pop(){
          //判断栈是否为空，如果为空抛出异常
          if(isEmpty()){
               throw new RuntimeException("栈为空!");
          }
          //出栈
          Object oldVal=this.elem[useSize-1];
          this.elem[useSize-1]=null;
          this.useSize--;
          //返回弹出栈的元素
          return (E) oldVal;
     }
     //得到栈顶元素
     public E peek(){
          //判断栈是否为空，如果为空抛出异常
          if(isEmpty()){
               throw new RuntimeException("栈为空!");
          }
          //返回栈顶元素
          return (E) this.elem[useSize-1];
     }
     //搜索元素得到位置,从栈顶开始向下数
     public int search(E element){
          int index=0;
          for (int i = this.useSize-1; i >=0 ; i--) {
               index++;
               if(element.equals(this.elem[i])){
                    return index;
               }
          }
          return -1;
     }
}