Pila monótona: siguiente elemento más grande

496. El siguiente elemento más grande

https://leetcode.cn/problems/next-greater-element-i/submissions/

Defina un resultado de matriz del mismo tamaño que nums1 para almacenar el resultado

Si no se asigna una posición de la matriz de resultados, debe ser -1, por lo que se inicializa en -1

En el proceso de atravesar nums2, necesitamos juzgar si nums2[i] ha aparecido en nums1

Sin elementos repetidos, podemos usar el mapa para mapear

Encuentre el subíndice rápidamente según el valor, y también puede juzgar si nums2[i] ha aparecido en nums1

A continuación, analizaremos las siguientes tres situaciones, las cuales deben ser analizadas con claridad.

  1. Caso 1:

El elemento atravesado actual T[i] es más pequeño que el elemento superior T[temp.peek()]

En este momento, se cumple la pila incremental (el orden desde la cabeza de la pila hasta la parte inferior de la pila), por lo que se empuja directamente a la pila.

  1. Caso dos:

El elemento atravesado actual T[i] es igual al elemento superior T[temp.peek()]

Si son iguales, todavía se empujan directamente a la pila, porque estamos pidiendo el primer elemento a la derecha que sea más grande que nosotros, ¡no mayor o igual que!

  1. Caso tres:

El elemento atravesado actual T[i] es mayor que el elemento superior T[temp.peek()]

En este momento, si se coloca en la pila, no satisfará la pila incremental.Este es también el momento de encontrar el primer elemento a la derecha que es más grande que él mismo.

Determine si el elemento superior de la pila ha aparecido en nums1 (tenga en cuenta que los elementos de la pila son elementos de nums2) y, de ser así, comience a registrar el resultado.

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Stack<Integer> temp = new Stack<>();//单调栈,递增
        int[] res = new int[nums1.length];//记录结果集
        Arrays.fill(res,-1);//初始化-1
        HashMap<Integer,Integer> hashmap = new HashMap<>();//利用没有重复的特性
        for(int i=0;i<nums1.length;i++){
                hashmap.put(nums1[i],i);
        }
        temp.add(0);
        for(int i=1;i<nums2.length;i++){
            if(nums2[i] <= nums2[temp.peek()]){
                temp.add(i);
            }else{
                while(!temp.isEmpty() && nums2[temp.peek()] < nums2[i]){
                    if(hashmap.containsKey(nums2[temp.peek()])){
                         Integer index = hashmap.get(nums2[temp.peek()]);
                         res[index] = nums2[i];
                    }
                    temp.pop();
                }
                temp.add(i);
            }

        }
        return res;
    }
}

503. El siguiente elemento más grande 2

https://leetcode.cn/problems/next-greater-element-ii/submissions/

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        int size = nums.length;
        Stack<Integer> temp = new Stack<>();
        int[] res = new int[size];
        if(nums == null || nums.length <=1){
            return new int[]{-1};
        }
        Arrays.fill(res,-1);

        for(int i=0;i<2*size;i++){
            while(!temp.isEmpty() && nums[i%size] > nums[temp.peek()]){
                res[temp.peek()] = nums[i% size];
                    temp.pop();
            }
                temp.push(i%size);
        }
return res;
    }
}

Supongo que te gusta

Origin blog.csdn.net/weixin_56194193/article/details/129089892
Recomendado
Clasificación