栈-实现一个简单的静态栈

栈的简介

        栈是一种先进后出的线性表。栈限制插入和删除只能在一个位置进行，允许插入删除的一端称为栈顶，另一端称为栈底。

        插入数据的操作称为压栈（PUSH），删除数据的操作称为弹栈（POP）。

栈有两种实现方式：通过数组实现（静态栈），通过链表实现（动态栈）。

 实现一个静态栈

定义一个栈溢出异常，当栈满时继续压栈抛出

package xyz.syyrjx.stack.exception;

public class MyStackOverflowException extends RuntimeException{
    public MyStackOverflowException() {
    }

    public MyStackOverflowException(String message) {
        super(message);
    }
}

定义一个栈空异常，当栈空时继续弹栈抛出

package xyz.syyrjx.stack.exception;

public class MyStackEmptyException extends RuntimeException{
    public MyStackEmptyException() {
    }

    public MyStackEmptyException(String message) {
        super(message);
    }
}

定义一个简单的静态栈

package xyz.syyrjx.stack;

import xyz.syyrjx.stack.exception.MyStackEmptyException;
import xyz.syyrjx.stack.exception.MyStackOverflowException;

public class MyStaticStack<T> {
    private Object[] array;
    private int size;

    private static final int DEFAULT_INIT_LENGTH = 10;
    private static final String STACK_OVERFLOW_MESSAGE = "栈已满,无法继续存入数据";
    private static final String STACK_EMPTY_MESSAGE = "栈已空,无法继续删除数据";

    public MyStaticStack(int initLength){
        array = new Object[initLength];
    }
    public MyStaticStack(){
        this(DEFAULT_INIT_LENGTH);
    }

    /**
     * 压栈方法
     * @param obj 需要压栈的数据
     */
    public void push(T obj){
        if (size >= array.length){
            throw new MyStackOverflowException(STACK_OVERFLOW_MESSAGE);
        }
        array[size++] = obj;
    }

    /**
     * 弹栈方法
     * @return 弹出栈的元素
     */
    public T pop(){
        if (0 == size){
            throw new MyStackEmptyException(STACK_EMPTY_MESSAGE);
        }
        T res = (T)array[size - 1];
        size--;
        return res;
    }

    /**
     * 获取栈中有效元素的长度
     * @return 有效元素的长度
     */
    public int size(){
        return this.size;
    }

    public static void main(String[] args) {
        MyStaticStack<String> stack = new MyStaticStack<>();
        stack.push("1");
        stack.push("2");
        stack.push("3");
        stack.push("4");
        stack.push("5");
        stack.push("6");
        System.out.println("当前栈的长度" + stack.size());
        System.out.println("弹出栈顶元素" + stack.pop());
        System.out.println("当前栈的长度" + stack.size());
        stack.push("7");
        System.out.println("弹出栈顶元素" + stack.pop());
    }
}

使用刚刚写的静态栈来解决问题

题目：给出一个仅包含字符'(',')','{','}','['和']',的字符串，判断给出的字符串是否是合法的括号序列
括号必须以正确的顺序关闭，"()"和"()[]{}"都是合法的括号序列，但"(]"和"([)]"不合法。

package xyz.syyrjx.stack;

import java.util.Objects;

public class TestApp {
    /*
        给定字符串只有'('、')'、'['、']'、'{'、'}'
        判断字符串中的括号是不是完整关闭
        如"("、"[[(]"、"]["返回false
        "()"、"[()]"返回true
     */
    public static final char[] BRACKETS_ARRAY = {'(',')','[',']','{','}'};

    /**
     * 检验字符串
     * @param str 需要被检验的字符串
     * @return 匹配返回true，不匹配返回false
     */
    public static boolean check(String str){
        //如果字符串长度为单数，一定不是完整关闭的
        if (0 != str.length() % 2){
            return false;
        }

        MyStaticStack<Character> stack = new MyStaticStack<>(str.length());

        for (int i = 0; i < str.length(); i++){
            char currentChar = str.charAt(i);
            //判断是哪个字符
            int j = 0;
            for (;j < BRACKETS_ARRAY.length; j++){
                if (currentChar == BRACKETS_ARRAY[j]){
                    break;
                }
            }
            //出现了其它字符
            if (j > BRACKETS_ARRAY.length){
                return false;
            }
            switch (j){
                //左括号进栈
                case 0:
                case 2:
                case 4:
                    stack.push(BRACKETS_ARRAY[j]);
                    break;
                //右括号出栈
                case 1:
                case 3:
                case 5:
                    //栈空还需要出栈，右括号多了
                    if (0 == stack.size()){
                        return false;
                    }
                    //本次出栈的左括号不与本次获取到的右括号匹配，则返回false
                    if (!Objects.equals(BRACKETS_ARRAY[j - 1],stack.pop())){
                        return false;
                    }
                    break;
            }
        }
        //如果栈中还有剩余的数据，则左括号多了
        return 0 == stack.size();
    }

    public static void main(String[] args) {
        System.out.println(check("111"));
        System.out.println(check("()[]{}"));
        System.out.println(check("[}"));
        System.out.println(check("[)"));
        System.out.println(check("{(})"));
        System.out.println(check("{[()]}"));
    }
}