Java - empuje de pila, secuencia emergente

enlace de tema

Niuke online oj question - stack push, secuencia pop

Tema Descripción

Ingrese dos secuencias enteras, la primera secuencia representa la orden de inserción de la pila, juzgue si la segunda secuencia puede ser la orden de aparición de la pila. Suponga que todos los números empujados a la pila son desiguales. Por ejemplo, la secuencia 1, 2, 3, 4, 5 es la secuencia de inserción de una cierta pila, y la secuencia 4, 5, 3, 2, 1 es una secuencia emergente correspondiente a la secuencia de inserción, pero 4, 3, 5, 1, 2 No puede ser la secuencia pop de la secuencia push.

1. 0<=pulsarV.longitud == popV.longitud <=1000
2. -1000<=empujarV[i]<=1000
3. Todos los números de pushV son diferentes

Ejemplo de tema

Ejemplo 1

Entrada:
[1,2,3,4,5],[4,5,3,2,1]

valor de retorno:
verdadero

Descripción:
Puede pasar push(1)=>push(2)=>push(3)=>push(4)=>pop()=>push(5)=>pop()=>pop()=> pop ()=>pop()
para obtener la secuencia [4,5,3,2,1] y devolver verdadero

Ejemplo 2

Entrada:
[1,2,3,4,5],[4,3,5,1,2]

valor devuelto:
falso

Explicación:
dado que es la secuencia de pulsación de [1,2,3,4,5] y la secuencia de pulsación de [4,3,5,1,2], se requiere que se pulsen 4, 3, 5 antes de 1, 2, Y 1 y 2 no se pueden mostrar, pero en un orden tan apremiante, 1 no se puede mostrar antes de 2, por lo que si no se puede formar, devuelve falso

ideas para resolver problemas

En primer lugar, si pushA o popA están vacíos, o las longitudes de los dos son diferentes, es definitivamente imposible ser la secuencia emergente de la pila y devolver falso directamente.

Puede crear directamente una pila, definir un elemento i para recorrer la secuencia pushA y definir un elemento j para recorrer la secuencia popA

Primero inserte el elemento pushA[i] en la pila. Si la pila no está vacía y el valor del elemento superior de la pila es igual a popA[j], entonces el elemento superior de la pila siempre aparecerá, j++

Repita el proceso anterior, si la última pila no está vacía, significa que todavía hay elementos que no se han extraído y devuelve falso

Por ejemplo:

primero inserte el elemento push[i] en la pila

, luego pop[j] != stack.peek(), I++, continúe insertando arr[i] en la pila,

luego pop[j] != stack. peek(), I++, continúa insertando arr[i] en la pila

. Cuando i es 3, el elemento insertado en la pila es 4 en este momento, pop[j] == stack.peek(), extrae el elemento superior de la pila, j++ en este momento

pop[j] ! = stack.peek(), I++, continúa empujando hacia la parte superior de la pila

En este momento, pop[j] == stack.peek(), extrae el elemento superior de la pila, j++, repite las operaciones anteriores hasta que la pila está vacía, y

finalmente cuando atravieso toda la matriz, la pila está vacía, lo que indica que popA es la secuencia emergente correcta y devuelve verdadero

código completo

import java.util.*;

public class Solution {
    
    
    public boolean IsPopOrder(int [] pushA,int [] popA) {
    
    
      if(pushA == null || popA == null || pushA.length != popA.length){
    
    
            return false;
        }
        Stack<Integer> stack = new Stack<>();
        int j = 0;
        for (int i = 0; i < pushA.length; i++){
    
    
            stack.push(pushA[i]);
            while(!stack.isEmpty() && stack.peek() == popA[j]){
    
    
                stack.pop();
                j++;
            }
        }
        return stack.isEmpty();
    }
}