• 栈也是一种线性结构；
• 相比数组，栈所对应的操作是数组的子集；
• 栈只能从一端添加元素，也只能从这一端取出元素，这一端通常称之为"栈顶"；
• 向栈中添加元素的过程，称之为"入栈"，从栈中取出元素的过程称之为"出栈"；
• 栈的形象化描述如下图：
• 

• "入栈"的顺序若为1-2-3-4，那么出栈的顺序只能为4-3-2-1，即，栈是一种"后进先出"（Last In First Out）的数据结构；
• 从用户的角度，只能看到栈顶元素，其它元素对用户是不可见的；
• 在计算机世界里，"栈"有着不可思意的作用；

• 应用程序中的"撤销"(Undo)操作的底层原理就是通过"栈"来实现的；
• 程序调用的系统栈，通过下图简单示例：
• 
• 
• 

• 任务目标如下：

• Stack<E>
  ·void push(E)   //入栈
  ·E pop()    // 出栈
  ·E peek()   // 查看栈顶元素
  ·int getSize()  // 查看栈中共有多少元素
  ·boolean isEmpty()   // 查看栈是否为空

• 需要提一下，从用户的角度来看，只要实现上述操作就好，具体底层实现，用户并不关心，实际上，底层确实有多种实现方式。
• 我们准备在之前实现的动态数组基础上，来实现"栈"这种数据结构。
• 先定义一个接口Interface，如下：

• public interface Stack<E> {  // 支持泛型int getSize();boolean isEmpty();void push(E e);E pop();E peek();
  }

• 然后实现一个ArrayStack类，如下：

• public class ArrayStack<E> implements Stack<E> {Array<E> array;//构造函数public ArrayStack(int capacity) {array = new Array<>(capacity);}//无参数构造函数public ArrayStack() {array = new Array<>();}//实现getSize方法
      @Overridepublic int getSize() {return array.getSize();}//实现isEmpty方法
      @Overridepublic boolean isEmpty() {return array.isEmpty();}//实现getCapacity方法public int getCapacity() {return array.getCapacity();}//实现push方法
      @Overridepublic void push(E e) {array.addLast(e);}//实现pop方法
      @Overridepublic E pop() {return array.removeLast();}//实现peek方法public E peek() {return array.getLast();}//方便打印测试
      @Overridepublic String toString() {StringBuilder res = new StringBuilder();res.append("Stack: ");res.append('[');for (int i = 0; i < array.getSize(); i++) {res.append(array.get(i));if (i != array.getSize() - 1) {res.append(", ");}}res.append("] top");return res.toString();}
  }

• Array类的业务逻辑如下：

• public class Array<E> {private E[] data;  //设置为private，不希望用户从外部直接获取这些信息，防止用户篡改数据private int size;//构造函数，传入数组的容量capacity构造Arraypublic Array(int capacity) {data = (E[]) new Object[capacity];size = 0;}//无参数构造函数，默认数组容量capacity=10public Array() {this(10);    //这里的capacity是IDE自动添加的提示信息，实际不存在
      }//获取数组中的元素个数public int getSize() {return size;}//获取数组的容量public int getCapacity() {return data.length;}//判断数组是否为空public boolean isEmpty() {return size == 0;}//向数组末尾添加一个新元素epublic void addLast(E e) {add(size, e);}//向数组开头添加一个新元素epublic void addFirst(E e) {add(0, e);}//在index位置插入一个新元素epublic void add(int index, E e) {if (index < 0 || index > size) {throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");}if (size == data.length) {resize(2 * size); //扩大为原容量的2倍
          }for (int i = size - 1; i >= index; i--) {data[i + 1] = data[i];}data[index] = e;size++;}//获取index位置的元素public E get(int index) {if (index < 0 || index >= size) {throw new IllegalArgumentException("Get failed. Index is illegal.");}return data[index];}//获取最后一个元素public E getLast() {return get(size - 1);}//获取开头的元素public E getFirst() {return get(0);}//修改index位置的元素为epublic void set(int index, E e) {if (index < 0 || index >= size) {throw new IllegalArgumentException("Set failed. Index is illegal.");}data[index] = e;}//查找数组中是否存在元素epublic boolean contains(E e) {for (int i = 0; i < size; i++) {if (data[i].equals(e)) {return true;}}return false;}//查看数组中元素e的索引，若找不到元素e，返回-1public int find(E e) {for (int i = 0; i < size; i++) {if (data[i].equals(e)) {return i;}}return -1;}//删除掉index位置的元素，并且返回删除的元素public E remove(int index) {if (index < 0 || index >= size) {throw new IllegalArgumentException("Remove failed. Index is illegal.");}E ret = data[index];for (int i = index + 1; i < size; i++) {data[i - 1] = data[i];}size--;   //data[size]会指向一个类对象，这部分空间不会被释放loitering objectsdata[size] = null;if (size == data.length / 4 && data.length / 2 != 0) {resize(data.length / 2);  //被利用的空间等于总空间的一半时，将数组容量减少一半
          }return ret;}//删除掉数组开头的元素，并返回删除的元素public E removeFirst() {return remove(0);}//删除掉数组末尾的元素，并返回删除的元素public E removeLast() {return remove(size - 1);}//如果数组中有元素e，那么将其删除，否则什么也不做public void removeElement(E e) {int index = find(e);if (index != -1) {remove(index);}}@Overridepublic String toString() {    //覆盖父类的toString方法
  StringBuilder res = new StringBuilder();res.append(String.format("Array: size=%d, capacity=%d\n", size, data.length));res.append('[');for (int i = 0; i < size; i++) {res.append(data[i]);if (i != size - 1) {res.append(", ");}}res.append(']');return res.toString();}private void resize(int newCapacity) {E[] newData = (E[]) new Object[newCapacity];for (int i = 0; i < size; i++) {newData[i] = data[i];}data = newData;}
  }

4.. 对我们实现的栈进行测试：

• public class Main {public static void main(String[] args) {ArrayStack<Integer> stack = new ArrayStack<>();//测试入栈pushfor (int i = 0; i < 5; i++) {stack.push(i);System.out.println(stack);}//测试出栈
          stack.pop();System.out.println(stack);}
  }

• 输出结果如下：

• Stack: [0] top
  Stack: [0, 1] top
  Stack: [0, 1, 2] top
  Stack: [0, 1, 2, 3] top
  Stack: [0, 1, 2, 3, 4] top
  Stack: [0, 1, 2, 3] top

5.. 栈的时间复杂度分析

• Stack<E>
  ·void push(E)    O(1) 均摊
  ·E pop()    O(1)   均摊
  ·E peek()    O(1)
  ·int getSize()    O(1)
  ·boolean isEmpty()    O(1)

• 业务逻辑如下：

• import java.util.Stack;class Solution {public boolean isValid(String s) {Stack<Character> stack = new Stack<>();for (int i = 0; i < s.length(); i++) {char c = s.charAt(i);if (c == '(' || c == '[' || c == '{') {stack.push(c);} else {if (stack.isEmpty()) {return false;}char topChar = stack.pop();if (topChar == '(' && c != ')') {return false;}if (topChar == '[' && c != ']') {return false;}if (topChar == '{' && c != '}') {return false;}}}return stack.isEmpty();   //这里很巧妙
      }//测试public static void main(String[] args){System.out.println((new Solution()).isValid("()"));System.out.println((new Solution()).isValid("()[]}{"));System.out.println((new Solution()).isValid("({[]})"));System.out.println((new Solution()).isValid("({)}[]"));}
  }