3.1_栈_顺序存储结构（数组形式）
【栈的定义】
栈（stack）是限定仅在表尾进行插入和删除操作的线性表。
栈又称为后进先出（Last In First Out）线性表，简称LIFO结构。
（PS：定义中的表尾是指 栈顶！）
【几个关键词 】
[ 栈顶(top) ]
允许插入和删除的一端称为 栈顶。
[ 栈底(bottom) ]
栈顶的另一端称为 栈底。
[ 空栈 ]
不含任何数据元素的栈。
【栈的插入操作——进栈（push）】
栈的插入操作，叫做进栈，也称为压栈、入栈。
【栈的删除操作——出栈（pop）】
栈的删除操作，叫做出栈，也称为弹栈。
【进栈出栈的变化形式】
如果3个整数1,2,3依次入栈，会有哪些出栈次序？
第一种：1-2-3进栈，即3-2-1出栈。
第二种：1进，1出，2斤，2出，3进，3出，进一个出一个，即1-2-3出栈。
第三种：1进，2进，2出，1出，3进，3出，即2-1-3出栈。
第四种：1进，1出，2进，3进，3出，2出，即1-3-2出栈。
第四种：1进，2进，2出，3进，3出，2出，即2-3-1出栈
【栈的抽象数据类型】
ADT 栈（stack）
Data
同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。
Operation
InitStack(*S) 初始化操作，建立一个空栈S
DestoryStack(*S) 若栈存在，则销毁它
ClearStack(*S) 将栈清空
StackEmpty(S) 若栈为空，返回true，否则返回false。
GetTop(S,*e) 若栈S存在且非空，用e返回S的栈顶元素。
Push(*S,e) 若栈S存在，插入新元素e到栈S中并成为栈顶元素。
Pop(*S,*e) 删除栈S中栈顶元素，并用e返回其值。
StackLength(S) 返回栈S的元素个数。
endADT
【自定义的栈MyStack.java】
package com.Higgin.Stack; import java.util.ArrayList; import java.util.Arrays; import java.util.EmptyStackException; public class MyStack { protected Object[] elementData; //栈中具体的对象数组 protected int elementCount; //栈顶指针 protected int capacityIncrement;//当栈满了，每次增长栈的容量 public MyStack(int initialCapacity,int capacityIncrement){ if(initialCapacity<0){ //如果初始化栈的容量小于0，抛出异常 throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity); } this.elementData=new Object[initialCapacity]; this.capacityIncrement=capacityIncrement; } public MyStack(int initialCapacity){ this(initialCapacity,0); //默认增长的容量为0 } public MyStack(){ this(10); //默认初始栈的容量为10 } /** * 返回栈中的已存的元素个数 */ public int size(){ return elementCount; } /** * 判断是否为空栈 */ public boolean empty(){ return size()==0; } /** * 进栈 */ public Object push(Object obj){ if((elementCount+1)>elementData.length){ //如果再添加一个对象，导致溢出，则扩容（若不想扩容直接抛出异常即可） grow(elementCount+1); //扩容 } elementData[elementCount++]=obj; return obj; } /** * 查看栈顶部的元素，但不从栈中移除它 */ public Object peek(){ int len=size(); if(len==0){ throw new EmptyStackException(); } return elementData[len-1]; } /** * 出栈 */ public Object pop(){ Object obj=peek(); //获取栈顶的对象，里面包含了判断栈是否为空的判断 elementCount--; elementData[elementCount]=null; return obj; } /** * 查找对象的位置 */ public int search(Object obj){ if(size()==0){ //如果是空栈，直接不找 throw new EmptyStackException(); } int i=lastIndexOf(obj); if(i>=0){ return size()-i; } return -1; } /** * 扩容 * （如果再存入数据时，容量不够，就进行扩容） */ public void grow(int minCapacity){ //扩容方法 int oldCapacity=elementData.length; //原来的容量 int newCapacity=oldCapacity+((capacityIncrement>0)?capacityIncrement:oldCapacity); //增长后的新容量：设置过就为 老容量+设置值 ，否则就直接翻倍 if(newCapacity<minCapacity){ //如果新增后的容量依然过小，直接把当前值指针的值传过来（这个应该是容量过大的时候） newCapacity=minCapacity; } if(newCapacity-Integer.MAX_VALUE>8){ if(minCapacity<0){ //说明都溢出了 throw new OutOfMemoryError(); //直接抛出错误 } newCapacity=(minCapacity>(Integer.MAX_VALUE-8)?Integer.MAX_VALUE:(Integer.MAX_VALUE-8)); } elementData=Arrays.copyOf(elementData, newCapacity); //扩容后的elementData } /** * 找出obj对象在 elementData[i]中最后的位置，对于栈而言，其实是离栈顶最近的位置 */ public int lastIndexOf(Object obj){ if(obj==null){ for(int i=elementCount-1;i>=0;i--){ if(elementData[i]==null){ return i; } } }else{ for(int i=elementCount-1;i>=0;i--){ if(obj.equals(elementData[i])){ return i; } } } return -1; } }
【测试】
package com.Higgin.Stack; import org.junit.Test; public class TestMyStack { @Test public void test1(){ MyStack ms=new MyStack(); System.out.println("是否为空==="+ms.empty()); //true ms.push(11); ms.push(22); ms.push(33); System.out.println("最近一次添加的是33==="+ms.peek()); //33 ms.push(44); ms.push(55); System.out.println("最近一次添加的是55==="+ms.peek()); //55 System.out.println("寻找22的位置==="+ms.search(22)); //4 System.out.println("寻找55的位置==="+ms.search(55)); //1 System.out.println("寻找99的位置(不存在)==="+ms.search(99)); //-1 ms.pop(); System.out.println("执行了一次pop，栈顶的元素==="+ms.peek()); //44 System.out.println("栈移除了之后的长度为===="+ms.size()); //4 } }
【运行结果】
