LeetCode pila y la práctica de colas

En primer lugar, pequeño problema convencional

232. cola de la pila

Una pila es ciertamente imposible de conseguir ah, por lo que necesitamos una pila auxiliar.

clase MyQueue {
    Pila <Integer> STACK1, STACK2;
    / ** inicializar la estructura de datos aquí. * / 
    Público MyQueue () {
        STACK1 = nuevo Stack <Integer> ();
        STACK2 = nuevo Stack <Integer> ();
    }
    
    / ** elemento de empuje X a la parte posterior de la cola. * / 
    Público  sin efecto de empuje ( int x) {
        stack1.push (x);
    }
    
    / ** elimina el elemento desde el frente de cola y devuelve dicho elemento. * / 
    Pública  int pop () {
        f (STACK1, STACK2);
        volver stack2.pop ();
    }
    
    / ** Obtener el elemento frontal. * / 
    Pública  int peek () {
        f (STACK1, STACK2);
        volver stack2.peek ();
    }
    
    / ** Indica si la cola está vacía. * / 
    Pública  booleano vacía () {
         retorno stack2.empty () && stack1.empty ();
    }
    
    privada  vacío f (Pila <Integer> s1, Montón <Integer> s2) {
        si (s2.empty ()) {
            tiempo (! s1.empty ()) {
                Integer temp = s1.pop ();
                s2.push (temp);
            }
       }
    }
}

Implementado con cola 225. Pila

Cuando el equipo de más de un elemento, cada uno que viene, ponemos antes del elemento n-1 de la cola de nuevo en la ingesta

clase MyStack {

    privada cola <Integer> cola;

    Pública MyStack () {
        cola = nuevo LinkedList <> ();
    }

    pública  sin efecto de empuje ( int x) {
        queue.add (x);
        int cnt = queue.size ();
        mientras que (cnt--> 1 ) {
            queue.add (queue.poll ());
        }
    }

    pública  int pop () {
         retorno queue.remove ();
    }

    pública  int superior () {
         retorno queue.peek ();
    }

    pública  booleano vacía () {
         volver queue.isEmpty ();
    }
}

155. El circuito de espera mínimo

El uso de un seguimiento de la pila auxiliar de la pila actual elemento más pequeño, siempre se debe prestar atención a min igual al elemento superior de la pila auxiliar de la pila para asegurar la correcta.

clase MinStack {
     privado  int min = Integer.MAX_VALUE;
    LinkedList <Integer> dataStack;
    LinkedList <Integer> minStack;
    / ** inicializar su estructura de datos aquí. * / 
    Público MinStack () {
        dataStack = nuevo LinkedList <> ();
        minStack = nuevo LinkedList <> ();
    }
    
    pública  sin efecto de empuje ( int x) {
        dataStack.add (x);
        min = Math.min (min, x);
        minStack.add (minutos);
    }
    
    pública  vacío pop () {
        dataStack.pollLast ();
        minStack.pollLast ();
        min = minStack.isEmpty ()? Integer.MAX_VALUE: minStack.peekLast ();
    }
    
    pública  int superior () {
         volver dataStack.peekLast ();
    }
    
    pública  int getMin () {
         volver minStack.peekLast ();
    }
}

 En segundo lugar, el problema de los soportes coincidentes

 20. soportes eficaces

clase de soluciones {
     pública  booleano isValid (String s) {
         si (s == "") regresan  verdadera ;
        si (s == nula || s.length ()% 2 == 1) de retorno  falsa ;
        LinkedList <caracteres> pila = nuevo LinkedList <> ();
        para ( int i = 0; i <s.length (); i ++ ) {
             si (! stack.isEmpty () || f (stack.peekLast (), s.charAt (i))) {
                stack.add (s.charAt (i));
                continuar ;
            }
            si (f (stack.peekLast (), s.charAt (i))) {
                stack.pollLast ();
            }
        }
        volver stack.isEmpty ();
    }
    privado  boolean f ( Char c1, Char c2) {
         si (c1 == '(' && c2 == ')' )
             volver  verdadero ;
        otra cosa  si (c1 == '[' && c2 == ']' )
             volver  verdadera ;
        otra cosa  si (c1 == '{' && c2 == '}' )
             devolver  cierto ;
        otra cosa  retorno  falsa ;
    }
}

decodificación 394. cuerdas

Dificultad del problema radica en la forma en que queremos empujar la pila para generar cadena de respuestas.

Recibir personaje con un puntero, un puntero con receptor digital adicional, cuando un corchete izquierdo se encuentra con los caracteres y números de pila, respectivamente, cuando se enfrentan a un paréntesis derecho, primero en salir los números pila se duplicaron, dentro de la concatenación de cadenas de tracción.

clase de soluciones {
     público Cadena decodeString (String s) {
         si (s == nula ) de retorno  nula ;
        si (s.length () == 0) retorno "" ;
        LinkedList <StringBuilder> q = nuevo LinkedList <> ();
        LinkedList <Integer> data = nuevo LinkedList <> ();
        StringBuilder ans = nuevo StringBuilder ();
        Num StringBuilder = nuevo StringBuilder ();
        para ( Char c: s.toCharArray ()) {
             si (c> = '0' && c <= '9' ) num.append (c);
            más  si (c> = 'a' && c <= 'z' ) ans.append (c);
            más  si (c> = 'A' && c <= 'Z' ) ans.append (c);
            más  si (c == '[' ) {
                data.add (Integer.valueOf ( nuevo String (num)));
                num = nuevo StringBuilder ();
                q.add (ans);
                ans = nuevo StringBuilder ();
            } Demás  si (c == ']' ) {
                 int n = data.pollLast ();
                Temp StringBuilder = nuevo StringBuilder (ans);
                mientras que (-N> 0 ) {
                    ans.append (temp);
                }
                año = q.pollLast append () (años).
            }
        }
        volver  nuevos de Cuerda (ans);
    }
}

 En tercer lugar, el primero de una serie de elementos de este grande o pequeño que mirar a su alrededor

el agua de lluvia leetcod