【本节目标】
1.
栈的概念及使用
2.
相关
OJ
题
一、概念
- 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。
- 栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
- 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
- 出栈：栈的删除操作叫做出栈。出数据在栈顶
栈在现实生活中的例子：
二、栈的使用
public static void main(String[] args) {
Stack<Integer> s = new Stack();
s.push(1);
s.push(2);
s.push(3);
s.push(4);
System.out.println(s.size()); // 获取栈中有效元素个数---> 4
System.out.println(s.peek()); // 获取栈顶元素---> 4
s.pop(); // 4出栈，栈中剩余1 2 3，栈顶元素为3
System.out.println(s.pop()); // 3出栈，栈中剩余1 2 栈顶元素为3
if(s.empty()){
System.out.println("栈空");
}else{
System.out.println(s.size());
}
}三、栈的模拟实现
从上图中可以看到，
Stack
继承了
Vector
，
Vector
和
ArrayList
类似，都是动态的顺序表，不同的是
Vector
是线程安全的。
import java.sql.Array;
import java.util.Arrays;
public class MyStack {
public int[] elem;
public int usedSize;
public MyStack(int[] elem) {
this.elem = new int[10];
}
public void push(int data){
if(ifFull()){
grow();
}
elem[usedSize++]=data;
}
public boolean ifFull(){
return elem.length==usedSize;
}
private void grow(){
elem= Arrays.copyOf(elem,elem.length*2);
}
public int pop(){
if(isEmpty()){
throw new EmptyException("栈为空");
}else {
int k=usedSize-1;
usedSize--;
return elem[k];
}
}
private boolean isEmpty(){
return usedSize==0;
}
public int peek(){
if(isEmpty()){
throw new EmptyException("栈为空");
}else {
return elem[usedSize-1];
}
}
}
四、栈的应用场景
1. 改变元素的序列
1. 若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）A: 1,4,3,2 B: 2,3,4,1 C: 3,1,4,2 D: 3,4,2,1答案：C2. 一个栈的初始状态为空。现将元素 1 、 2 、 3 、 4 、 5 、 A 、 B 、 C 、 D 、 E 依次入栈，然后再依次出栈，则元素出栈的顺序是（ ）。A: 12345ABCDE B: EDCBA54321 C: ABCDE12345 D: 54321EDCBA答案：B
单链表是否可以实现栈？
答：
- 顺序表实现的栈可以将插入、删除的时间复杂度达到O（1），
- 如果采用尾插操作，入栈时间复杂度为O（N），如果有last那么时间复杂度为O（1），但是出栈一定是O（N）
- 如果采用头插法，入栈时间复杂度为O（1），同时出栈的时间复杂度也是O（1）
结论：
- 如果采用单链表来实现栈，那么可以采用头插法的形式来入栈和出栈，叫做链式栈
- 采用双向链表来实现栈是完全ok的，入栈不管是头插还是尾插都可以实现，时间复杂度都可以达到O（1）
2. 将递归转化为循环
比如：逆序打印链表
{
Stack<Node> s = new Stack<>();
// 将链表中的结点保存在栈中
Node cur = head;
while(null != cur){
s.push(cur);
cur = cur.next;
}
// 将栈中的元素出栈
while(!s.empty()){
System.out.print(s.pop().val + " ");
}
}3. 括号匹配
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=='{'){
stack.push(ch);//是左括号则入栈
}else{
if(stack.isEmpty()){
return false;//不是左括号，但是栈空，右括号多
}
char ch2=stack.peek();
if((ch2=='('&&ch==')')||(ch2=='['&&ch==']')||(ch2=='{'&&ch=='}')){
stack.pop();//有括号刚好匹配左括号，出栈
}else{
return false;//右括号不匹配左括号，错误
}
}
}
if(!stack.isEmpty()){
return false;//遍历结束但是但是栈不空，左括号多
}
return true;
}
}4. 逆波兰表达式求值
题目：中缀表达式a+b*c+(d*e+f)*g，其转换成后缀表达式为abc*+de*f+g*+。
将表达式按照运算先后加括号
a+b*c+(d*e+f)*g=（（a+（b*c））+（（(d*e）+f)*g））
再将每个运算符移出对应的括号外面
（（a+（b*c））+（（(d*e）+f)*g））=（（a（bc）*）+（（(de）*f)+g）*）+
class Solution {
public int evalRPN(String[] tokens) {
Stack<Integer> stack=new Stack<>();
for(int i=0;i<tokens.length;i++){
String ch=tokens[i];
if(isOperator(ch)==false){
int z=Integer.parseInt(ch);
stack.push(z);
}else{
int y=stack.pop();
int x=stack.pop();
switch(ch){
case"+":stack.push(x+y);
break;
case"-" :stack.push(x-y);
break;
case"*" :stack.push(x*y);
break;
case"/":stack.push(x/y);
break;
}
}
}
return stack.pop();
}
private boolean isOperator(String ch){
if(ch.equals("+")||ch.equals("-")||ch.equals("*")||ch.equals("/")){
return true;
}
return false;
}
}把字符串变成整形的函数Integer.parseInt（）
5. 出栈入栈次序匹配
顺序遍历pushV，如果栈顶元素和popV当前元素相同，则弹出，不同则将pushV当前元素入栈
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param pushV int整型一维数组
* @param popV int整型一维数组
* @return bool布尔型
*/
public boolean IsPopOrder (int[] pushV, int[] popV) {
// write code here
Stack<Integer> stack=new Stack<>();
int j=0;
for(int i=0;i<pushV.length;i++){
stack.push(pushV[i]);
while(stack.empty()==false&&j<popV.length&&stack.peek()==popV[j]){
stack.pop();
j++;
}
}
return stack.empty();
}
}
6. 最小栈
入栈：
- 普通栈一定要放
- 最小栈放的原则：
- 如果最小栈是空的，则放
- 如果放的元素小于等于当前栈顶的元素，则放
出栈：判断出栈元素和最小栈栈顶元素关系，相同则最小栈也出去
import java.util.Stack;
class MinStack {
public Stack<Integer> stack;
public 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 {
int peekVal = minStack.peek();
if(val <= peekVal) {
minStack.push(val);
}
}
}
public void pop() {
if(stack.empty()) {
return;
}
int popVal = stack.pop();
if(popVal == minStack.peek()) {
minStack.pop();
}
}
public int top() {
if(stack.empty()) {
return -1;
}
return stack.peek();
}
public int getMin() {
if(minStack.empty()) {
return -1;
}
return minStack.peek();
}
}五、 概念区分
栈、虚拟机栈、栈帧有什么区别呢？
- 栈:是一种数据结构
- 虚拟机栈：是jvm中的一块内存
- 栈帧：运行一个方法、一个函数时，给它开辟的内存
