pilha LeetCode e prática fila

Primeiro, problema pequeno convencional

Queue 232. Stack

Uma pilha é certamente impossível de alcançar ah, por isso precisamos de uma pilha auxiliar.

classe MyQueue { 
    Stack <Integer> stack1, stack2;
    / ** inicializar sua estrutura de dados aqui. * / 
    Público MyQueue () { 
        stack1 = new Stack <Integer> (); 
        stack2 = new Stack <Integer> (); 
    } 
    
    / ** push elemento x para a parte de trás da fila. * / 
    Público  vazio push ( int x) { 
        stack1.push (x); 
    } 
    
    / ** Remove o elemento da frente da fila e devolve esse elemento. * / 
    Público  intpop () { 
        f (stack1, stack2); 
        regresso stack2.pop (); 
    } 
    
    / ** Obter o elemento frontal. * / 
    Público  int espiada () { 
        f (stack1, stack2); 
        regresso stack2.peek (); 
    } 
    
    / ** Retorna se a fila está vazia. * / 
    Público  boolean empty () {
         return stack2.empty () && stack1.empty (); 
    } 
    
    Private  vazio f (Stack <Integer> s1, Stack <Integer> s2) {
        se (s2.empty ()) {
            enquanto (! S1.empty ()) {
                Inteiros de temp= S1.pop (); 
                s2.push (temp); 
            } 
       } 
    } 
}

Implementado com fila de 225. Stack

Quando a equipe de mais de um elemento, cada um vindo, nós colocamos antes do elemento n-1 a partir da cauda novamente na ingestão

classe MyStack { 

    privada Queue <Integer> fila; 

    pública MyStack () { 
        fila = new LinkedList <> (); 
    } 

    Pública  vazio push ( int x) { 
        queue.add (x); 
        int cnt = queue.size ();
        enquanto (cnt--> 1 ) { 
            queue.add (queue.poll ()); 
        } 
    } 

    Público  int pop () {
         return queue.remove (); 
    } 

    Público  int top () {
         returnqueue.peek (); 
    } 

    Pública  boolean empty () {
         retornar queue.isEmpty (); 
    } 
}

155. A pilha mínimo

Usando um rastreamento de pilha auxiliar do atual pilha menor elemento, deve sempre prestar atenção para min igual ao elemento do topo da pilha auxiliar da pilha para assegurar a correcta.

classe MinStack {
     privado  int min = Integer.MAX_VALUE; 
    LinkedList <Integer> dataStack; 
    LinkedList <Integer> minStack;
    / ** inicializar sua estrutura de dados aqui. * / 
    Público MinStack () { 
        dataStack = new LinkedList <> (); 
        minStack = new LinkedList <> (); 
    } 
    
    Pública  vazio push ( int x) { 
        dataStack.add (x); 
        min = Math.min (min, x);
        minStack.add (minutos); 
    } 
    
    Pública  vazio Pop () { 
        dataStack.pollLast (); 
        minStack.pollLast (); 
        min = minStack.isEmpty ()? Integer.MAX_VALUE: minStack.peekLast (); 
    } 
    
    Pública  int top () {
         retornar dataStack.peekLast (); 
    } 
    
    Pública  int getMin () {
         retornar minStack.peekLast (); 
    } 
}

 Em segundo lugar, o problema de suportes correspondentes

 20. suportes eficazes

classe Solution {
     pública  boolean isValid (String s) {
         se (s == "") retornar  verdadeiro ;
        Se (s == nulo || s.length ()% 2 == 1) retorno  falso ; 
        LinkedList <caracteres> pilha = new LinkedList <> ();
        para ( int i = 0; i <s.length (); i ++ ) {
             se (! stack.isEmpty () || f (stack.peekLast (), s.charAt (i))) { 
                stack.add (s .charAt (i)); 
                continuar ; 
            } 
            se(f (stack.peekLast (), s.charAt (i))) { 
                stack.pollLast (); 
            } 
        } 
        Retornar stack.isEmpty (); 
    } 
    Private  boolean f ( caractere c1, carvão c2) {
         se (c1 == '(' && c2 == ')' )
             retornar  verdadeiro ;
        outra  se (c1 == '[' && c2 == ']' )
             retornar  verdadeiro ;
        outra  se (c1 == '{' && c2 == '}' )
             retornar  verdadeiro ;
          
    } 
}

decodificação 394. corda

Dificuldade do problema reside na forma como queremos empurrar a pilha para gerar seqüência de respostas.

Receber personagem com um ponteiro, um ponteiro com receptor digital adicional, quando um colchete esquerdo encontra os personagens pilha e números, respectivamente, quando confrontados com um parêntese direito, first-out números pilha dobrou, dentro da concatenação puxar.

classe Solution {
     pública de Cordas decodeString (String s) {
         se (s == nulo ) de retorno  nulo ;
        se (s.length () == 0) return "" ; 
        LinkedList <StringBuilder> q = new LinkedList <> (); 
        LinkedList <Integer> data = new LinkedList <> (); 
        StringBuilder ans = novo StringBuilder (); 
        StringBuilder núm = novo StringBuilder ();
        para ( carvãoc: s.toCharArray ()) {
             se (c> = '0' && c <= '9' ) num.append (c);
            outra  se (c> = 'a' && c <= 'z' ) ans.append (c);
            outra  se (c> = 'A' && c <= 'Z' ) ans.append (c);
            outra  se (c == '[' ) { 
                data.add (Integer.valueOf ( new String (num))); 
                Num = novo StringBuilder (); 
                q.add (ANS); 
                ans = novo StringBuilder (); int n = data.pollLast (); 
                Temp StringBuilder = novo StringBuilder (ANS);
                enquanto (-N> 0 ) { 
                    ans.append (temp); 
                } 
                Ans = q.pollLast () Anexar (ANS).; 
            } 
        } 
        Retornar  nova String (ANS); 
    } 
}

 Em terceiro lugar, o primeiro de uma série de elementos deste grande ou pequeno do que olhar ao redor

a água da chuva leetcod