Título
Use apenas duas pilhas para implementar uma fila primeiro a entrar, primeiro a sair. A fila deve suportar todas as operações suportadas pela fila geral (push, pop, peek, empty):
Implemente a classe MyQueue:
void push (int x) Empurra o elemento x para o final da fila
int pop () Remove do início da fila e retorna o elemento
int peek () Retorna o elemento no início da fila
booleano vazio () Se a fila está vazio, retorna verdadeiro; caso contrário, retorna falso
Descrição:
Você só pode usar operações de pilha padrão - ou seja, apenas empurrar para cima, peek / pop de cima, tamanho e operações vazias são legais.
O idioma que você está usando pode não oferecer suporte a pilhas. Você pode usar list ou deque (fila dupla) para simular uma pilha, desde que seja uma operação de pilha padrão.
Avançado:
Você pode implementar uma fila com O (1) tempo amortizado para cada operação? Em outras palavras, a complexidade de tempo total para realizar n operações é O (n), mesmo que uma das operações possa demorar muito.
Exemplo:
Entrada:
[“MyQueue”, “push”, “push”, “peek”, “pop”, “empty”]
[[], [1], [2], [], [], []]
Saída:
[nulo, nulo, nulo, 1, 1, falso]
解释 ：
MyQueue myQueue = new MyQueue ();
myQueue.push (1); // a fila é: [1]
myQueue.push (2); // a fila é: [1, 2] (mais à esquerda é a frente da fila)
myQueue.peek (); // retorna 1
myQueue.pop (); // retorna 1, a fila é [2]
myQueue.empty (); // retorna falso
mensagem:
1 <= x <= 9
Chama push, pop, peek e empty até 100 vezes,
assumindo que todas as operações são válidas (por exemplo, uma fila vazia não chamará operações pop ou peek)
Tópicos Relacionados Projeto de Pilha
Ideias para resolução de problemas
Esta questão é relativamente simples.Você só precisa entender que a pilha tem uma natureza do primeiro a entrar, primeiro a sair.
Demonstração de código
class MyQueue {
Stack<Integer> stack1;
Stack<Integer> stack2;
/** Initialize your data structure here. */
public MyQueue() {
stack1=new Stack<>();
stack2=new Stack<>();
}
/** Push element x to the back of queue. */
public void push(int x) {
if(!stack2.empty()) {
while (!stack2.empty())
{
Integer pop = stack2.pop();
stack1.push(pop);
}
stack1.push(x);
}
else
stack1.push(x);
}
/** Removes the element from in front of queue and returns that element. */
public int pop() {
if(!stack1.empty())
{
while (!stack1.empty())
{
Integer pop = stack1.pop();
stack2.push(pop);
}
Integer res = stack2.pop();
return res;
}
else
return stack2.pop();
}
/** Get the front element. */
public int peek() {
if(!stack1.empty())
{
while (!stack1.empty())
{
Integer pop = stack1.pop();
stack2.push(pop);
}
return stack2.peek();
}
else
return stack2.peek();
}
/** Returns whether the queue is empty. */
public boolean empty() {
if(!stack1.empty())
{
return stack1.empty();
}
else
return stack2.empty();
}
}
Demonstração de efeito
A
resposta da informação foi bem-sucedida:
tempo de execução: 0 ms, derrotando 100,00% dos usuários Java.
Consumo de memória: 36,6 MB, derrotando 12,28% dos usuários Java