g0901_1000.s0946_validate_stack_sequences.Solution Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

There is a newer version: 1.38

package g0901_1000.s0946_validate_stack_sequences;

// #Medium #Array #Stack #Simulation #2022_12_26_Time_1_ms_(98.95%)_Space_42_MB_(87.24%)

import java.util.ArrayDeque;
import java.util.Deque;

/**
 * 946 - Validate Stack Sequences\.
 *
 * Medium
 *
 * Given two integer arrays `pushed` and `popped` each with distinct values, return `true` _if this could have been the result of a sequence of push and pop operations on an initially empty stack, or_ `false` _otherwise._
 *
 * **Example 1:**
 *
 * **Input:** pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
 *
 * **Output:** true
 *
 * **Explanation:** We might do the following sequence: 
 *
 * push(1), push(2), push(3), push(4), 
 *
 * pop() -> 4, 
 *
 * push(5), 
 *
 * pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
 *
 * **Example 2:**
 *
 * **Input:** pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
 *
 * **Output:** false
 *
 * **Explanation:** 1 cannot be popped before 2.
 *
 * **Constraints:**
 *
 * *   `1 <= pushed.length <= 1000`
 * *   `0 <= pushed[i] <= 1000`
 * *   All the elements of `pushed` are **unique**.
 * *   `popped.length == pushed.length`
 * *   `popped` is a permutation of `pushed`.
**/
public class Solution {
    public boolean validateStackSequences(int[] pushed, int[] popped) {
        Deque stack = new ArrayDeque<>();
        int i = 0;
        int j = 0;
        int len = pushed.length;
        while (i < len) {
            if (pushed[i] == popped[j]) {
                i++;
                j++;
            } else if (!stack.isEmpty() && stack.peek() == popped[j]) {
                stack.pop();
                j++;
            } else {
                stack.push(pushed[i++]);
            }
        }
        while (j < len) {
            if (!stack.isEmpty() && stack.peek() != popped[j++]) {
                return false;
            } else {
                stack.pop();
            }
        }
        return true;
    }
}