Título
Utilice solo dos pilas para implementar una cola de primero en entrar, primero en salir. La cola debe admitir todas las operaciones admitidas por la cola general (push, pop, peek, empty):
Implemente la clase MyQueue:
void push (int x) Empuja el elemento x hasta el final de la cola
int pop () Elimina del principio de la cola y devuelve el elemento
int peek () Devuelve el elemento al principio de la cola
booleano vacío () Si la cola está vacío, devuelve verdadero; de lo contrario, devuelve falso
Descripción:
Solo puede usar operaciones de pila estándar, es decir, solo las operaciones de empujar hacia arriba, mirar / sacar desde arriba, el tamaño y las operaciones vacías son legales.
Es posible que el idioma que está utilizando no admita pilas. Puede usar list o deque (cola de dos extremos) para simular una pila, siempre que sea una operación de pila estándar.
Avanzado:
¿Puede implementar una cola con O (1) tiempo amortizado para cada operación? En otras palabras, la complejidad de tiempo total de realizar n operaciones es O (n), incluso si una de las operaciones puede llevar mucho tiempo.
Ejemplo:
Entrada:
[“MyQueue”, “push”, “push”, “peek”, “pop”, “empty”]
[[], [1], [2], [], [], []]
Salida:
[nulo, nulo, nulo, 1, 1, falso]
解释 ：
MyQueue myQueue = new MyQueue ();
myQueue.push (1); // la cola es: [1]
myQueue.push (2); // la cola es: [1, 2] (el más a la izquierda está al frente de la cola)
myQueue.peek (); // devuelve 1
myQueue.pop (); // devuelve 1, la cola es [2]
myQueue.empty (); // falso retorno
inmediato:
1 <= x <= 9
Llamar push, pop, peek y vaciar hasta 100 veces,
asumiendo que todas las operaciones son válidas (por ejemplo, una cola vacía no llamará operaciones pop o peek)
Temas relacionados Diseño de pila
Ideas para resolver problemas
Esta pregunta es relativamente simple: solo necesita comprender que la pila tiene una naturaleza de primero en entrar, último en salir, y que el equipo tiene una naturaleza de primero en entrar, primero en salir.
Demostración 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();
}
}
Demostración de efectos
La
respuesta de información fue exitosa:
tiempo de ejecución: 0 ms, derrotando al 100,00% de los usuarios de Java
Consumo de memoria: 36,6 MB, derrotando al 12,28% de los usuarios de Java