A espada se refere à Oferta 31. A sequência de empurrar e estourar a pilha --- simulação

A espada se refere à Oferta 31. A sequência de empurrar e estourar a pilha

Insira duas sequências inteiras. A primeira sequência representa a ordem em que a pilha é empurrada. Avalie se a segunda sequência é a ordem pop-up da pilha. Suponha que todos os números colocados na pilha não sejam iguais. Por exemplo, a sequência {1,2,3,4,5} é a sequência push de uma certa pilha, a sequência {4,5,3,2,1} é uma sequência pop correspondente à sequência push, mas { 4,3, 5,1,2} não pode ser a seqüência pop da seqüência de pilha.

Exemplo 1:

Entrada: push = [1,2,3,4,5], popped = [4,5,3,2,1]
Saída: true
Explicação: Podemos executar na seguinte ordem:
push (1), push (2 ), empurre (3), empurre (4), pop () -> 4,
empurre (5), pop () -> 5, pop () -> 3, pop () -> 2, pop () -> 1
Exemplo 2:

Entrada: push = [1,2,3,4,5], popped = [4,3,5,1,2]
Saída: false
Explicação: 1 não pode ser popped antes de 2.

Fonte: LeetCode
Link: Clique para ir para https://leetcode-cn.com/problems/zhan-de-ya-ru-dan-chu-xu-lie-lcof

---

Ideias:

Simule operações pop e pop

1. Matriz de loop estourado
2. Encontre o primeiro elemento da matriz popped e, em seguida, percorra a matriz popped para encontrar o índice do elemento correspondente e, em seguida, empurre todos os elementos que não foram colocados na pilha antes do índice.
3. Julgue se o elemento do topo da pilha é igual ao elemento subscrito da matriz exibida, se não for igual, retorna falso
4. Se ele sair do loop de popping da matriz, ele atenderá aos requisitos e retornará verdadeiro

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;
    }
}

---

Processo de algoritmo do irmão mais velho:

1. Inicialização: pilha de pilha auxiliar, índice i da sequência pop-up;
2. Percorra a sequência da pilha: cada elemento é marcado como num;
   (1) O elemento num é colocado na pilha;
   (2) Loop popped: Se o elemento superior da pilha == popped sequence element popped [i], então pop e i ++ são executados
3. Valor de retorno: se a pilha estiver vazia, essa sequência pop-up é válida.

Autor:
link jyd : 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();
    }
}