La espada se refiere a la Oferta 31. La secuencia de empujar y hacer estallar la pila --- simulación

La espada se refiere a la Oferta 31. La secuencia de empujar y hacer estallar la pila

Ingrese dos secuencias enteras. La primera secuencia representa el orden en el que se empuja la pila. Por favor, juzgue si la segunda secuencia es el orden emergente de la pila. Suponga que todos los números colocados en la pila no son iguales. Por ejemplo, la secuencia {1,2,3,4,5} es la secuencia de inserción de una determinada pila, 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 emergente de la secuencia de la pila.

Ejemplo 1:

Entrada: push = [1,2,3,4,5], popped = [4,5,3,2,1]
Salida: verdadera
Explicación: Podemos ejecutar en el siguiente orden:
push (1), push (2 ), empujar (3), empujar (4), pop () -> 4,
empujar (5), pop () -> 5, pop () -> 3, pop () -> 2, pop () -> 1
Ejemplo 2:

Entrada: push = [1,2,3,4,5], popped = [4,3,5,1,2]
Salida: falso
Explicación: 1 no se puede abrir antes que 2.

Fuente:
Enlace de LeetCode : Haga clic para ir a https://leetcode-cn.com/problems/zhan-de-ya-ru-dan-chu-xu-lie-lcof

---

Ideas:

Simular operaciones pop y pop

1. Matriz de bucle
2. Busque el primer elemento de la matriz emergente, luego recorra la matriz emergente para encontrar el índice de elemento correspondiente y luego empuje todos los elementos que no se han colocado en la pila antes del índice.
3. Juzgue si el elemento superior de la pila es igual al elemento subíndice de la matriz emergente, si no es igual, devuelva falso
4. Si sale del ciclo de hacer estallar la matriz, cumple con los requisitos y devuelve verdadero

class Solution {
    
    
    public static boolean validateStackSequences(int[] pushed, int[] popped) {
    
    
        int push = pushed.length;
        int pop = popped.length;
        int i = 0;  //入栈下标
        int j = 0;  //出栈下标
        Stack<Integer> stack = new Stack<>();
        //下标范围内循环
        while(j < pop) {
    
    
            int start = i;  //记录入栈的下标
            
            //若栈为空 或 栈顶元素不等于弹出j下标元素
            //则进行入栈模拟，找到下个出栈的元素，然后入从start到k
            if(stack.isEmpty() || stack.peek() != popped[j]) {
    
    
                for(int k = i; k < push; k++) {
    
    
                    //先找到出栈元素 对应的 入栈元素的下标，为k
                    if(pushed[i] == popped[j]) {
    
    
                        //从start到k元素入栈
                        for(int n = start; n <= k; n++) {
    
    
                            stack.push(pushed[n]);
                        }
                        i++;
                        break;  //入完栈循环结束
                    }
                    i++;
                }
            }
            
            //判断栈顶元素和出栈元素是否相等，相等遍历下一个，不等就返回false
            if(stack.pop() == popped[j]) {
    
    
                j++;
            }else {
    
    
                return false;
            }
        }
        //如果程序走到这，证明出栈元素遍历完成，符合入栈出栈条件，返回true
        return true;
    }
}

---

Proceso del algoritmo de hermano mayor:

1. Inicialización: pila de pila auxiliar, índice i de la secuencia emergente;
2. Atraviesa la secuencia de la pila: cada elemento está marcado como num;
   (1) El elemento num se empuja a la pila;
   (2) Bucle reventado: si el elemento superior de la pila == elemento de secuencia emergente apareció [i], entonces pop e i ++ se ejecutan
3. Valor de retorno: si la pila está vacía, esta secuencia emergente es legal.

Autor: jyd
enlace: https: //leetcode-cn.com/problems/zhan-de-ya-ru-dan-chu-xu-lie-lcof/solution/mian-shi-ti-31-

class Solution {
    
    
    public boolean validateStackSequences(int[] pushed, int[] popped) {
    
    
        Stack<Integer> stack = new Stack<>();
        int i = 0;
        for(int num : pushed) {
    
    
            stack.push(num); // num 入栈
            while(!stack.isEmpty() && stack.peek() == popped[i]) {
    
     // 循环判断与出栈
                stack.pop();
                i++;
            }
        }
        return stack.isEmpty();
    }
}