Índice
1. Perguntas de múltipla escolha que podem ser respondidas durante o empilhamento
2. Transforme recursão em loop
3. Avaliação reversa da expressão polonesa
5. Sequência push e pop de pilha
Prefácio:
Se você quer aprender bem a estrutura de dados, precisa praticar as questões, não só precisamos estudar mais questões, mas também estudá-las bem! Por esse motivo, iniciei uma série de perguntas obrigatórias. Este é o primeiro artigo de múltipla escolha. Esta série será atualizada de tempos em tempos, fique atento!
Explicação detalhada do Stack - Blog WHabcwu - Blog CSDN
1. Perguntas de múltipla escolha que podem ser respondidas durante o empilhamento
A sequência de entrada e saída da opção A:push(1)->pop() saída 1;push(2)->push(3)->push(4)->pop() e 4;pop() fora 3;pop() fora 2;As etapas do BCD são as mesmas e a análise mostra que C está obviamente errado;Escolha C
2. Transforme recursão em loop
public void printfList(Node head) {
if (head == null) {
return;
}
Node cur=head;
Stack<Node> stack = new Stack<>();
while (cur!=null){
stack.push(cur);
cur=cur.next;
}
while(!stack.empty()){
System.out.println(stack.pop().val);
}
}3. Avaliação reversa da expressão polonesa
Para compreender completamente esta questão, você deve primeiro entender claramente a expressão sufixo
Resumir:
(1) Percorra os números e empurre a pilha de acordo
(2) Pop 2 números ao encontrar ' + ' ' - ' ' * ' ' / ', o número exibido pela primeira vez é usado como o operando direito, e o número exibido pela segunda vez é usado como o operando esquerdo
(3) Em seguida, coloque o número calculado por (2) na pilha
(4) Repita (1) (2) (3)
Então o código:
class Solution {
public int evalRPN(String[] tokens) {
Stack<Integer> stack = new Stack<>();
for (String x : tokens) {
if (!isoperation(x)) {
stack.push(Integer.parseInt(x));
} else {
int x1 = stack.pop();
int x2 = stack.pop();
switch (x) {
case "+":
stack.push(x2 + x1);
break;
case "-":
stack.push(x2 - x1);
break;
case "*":
stack.push(x2 * x1);
break;
case "/":
stack.push(x2 / x1);
break;
}
}
}
return stack.pop();
}
public boolean isoperation(String x) {
if (x.equals("+") || x.equals("-") || x.equals("*") || x.equals("/")) {
return true;
}
return false;
}
}4. Parênteses Válidos
Parênteses válidos 
https://leetcode.cn/problems/valid-parentheses/
class Solution {
public boolean isValid(String s) {
Stack<Character> stack = new Stack<>();
for (int i = 0; i < s.length(); i++) {
char x=s.charAt(i);
if(x=='('||x=='{'||x=='['){
stack.push(x);
}else{
if(stack.empty()){
return false;
}
char y=stack.peek();
if(y=='('&&x==')'||y=='{'&&x=='}'||y=='['&&x==']'){
stack.pop();
}else{
return false;
}
}
}
if(!stack.empty()){
return false;
}
return true;
}
}Analisar:
(1) Percorra a string fornecida, pois o parêntese esquerdo encontrado posteriormente deve ser fechado primeiro , para que possamos colocar esse parêntese esquerdo no topo da pilha.
(2) Quando encontramos um parêntese direito, podemos retirar o parêntese esquerdo do topo da pilha e julgar se eles são do mesmo tipo de parênteses.Se a pilha estiver vazia, retorne flase, se não estiver vazio, mas não do mesmo tipo, também retorna falso.
(3) Após a travessia, se não houver parênteses esquerdos na pilha, retorne falso.
5. Sequência push e pop de pilha
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param pushV int整型一维数组
* @param popV int整型一维数组
* @return bool布尔型
*/
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(j<popV.length&&!stack.empty()&&stack.peek().equals(popV[j])){
stack.pop();
j++;
}
}
return stack.empty();
}
}Analisar:
6. Pilha mínima
Pilha mínima https://leetcode.cn/problems/min-stack/
import java.util.Stack;
public class MinStack {
private Stack<Integer> stack;
private Stack<Integer> minstack;
public MinStack() {
this.stack = new Stack<>();
this.minstack = new Stack<>();
}
public void push(int val) {
stack.push(val);
if (minstack.empty()) {
minstack.push(val);
} else {
if (minstack.peek() >= val) {
minstack.push(val);
}
}
}
public void pop() {
if(!stack.empty()){
int x = stack.pop();
if (x == minstack.peek()) {
minstack.pop();
}
}
}
public int top() {
return stack.peek();
}
public int getMin() {
return minstack.peek();
}
}
Analisar:
Método de pilha auxiliar:
(1) Um é usado para armazenar dados normalmente -> pilha
(1) Um é usado para armazenar os dados mínimos-> minstack
pilha privada Stack<Integer>;
private Stack<Integer> minstack;
empurrar:
A pilha é empurrada para dentro da pilha sem distinção, e a pilha mínima é julgada. Se estiver vazia, é empurrada diretamente para a pilha. Se não estiver vazia, precisa ser comparada com o elemento superior da pilha. Se estiver for menor ou igual a, ele será colocado na pilha.
O resto é simples demais para descrever.
O acima é meu compartilhamento pessoal, se você tiver alguma dúvida, seja bem-vindo para discutir! ! !
Eu já vi isso, por que você não presta atenção e dá um like grátis 
