leecode题解，实现一个简单的栈结构

栈是一个很重要的数据结构，在计算机应用里也经常能看到栈的身影，比如

1. location的路由，push、pop操作对前端朋友不陌生吧
2. 符号匹配
3. 标签匹配，比如html标签
4. 函数调用，比如递归为什么调用顺序和返回顺序是相反的

在leecode里，有这样一道有意思的题，原题是这样的：

Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

An input string is valid if:

1. Open brackets must be closed by the same type of brackets.
2. Open brackets must be closed in the correct order.

Note that an empty string is also considered valid.

Input: "()"
Output: true

Input: "()[]{}"
Output: true

Input: "(]"
Output: false

Input: "([)]"
Output: false

Input: "{[]}"
Output: true

这里就使用了栈来解决问题，解决代码如下

class Solution {
    public boolean isValid(String s) {
        if(s==null || "" == s) return false;
        Stack<Character> stack = new Stack<Character>();
        for(int i=0;i<s.length();i++){
            Character c = s.charAt(i);
            if('(' == c || '[' == c || '{' == c) {
                stack.push(c);
            } else if(')' == c && !stack.empty() && '(' == stack.peek()){
                stack.pop();
            } else if(']' == c && !stack.empty() && '[' == stack.peek()){
                stack.pop();
            } else if('}' == c && !stack.empty() && '{' == stack.peek()){
                stack.pop();
            } else {
                return false;
            }
        }
        return stack.empty();
    }
}

 其中Stack是jdk原生提供的工具类，注意它是继承于vector的，所以是线程安全的，我们也可以自己实现一个栈

package com.natsuki.Stack;

import java.io.Serializable;
import java.util.EmptyStackException;


public class SeqStack<T> implements Stack<T>,Serializable {

    private static final long serialVersionUID = -5413303117698554397L;

    /**
     * 栈顶指针,-1代表空栈
     */
    private int top=-1;

    /**
     * 容量大小默认为10
     */
    private int capacity=10;

    /**
     * 存放元素的数组
     */
    private T[] array;

    private int size;

    public SeqStack(int capacity){
        array = (T[]) new Object[capacity];
    }

    public SeqStack(){
        array= (T[]) new Object[this.capacity];
    }

    public  int size(){
        return size;
    }


    @Override
    public boolean isEmpty() {
        return this.top==-1;
    }

    /**
     * 添加元素,从栈顶(数组尾部)插入
     * @param data
     */
    @Override
    public void push(T data) {
        //判断容量是否充足
        if(array.length==size)
            ensureCapacity(size*2+1);//扩容

        //从栈顶添加元素
        array[++top]=data;

        size++;
    }

    /**
     * 获取栈顶元素的值,不删除
     * @return
     */
    @Override
    public T peek() {
        if(isEmpty())
            new EmptyStackException();
        return array[top];
    }

    /**
     * 从栈顶(顺序表尾部)删除
     * @return
     */
    @Override
    public T pop() {
        if(isEmpty())
            new EmptyStackException();
        size--;
        return array[top--];
    }

    /**
     * 扩容的方法
     * @param capacity
     */
    public void ensureCapacity(int capacity) {
        //如果需要拓展的容量比现在数组的容量还小,则无需扩容
        if (capacity<size)
            return;

        T[] old = array;
        array = (T[]) new Object[capacity];
        //复制元素
        for (int i=0; i<size ; i++)
            array[i]=old[i];
    }

    public static void main(String[] args){
        SeqStack<String> s=new SeqStack<>();
        s.push("A");
        s.push("B");
        s.push("C");
        System.out.println("size->"+s.size());
        int l=s.size();//size 在减少,必须先记录
        for (int i=0;i<l;i++){
            System.out.println("s.pop->"+s.pop());
        }

        System.out.println("s.peek->"+s.peek());
    }
}