Java实现栈以及栈的相关面试题

目录

• Java实现栈
• 栈的经典题目

---

1.Java实现栈

栈是一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。简言之就是出栈和入栈都是在栈顶进行操作，因为其底层是一个数组，所以实现会非常简单，我就不多赘述了，看代码：

public class MyStack<E> {
    public int usedSize;
    public E[] elem;
    public static final int DEFAULT_SIZE = 5;

    public MyStack() {
        this.elem = (E[])new Object[DEFAULT_SIZE];
    }

    ///入栈
    public void push(E val){
        //入队，需要判满，满了要扩容
        if(isFull()) {
            this.elem = Arrays.copyOf(this.elem, 2*this.elem.length);
        }
        this.elem[usedSize++] = val;
    }
    private Boolean isFull() {
        return this.usedSize == this.elem.length;
    }
    //出栈
    public E pop(){
        //栈为空，不能弹出元素
        if(empty()) {
            throw new MyStackIsEmpty("栈为空！");
        }
        E ret = this.elem[usedSize-1];
        //this.elem[usedSize-1] = null;引用类型需要置空
        this.usedSize--;
        return ret;
    }
    //获取栈顶元素，但不删除
    public E peek(){
        if(empty()) {
            throw new MyStackIsEmpty("栈为空！");
        }
        return this.elem[usedSize-1];
    }
    public int size(){
        return this.usedSize;
    }
    public boolean empty(){
        return this.usedSize == 0;
    }
}

栈的一些常用方法：

方法	功能
Stack()	构造一个空栈
E push(E e)	将 e 入栈，并返回 e
E pop()	将栈顶元素出栈并返回
E peek()	获取栈顶元素
int size()	获取栈中有效元素个数
boolean empty()	检测栈是否为空

---

2.栈的经典题目

 2.1.括号匹配

    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for(int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            //是左括号就入栈
            if(ch == '(' || ch == '{' || ch == '[') {
                stack.push(ch);
            } else {
                //如果第一个就是右括号，直接返回false
                if(stack.empty()) return false;
                char tmp = stack.peek();
                if(tmp == '(' && ch == ')' || tmp == '[' && ch == ']' || tmp == '{' && ch == '}') {
                    stack.pop();
                } else {
                    return false;
                }
            }
        }
        //如果栈里面还有元素，说明左括号多，return false
        return stack.empty();
    }

先讨论不匹配的情况，只有三种：

1.左括号多：" ( ( { } " ;  2.右括号多：" ( { } ) ] )" ;  3.左右括号不匹配：" ( } ";

所以这个题用栈来实现就简单了，我们把左括号入栈，遇到右括号就弹出一个元素，然后判断这两括号匹配不匹配，一次类推；所以我们要设计一个循环来遍历字符串当中的每个字符，如果循环走完，栈不为空，说明左括号多；如果栈为空，循环还没走完，说明右括号多；如果栈为空，中间的括号也都匹配上了，就返回 true；

---

 2.2.逆波兰表达式

    private boolean isCalculate(String s) {
        if("+".equals(s) || "-".equals(s) || "*".equals(s) || "/".equals(s)) {
            return true;
        }
        return false;
    }
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for(int i = 0; i < tokens.length; i++) {
            String s = tokens[i];
            if(!isCalculate(s)) {
                stack.push(Integer.parseInt(s));
            } else {
                //走到这里，说明s拿到的是运算符，弹两个元素出来
                int nums1 = stack.pop();
                int nums2 = stack.pop();
                switch(s) {
                    case "+" :
                        stack.push(nums2 + nums1);
                        break;
                    case "-" :
                        stack.push(nums2 - nums1);
                        break;
                    case "*" :
                        stack.push(nums2 * nums1);
                        break;
                    case "/" :
                        stack.push(nums2 / nums1);
                        break;
                }
            }
        }
        return stack.peek();
    }

在讲解这个题之前给大家普及一点知识，我们平时的算术表达式中，运算符总是出现在两个操作数之间，例如 5 * (7 - 2 * 3) + 8 / 2 ,这种形式叫做中缀表达式，而我们的逆波兰表达式又叫后缀表达式，那什么是后缀表达式呢???

我们把中缀表达式的运算符移动到自己所在的括号的右括号的右边，然后再去括号，这就是逆波兰表达式，，，那这个东西该怎么计算呢？？？

去括号得到的结果存放在数组中，用 for 循环拿到数组中每一个元素，然后判断，是操作数就放入栈中，不是操作数，就肯定是运算符，此时就从栈中依次弹出两个元素，第一个作为右操作数，第二个作为左操作数，直到循环走完，此时栈中还剩一个元素，它就是我们表达式的结果。

---

2.3.出栈入栈次序匹配

    public boolean IsPopOrder(int [] pushA,int [] popA) {
        Stack<Integer> stack = new Stack<>();
        int j = 0;
        for(int i = 0; i < pushA.length; i++) {
            int tmp = pushA[i];
            stack.push(tmp);
            while(!stack.empty() && j < popA.length && stack.peek() == popA[j]) {
                stack.pop();
                j++;
            }
        }
        return stack.empty();//如果栈里面还有元素，则为假
    }

思路：我们先把pushA数组的元素一个一个和popA数组中的第一个元素比较，如果不相等就入栈，相等则出栈，所以这里我们需要两个变量分别控制两个数组，再一个就是特殊情况，可能我第一次匹配成功之后，栈顶元素又和popA当前值相等了，则又要弹出，所以弹出元素是需要一个循环来控制的，，最后就是考虑不匹配的情况了，如果循环走完了，栈不为空，则说明不匹配，，

 谢谢观看！！！