Durante las entrevistas, las pilas y las colas a menudo aparecen en parejas para examinar. Este artículo contiene el siguiente contenido de prueba para pila y colas:
(1) Creación de pila
(2) Creación de cola
(3) Dos pilas implementan una cola
(4) Dos colas implementan una pila
(5) Diseñe una pila con la función mínima min (), y requiere que la complejidad de tiempo de min, push, pop y todos sean O (1)
(6) Determine si las secuencias de empuje y POP de la pila son consistentes
1. Creación de pila:
A continuación, creamos una pila en forma de una lista vinculada para facilitar la expansión.
Implementación del código:
Public Class Stack {Public Node Head; Nodo = nuevo nodo (datos); } Public Node Pop () {if (curriante == NULL) {return null; Nodo que se coloca en la pila, nodo de retorno actual;} nodo de clase {int data; }} public static void main (string [] args) {pila stack = new stack (); Pop (). Data);Al ingresar a la pila, 14 o 15 líneas de código son la clave.
Efecto de ejecución:
2. Creación de cola:
Hay dos formas de creación de colas: basadas en la implementación de la estructura de matriz (cola secuencial) y basadas en la implementación de la estructura de la lista vinculada (cola de cadena).
A continuación, crearemos una cola en forma de una lista vinculada, para que la cola sea más conveniente cuando se expanda. Cuando la cola se enoe, comience desde el comienzo del cabezal del nodo.
Implementación del código:
Al ingresar a la pila, es lo mismo que agregar nodos en una lista vinculada ordinaria;
Public Class Queue {Public Node Head; } else {current.next = new Node (data); "La cola está vacía"); Data; Node Next; Public Node (int data) {this.data = data; i = 0; .out.println (queue.pop ());}}Efecto de ejecución:
3. Dos pilas implementan una cola:
Ideas:
La pila 1 se usa para almacenar elementos, Stack 2 se usa para pop elementos, negativo y negativo son positivos.
En pocas palabras, ahora coloque los datos 1, 2 y 3 en la pila uno, luego salga de la pila uno (3, 2, 1) y póngalo en la pila dos, luego los datos fuera de la pila dos (1, 2.3) Se ajusta a las reglas de la cola, es decir, negativo y negativo son positivos.
Versión completa de la implementación del código:
import java.util.stack;/*** Creado por Smyhvae en 2015/9/9.*/Public Class Colo Pila <Integer> stack2 = new Stack <> (); // pila para ejecutar operación de Doceue // Método: Agregue una operación de Enqueue a la cola public void push (int data) {stack1.push (data);}//método : Dale a la cola una operación dequeue public int pop () lanza la excepción {if (stack2.empty ()) {// antes de poner los datos en stack1 en stack2, debe asegurarse de que stack2 esté vacío (o está vacío al principio, o se han publicado los datos en Stack2), de lo contrario, el orden de desembararse se endurecerá, lo cual es fácil de olvidar mientras (! stack1.empty ()) {stack2.push (stack1.pop ()); // Abrir el Datos en Stack1 y colóquelo en Stack2 [código central]}} if (stack2.empty ()) {// Cuando Stack2 está vacío, hay dos posibilidades: 1. Al principio, dos pilas todos están vacíos. Los datos en STACK2 están terminados con una nueva excepción ("Queu está vacía"); push (1); );Preste atención al orden del código en la línea 22 y la línea 30, así como a los comentarios, y debe comprender cuidadosamente su significado.
Efecto de ejecución:
4. Dos colas implementan una pila:
Ideas:
Pon 1, 2 y 3 en la cola 1, luego deje el top 3 en la cola 1, coloque la parte inferior 2 y 3 en la cola 2 y coloque 3 de la cola 1. En este momento, la cola está vacía, y luego todo La cola 2 se queda. . . Circular a su vez.
Implementación del código:
import java.util.arraydeque; import java.util.queue;/*** Creado por Smyhvae en 2015/9/9.*/Public Class Stack {Queue <Integer> Queue1 = New Arr Aydeque <Integer> (); <integer> queue2 = new ArrayDeque <Integer> (); // Método: PISTA OPERACIÓN PUBLICA INT DATOS; {data = queue1.Poll (); Queue1.Poll ()); = nuevo stack (); stack.push (1); ));Efecto de ejecución:
5. Diseñe una pila con la función mínima min (), y requiere que la complejidad de tiempo de min, push, pop y todos sean O (1). El propósito del método MIN es: puede devolver el valor mínimo en la pila. 【Preguntas de la entrevista de WeChat】
Ideas ordinarias:
En términos generales, podemos pensar de esta manera: utilizando la variable MIN, cada vez que agregamos un elemento, se compara con el elemento MIN, para que pueda garantizar que el valor mínimo almacenado en min pueda garantizarse. Pero en este caso, habrá un problema: si el elemento más pequeño está fuera de la pila, ¿cómo puede saber cuál de los elementos restantes es el elemento más pequeño?
Ideas para mejorar:
Aquí debe agregar una pila auxiliar para intercambiar espacio por el tiempo. En la pila auxiliar, la parte superior de la pila siempre ahorra el valor más pequeño en la pila actual. Es específico: cada vez que se agrega un nuevo elemento en la pila original, se compara con el elemento superior de la pila auxiliar. El elemento es grande, luego copie el elemento superior de la pila auxiliar en la parte superior de la pila auxiliar;
Implementación completa del código:
import java.util.stack;/*** Creado por Smyhvae en 2015/9/9.*/public class Minstack {private Stack <Integer> stack = new Stack <Integer> (); nueva pila <integer> (); /En el auxiliar if (minstack.size () == 0 || data <minstack.peek ()) {minstack.push (data); Código] El método de PEEK devuelve el elemento en la parte superior de la pila}} int pop () lanza la excepción {if (stack.size () == 0) {tirar nueva excepción ("vacía en la pila"); data = stack.pop (); hueco ");} return minstack.peek ();} public static void main (string [] args) lanza excepción {minstack stack = new minstack (); stack.push (4); stack.pus h (3); stack .push (5); system.out.println (stack.min ());Efecto de ejecución:
6. Determine si las secuencias de empuje y POP de la pila son consistentes:
En pocas palabras: se sabe que un conjunto de datos 1, 2, 3, 4 y 5 se coloca en la pila en secuencia, por lo que hay muchas formas de publicarlo. ?
Por ejemplo:
datos:
1, 2, 3, 4, 5
Salida 1:
5, 4, 3, 2, 1 (correcto)
Salida 2:
4, 5, 3, 2, 1 (correcto)
Salida 3:
4, 3, 5, 1, 2 (error)
Código de versión completo:
import java.util.stack;/*** Creado por Smyhvae el 2015/9/9.
*/
Clase pública StackTest {
// Método: el orden de las matrices Data1 indica el orden de apilamiento. Ahora juzgue si la orden de apilamiento de datos2 es correcta.
Public static boolean secuenceIsPop (int [] data1, int [] data2) {
Pila <integer> stack = nueva pila <integer> ();
para (int i = 0, j = 0; i <data1.length; i ++) {
stack.push (data1 [i]);
while (stack.size ()> 0 && stack.peek () == data2 [j]) {
stack.pop ();
j ++;
}
}
return stack.size () == 0;
}
public static void main (string [] args) {
Pila <integer> stack = new Stack <Integer> ();
int [] data1 = {1, 2, 3, 4, 5};
int [] data2 = {4, 5, 3, 2, 1};
int [] data3 = {4, 5, 2, 3, 1};
System.out.println (secuseSpop (data1, data2));
System.out.println (secuseSpop (data1, data3));
}
}
El código es relativamente conciso, pero también es difícil de entender, por lo que debe entenderlo cuidadosamente.
Efecto de ejecución:
Los anteriores son preguntas clásicas de entrevistas sobre Java Stack y colas.