栈(Java)

提示：多练才是王道,加油٩(๑❛ᴗ❛๑)۶

---

1. 栈

栈是一种特殊的线性表,其只允许在固定的一端进行插入和删除操作.进行数据插入和删除的一端被称为栈顶,另一端称为栈底.栈中的元素遵循先进后出的原则.栈的三大核心操作:

1. push(E item):将元素压入栈顶
2. pop():弹出并返回栈顶元素.如果栈为空,则抛出异常
3. peek():查看栈顶元素但不弹出.如果栈为空,则抛出异常

如图所示,在栈顶进行入栈和出栈操作.

2. Java中栈的其中两种实现方式

2.1 Stack类

java.util.Stack类,是Java最早提供的栈实现,官方已经不推荐使用了,但是在很多编程算法题中,Stack仍然被广泛使用.

为什么不推荐?

Stack继承自Vector:

• 性能差:Vector是线程安全的,所有方法都用synchronized关键字修饰,即使在单线程环境下也会带来不必要的开销.
• 设计缺陷:它继承制Vector,导致它拥有了许多绯斩操作(如get(int index),insertElementAt),这破坏了栈的封装性和"后进先出"的原则.

既然不推荐,为什么很多刷题平台还是广泛使用呢?

• 历史关心 & 教学传统:很多算法教程、大学课程和早期的编程书籍都是基于Stack类来讲解栈概念的。这些教学材料有很强的延续性，导致一代代的程序员在学习阶段就习惯了使用Stack。
• 要求不同:在算法题中,通常只关心核心逻辑的正确性,而不是生产级别的代码质量.Stack的线程安全开销和设计缺陷在算法题的输入规模下几乎可以忽略不计,不会导致超时.
• 功能足够:对于求解一道算法题Stack提供的 push, pop, peek, empty 方法已经完全够用了。虽然它有多余的方法，但只要你不去用它们，就不会造成问题。

好了言归正传,现在我们来看一下这个Stack:

通过源码可以看到,Stack的核心方法就以下几种:

也就是:

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

2.1.1 Stack的模拟实现

public class MyStack {//底层使用整形数组elem啦存储元素public int[] elem;//usedSize两个作用:①表示当前栈中元素个数②始终指向栈顶元素的下一个位置,下一个入栈元素的下标public int usedSize;//构造方法将数组初始化为大小为10的整型数组public MyStack() {this.elem=new int[10];}//压栈操作public void push(int val) {if(isFull()) {//扩容,使用Arrays.copyOf方法,将新数组长度扩容为原来的2倍elem= Arrays.copyOf(elem,2*elem.length);}elem[usedSize++]=val;}public boolean isFull() {return usedSize==elem.length;}//出栈操作public int pop() {if(empty()) {return -1;//这里更合适做法是抛出一个异常}int toPop=elem[usedSize-1];//保留栈顶元素usedSize--;//逻辑删除return toPop;//最后返回栈顶元素}public boolean empty() {return usedSize==0;}//查看栈顶元素,逻辑与pop一致,除了不用usedSize--public int peek() {if(empty()) {return -1;//这里更合适做法是抛出一个异常}int toPeek=elem[usedSize-1];return toPeek;}
}

2.2 LinkedList类

上面Stack类的底层是动态数组,所以也叫顺序栈,用链表能实现栈吗?—可以.

LinkedList是双向链表,天然实现了栈所需的所有操作,并且效率很高.因此完全可以基于LinkedList实现栈.

顺着push和pop方法点过去可以看到两者的源码:

可以看到,push调用的是addFirst方法,即头插;pop调用的是removeFirst方法,即头删,因此用LinkedList实现的栈栈顶在链表的头,不是尾.

对比使用Stack类(在数组尾部进行入栈出栈,时间复杂度为O(1)):

• 这样入栈出栈操作也很高效,只涉及改变几个指针的指向,时间复杂度同为O(1).
• 然而数组满后需要昂贵的扩容操作(申请新数组,复制所有元素),双向链表无扩容开销,且不会造成内存浪费.

3. 典型习题讲解

3.1 逆波兰表达式求值

150. 逆波兰表达式求值 - 力扣（LeetCode）

这是一个栈的典型使用场景之一.求解这道题需要先弄明白逆波兰表达式的计算原理.

首先,什么是逆波兰表达式?

也叫后缀表达式,核心特点是运算符位于其对应的两个操作数之后.我们日常接触的都是中缀表达式,比如:a+b*c+(d*e+f)*g,其对应的后缀表达式为:abc*+de*f+g*+.

这是怎么转化的?有人总结出了以下步骤:

1. 先将中缀表达式的每个运算周围用括号括起来:a+b*c+(d*e+f)*g->((a+(b*c))+(((d*e)+f)*g))
2. 然后将每个运算符都向右移到包裹它的括号右边:((a+(b*c))+(((d*e)+f)*g))->((a(bc)*)+(((de)*f)+g)*)+
3. 最后将括号全部去掉:((a(bc)*)+(((de)*f)+g)*)+->abc*+de*f+g*+

可以明显看到后缀表达式的一个特征:没有括号,第3步将括号全部去掉了.

那为什么需要后缀表达式?

中缀表达式对人类很友好,但是对于计算机却很麻烦:需要处理运算符优先级(如乘除优先于加减)和加括号来确定运算顺序,这个过程比较复杂.

后缀表达式完美地解决了这个问题:

• 无需括号
• 无需优先级规则
• 只需要一个栈即可轻松完成计算.

那它的计算原理是什么?

1. 首先创建一个栈,准备将后缀表达式按照一定规律从左向右依次压入:
   • 若遇到数字,压入栈中,一直是数字就一直压
   • 若遇到的是运算符(+ - * /),则出栈两次,第一次的是右操作数,第二次是左操作数,运算过后,将结果继续压入栈中
   • 循环上述两个步骤,直至后缀表达式被扫描完
2. 扫描完后,栈中剩下的即为整个表达式的运算结果

然后思路就很清晰啦:

class Solution {public int evalRPN(String[] tokens) {Stack<Integer> stack=new Stack<>();for(int i=0;i<tokens.length;i++) {String tmp=tokens[i];if(isOperation(tmp)) {int num2=stack.pop();//右操作数int num1=stack.pop();//左操作数switch(tmp) {case "+":stack.push(num1+num2);break;case "-":stack.push(num1-num2);break;case "*":stack.push(num1*num2);break;case "/":stack.push(num1/num2);break;}}else {Integer num=Integer.valueOf(tmp);//将字符转为整型stack.push(num);}}return stack.pop();//遍历完数组,栈中剩下的就是运算结果}//判断是否是表达式public boolean isOperation(String s) {//引用类型进行比较要用equals,不能用==if(s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/")) {return true;}else {return false;}}
}

3.2 匹配括号

20. 有效的括号 - 力扣（LeetCode）

该题目要求第一次出现的右括号必须与它的前一个括号匹配,形状相同,朝向相反.

解题思路:创建一个栈,将字符串从左到右依次便利:

• 若是左括号,就痛快入栈;
• 若是右括号,弹出栈顶元素与其匹配:
  • 匹配的话(形状相同,朝向相反),就麻溜"出栈走人",然后下一位;
  • 不匹配的话,直接返回false
• 遍历完了就只用看下栈空不空,空了说明全部都匹配上了,返回true;非空返回false.

思路清晰,coding~

class Solution {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=='(') {//ch为左括号,入栈stack.push(ch);}else {//ch为右括号if(stack.empty()) {return false;//若是遇到了落单的右括号,直接false}else {char tmp=stack.peek();if(tmp=='{' && ch=='}' ||tmp=='[' && ch==']'|| tmp=='(' && ch==')' ) {stack.pop();}else {return false;}}}}return stack.empty();}
}

注意:判断Stack是否为空有两个方法isEmpty()和empty()(empty是Stack自己声明的,isEmpty则是Sytack从其父类Vector继承而来的),在idea上两者都能用,但是在力扣上用isEmpty()会报错,这可能是因为力扣的版本或环境问题,也可能是提供的Stack类是一个预定义的,模拟的类,就像2.1.1的模拟实现一样.

3.3 合理弹出序列

栈的压入、弹出序列_牛客题霸_牛客网

这种题型在选择题中常见,但是若是要将写选择题那种有点"只可意会不可言传"的感觉转为代码,还是有点差距的~

这题的思路是:定义两个下标,分别遍历入栈和出栈序列,假设i遍历入栈序列,j遍历出栈序列;

• 定义一个栈,将i对一个元素入栈,然后将i与j下标对应的值进行比较,若不相等,i++,j不动
• i一直++,直到i,j对应值相等,此时,将i对应元素出栈,j++
• 若是栈顶元素与j对应元素一直相等,则一直出栈,j也一直++;不相等了,再重复上一步操作
• 最后i和j都会遍历完,若此时栈为空,则说明该出栈序列是合理的,反之不合理.

public boolean IsPopOrder (int[] pushV, int[] popV) {Stack<Integer> stack=new Stack<>();int j=0;for(int i=0;i<pushV.length;i++) {stack.push(pushV[i]);while(!stack.empty() && j<popV.length && stack.peek()==popV[j]) {stack.pop();j++;}}return stack.empty();}

3.4 最小栈

155. 最小栈 - 力扣（LeetCode）

题目明确要求在常数时间内检索到最小元素,若只定义一个栈,那么寻找最小元素势必要遍历一遍stack,时间复杂度为O(n),不符合要求,因此,此题要建立两个栈:

1. 一个普通栈,正常压入弹出元素,每次使用push,pop,top这三个方法时均要对这个普通栈进行操作.
2. 还有一个存放最小元素的栈,该栈的压入弹出不能那么随心所欲了:
   • 元素push时要先与该栈栈顶元素比较,只有不大于栈顶元素才能压入栈中,否则便不能;
   • pop时要将栈顶元素与普通栈pop掉的元素比较,若相等,才能pop掉
   • top不能操作该栈
   • getMin只能操作该栈,用于peek该栈的栈顶元素

coding~

class MinStack {Stack<Integer> stack;Stack<Integer> minStack;public MinStack() {stack=new Stack<>();minStack=new Stack<>();}public void push(int val) {stack.push(val);if(minStack.empty()) {minStack.push(val);} else if(val<=minStack.peek()) {minStack.push(val);}}public void pop() {if(stack.empty()) return;int tmp=stack.pop();if(tmp==minStack.peek()) {minStack.pop();}}public int top() {if(stack.empty()) return -1;else return stack.peek();}public int getMin() {if(minStack.empty()) return -1;else return minStack.peek();}
}