Saltar navegación

20260209 ListasComoPilas - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 9 de febrero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues entonces, estábamos diciendo que como LinkedList es tan apañada para inserciones y borrados, pues LinkedList mete métodos propios suyos, que solo tiene ella, relacionados con hacer más tipos de inserciones y más tipos de borrados. 00:00:02
Porque como es su especialidad, la especialidad del LinkedList es insertar y borrar. Esa es su especialidad, es para lo que es buena. Si no, giraríamos con ArrayList para siempre. 00:00:25
entonces como la especialidad de linked list 00:00:36
es insertar y eliminar 00:00:38
porque ya sabemos 00:00:40
que lo hace ahí súper chulo 00:00:42
¿vale? eliminar 00:00:44
¡pum! punto pelota 00:00:46
insertar 00:00:49
¡pum! enlace para allá 00:00:51
y este para acá, punto pelota, ya está, como es tan buena 00:00:52
añade métodos propios relacionados 00:00:54
con eso 00:00:56
y la pregunta sería, ¿y por qué añade 00:00:57
métodos propios? pero si ya tenemos 00:01:00
add y remove con todas sus variantes 00:01:02
at first, at last, remove, remove all 00:01:04
porque añade métodos propios 00:01:07
bueno, pues para ofrecernos 00:01:09
trabajar 00:01:12
con una estructura 00:01:13
muy habitual 00:01:15
en informática de toda la vida que es la pila 00:01:17
la pila, a todo el mundo le suena 00:01:19
la pila es una estructura para almacenar 00:01:20
datos que se basa en 00:01:23
esta idea 00:01:25
¿vale? tú cuando tienes una caja 00:01:27
pues añadir a la caja 00:01:31
en principio 00:01:33
se queda como difuso, pero dices, vale, añado 00:01:35
pero ¿dónde al principio, al final, en medio 00:01:37
o cómo añado, en un orden? 00:01:39
Sacar de la caja, ya, pero sacar está como 00:01:41
muy abstracto, me falta información. ¿De dónde 00:01:43
saco? ¿Del principio, del final? 00:01:45
¿Cómo lo hago? Hay veces 00:01:47
que queremos 00:01:49
no necesitar esa información 00:01:50
complementaria, sino meter y sacar 00:01:53
y ya está. Entonces, 00:01:55
esa es la idea de la pila. 00:01:57
La pila es una estructura, una estructura 00:01:59
que se puede programar en cualquier 00:02:01
El lenguaje de programación, lógicamente, es una estructura en la cual cuando se inserta un elemento, 00:02:03
se inserta, si la pila es esto, que es un conjunto de muchas cosas, es una pila, una pila es un conjunto de cosas, una lista. 00:02:09
Pues la opción de insertar siempre va a ser en la cima. 00:02:18
Con lo cual, cuando tú insertas en una pila, no tienes que dar la información de dónde insertas. 00:02:24
Si al principio, al final, entre medias, porque en una pila, por definición, siempre que se añade algo, se añade en la cima. 00:02:29
No tienes que dar esa información, porque es la única opción en una pila, añadir en la cima. 00:02:38
Y cuando tú sacas de una pila, cuando tú sacas no tienes que decir tampoco de dónde saco, de arriba, de abajo, de la mitad, no. 00:02:44
Cuando tú dices sacar de la pila, se asume que por propia definición de este concepto, tú sacas siempre el último que metiste, ¿vale? Esto es lo que se llama una pila, por tanto se dice que tiene un comportamiento así, ¿vale? 00:02:52
El último que entró es el primero que sale. 00:03:11
Es el funcionamiento de la pila. 00:03:18
El último que llegó es el primero que sale. 00:03:20
Se llama pila porque es como funciona cuando tú apilas las cosas. 00:03:22
Cuando tú apilas las cosas, lo último que metes se queda arriba del todo, 00:03:25
con lo cual lo primero que sacas es lo último que metiste. 00:03:30
Es el efecto de apilar. 00:03:34
Por eso se llama pila, lógicamente. 00:03:36
¿Vale? 00:03:38
entonces es una estructura 00:03:39
que una vez programada 00:03:42
tú te limitas a decir 00:03:43
apila 00:03:45
que esa sería 00:03:47
lo que se llama, para unificar 00:03:49
un poco conceptos, el hacer el push 00:03:51
en la pila, hago un push 00:03:53
ahí se queda arriba 00:03:55
y desapila o saca, que esto es lo que 00:03:56
se llama 00:03:59
pues para unificar términos 00:04:00
y para entendernos todos, lo que se llama hacer un pop 00:04:03
push es 00:04:05
a la cima, elemento nuevo 00:04:07
y pop es, venga, trae 00:04:08
el pop siempre saca este 00:04:10
¿vale? 00:04:12
entonces es una estructura muy natural 00:04:15
en informática, porque muchas veces 00:04:16
reproduce exactamente lo que 00:04:18
pasa, en gestión 00:04:20
de procesos, en sistemas informáticos 00:04:22
lo habréis visto 00:04:24
¿no? cuando 00:04:26
bueno, pues la gestión de procesos 00:04:28
de un sistema operativo, ya sabéis 00:04:32
que está continuamente cambiando de proceso 00:04:34
de uno a otro, ahora 00:04:36
este, ahora el otro, ahora abres esto 00:04:37
pues se va aquí, está continuamente cambiando 00:04:39
de un proceso a otro 00:04:42
y todos esos procesos son programas 00:04:43
que están en RAM, todos 00:04:46
todos son programitas que están en RAM 00:04:48
entonces cuando un proceso se está ejecutando 00:04:51
¿qué ocurre? 00:04:54
que hay un registro que se llama en la CPU 00:04:56
un registro que se llama contador de programa 00:04:58
que es básico 00:05:00
que el contador de programa 00:05:01
es el que te dice 00:05:04
en qué dirección está 00:05:05
la sentencia que toca ejecutar 00:05:08
o que se está ejecutando, vamos 00:05:10
en qué dirección está 00:05:11
entonces, si tú estás 00:05:13
saltando de proceso todo el rato 00:05:17
el contador de programa 00:05:19
está saltando todo el rato 00:05:22
pero claro 00:05:24
no puedes perder, cuando tú saltas 00:05:26
de aquí a aquí, no puedes 00:05:28
perder en qué posición estabas 00:05:29
porque una vez que has acabado 00:05:32
con esta subrutina 00:05:33
o este subproceso, tienes que 00:05:35
volver a la que estabas 00:05:37
¿vale? que ahora estás aquí 00:05:38
y vuelves a llamar a otra subrutina 00:05:41
vale, el contador de programa salta 00:05:43
pero cuando esta subrutina ha terminado 00:05:45
tienes que volver a la que estabas 00:05:47
entonces no es tan sencillo como que 00:05:49
el contador de programa vaya saltando 00:05:51
según el sistema operativo 00:05:53
va cambiando de 00:05:55
subrutina, ahora abro esta ventana 00:05:56
ahora hago no sé qué, siempre tiene que volver 00:05:59
al punto en el que estaba cuando se 00:06:01
lanzó esa nueva acción 00:06:03
siempre tiene que volver, entonces 00:06:04
los contadores de programa 00:06:07
se tienen que guardar en algún lado 00:06:09
en algún lado tienen que guardar 00:06:11
en una colección, en algún sitio 00:06:12
los tiene que guardar el sistema operativo 00:06:14
pues el sistema operativo los guarda 00:06:16
en una pila, porque se adapta 00:06:19
exactamente a este funcionamiento 00:06:21
cuando el contador de programa 00:06:23
que está aquí, llama 00:06:25
a una, el contador de programa no, perdón 00:06:26
cuando el sistema operativo llama a una subrutina 00:06:29
este contador de programa 00:06:30
lo apila en la pila 00:06:32
y ahí se queda apilado 00:06:35
y nos vamos a la subrutina, cuando esta subrutina 00:06:36
terminó 00:06:39
se hace el pop porque entonces 00:06:39
el contador de programa que toca sacar 00:06:42
es el último que guarde 00:06:45
porque tengo que volver a la que me llamó a mí 00:06:47
cuando esta subrutina 00:06:49
terminó, vuelvo a hacer 00:06:51
el pop para sacar 00:06:53
el contador de programa 00:06:55
que llamó a esa anterior 00:06:57
entonces el último contador de programa 00:06:58
que yo llamo, el último 00:07:00
lo dejo aquí apilado 00:07:02
porque es el que tengo que devolver 00:07:06
cuando esa subrutina ha terminado, ¿vale? 00:07:08
Es el que tengo que devolver. 00:07:10
Y cuando esa ha terminado, de nuevo, 00:07:11
tendré que sacar al que me llamó a mí. 00:07:14
Entonces, según voy anidando contadores de programa, 00:07:16
según se van anidando subrutinas, 00:07:19
pues esos contadores de programa tienen que ir apilando. 00:07:21
Van entrando así y tienen que ir saliendo 00:07:23
del último en adelante, ¿vale? 00:07:25
Entonces, el sistema operativo tendrá su pila 00:07:31
de contadores de programa donde hace push y pop 00:07:33
según las subrutinas se van terminando. 00:07:35
por eso ocurre 00:07:37
cuando se anidan demasiadas llamadas 00:07:40
a sus rutinas, se anidan muchas 00:07:43
cien, mil, se anidan muchas 00:07:45
depende de la capacidad de la 00:07:47
memoria, claro, que llega un momento 00:07:49
que ¡pum! la pila 00:07:51
dice, ya no me caben tantos 00:07:53
contadores de programa, y sale ahí un 00:07:55
stack overflow tremendo 00:07:57
¿vale? 00:07:59
entonces, cuando 00:08:01
me puede salir a mí un stack overflow ¡pum! 00:08:03
se me ha ido ya la pila 00:08:06
la porra de tantos contadores de programa 00:08:07
normalmente ocurre 00:08:08
cuando tú estás haciendo un programa 00:08:10
recursivo, de los cuales no hemos 00:08:13
hecho todavía, pero en algún momento tendremos que hacer 00:08:14
alguno, en el cual un programa recursivo 00:08:16
es un programa que se llama a sí mismo 00:08:19
¿vale? que no pasa nada 00:08:20
yo tengo 00:08:22
un método 00:08:25
que hace no sé qué cosa 00:08:25
mirar por la ventana 00:08:28
entonces el método arranca 00:08:30
acércate a la ventana 00:08:32
ahora, y llama de nuevo 00:08:33
a mirar por la ventana, vale, no pasa nada 00:08:36
mirar por la ventana 00:08:38
acércate a la ventana, me acerco un poquito más 00:08:39
mirar por la ventana 00:08:42
entonces, cada llamada 00:08:44
a mirar por la ventana que viene del anterior 00:08:46
mirar por la ventana, implica 00:08:49
que se lanza una subrutina nueva 00:08:50
luego ese contador de programa 00:08:52
que me ha llamado, lo tengo que guardar 00:08:55
en la pila, entonces 00:08:56
no pasa nada, el programa este 00:08:58
recursivo, tendrá que 00:09:00
tener un id dentro que sea 00:09:03
y te has chocado con la ventana 00:09:04
ya está, no llames más a mirar por la ventana 00:09:07
porque ya te has chocado 00:09:09
entonces ahí ya no hay que meter más controles del programa 00:09:10
y empezamos a salir 00:09:12
pero alguien se puede haber confundido 00:09:14
y ese programa recursivo es 00:09:16
ese método recursivo es mirar por la ventana 00:09:18
da cuatro pasos, mirar por la ventana 00:09:21
luego vuelves a llamar 00:09:23
da cuatro pasos, mirar por la ventana 00:09:24
si alguien lo hace así 00:09:26
es que estás todo el rato 00:09:28
todo el rato acercándote 00:09:30
luego está todo el rato 00:09:32
llamando a sus rutinas, todo el rato llenando 00:09:34
esto hasta el infinito, hasta que llega un momento 00:09:36
que pum, le está cover flow 00:09:38
¿vale? claro, es que la recursión 00:09:40
no hay que plantearla así, la recursión hay que plantearla 00:09:42
de tal manera que tú te vuelves a llamar 00:09:44
a ti mismo, solo si 00:09:46
no se cumple cierta condición 00:09:48
entonces mirar por la ventana sería, da tres pasos 00:09:49
si no te has chocado 00:09:52
vuelve a mirar por la ventana, vale 00:09:54
das tres pasos, si no te has chocado 00:09:56
vuelve a mirar por la ventana 00:09:58
que de nuevo implicaría, da tres pasos 00:09:59
si no te has chocado 00:10:01
ese sería un programa recursivo bien hecho 00:10:02
voy a dar un momento en que te choques 00:10:05
ahí ya dejamos de apilar contadores 00:10:06
de programa, dejamos de apilarlos 00:10:09
y ya empezamos a sacarlos 00:10:11
¿vale? 00:10:12
según vamos terminando ya las acciones 00:10:15
y vamos volviendo ya hacia atrás 00:10:17
bueno 00:10:18
todo esto venía a cuento 00:10:20
de que la pila es una estructura muy natural 00:10:23
en la informática 00:10:25
¿vale? como ejemplo la que usa el sistema operativo 00:10:26
para guardar sus contadores de programa 00:10:29
según va cambiando de proceso. 00:10:31
Bueno, la pila sirve 00:10:33
pues eso, para apilar, desapilar de forma 00:10:35
rápida. ¿Quién es el más rápido 00:10:37
apilando, metiendo y sacando? 00:10:39
Pues la LinkedList. 00:10:41
Pues la LinkedList ofrece 00:10:43
métodos para que trabajemos 00:10:45
nosotros con una LinkedList como si fuera una pila. 00:10:47
¿Vale? 00:10:50
Por ejemplo. 00:10:51
Entonces, en resumen, 00:10:54
lo que hacen 00:10:55
en resumen 00:10:56
lo que hace meter en la primera posición 00:10:57
exacto 00:11:01
y pop te saca de la primera posición 00:11:02
vale 00:11:04
va a ser la primera posición 00:11:05
sí 00:11:09
vale, pues entonces 00:11:10
imaginaos que yo aquí para ver los métodos 00:11:12
que ofrece, entonces push y pop es la versión 00:11:15
reducida, pero luego ya 00:11:16
linked list te ofrece 00:11:19
un montón ya de variantes 00:11:21
de métodos rápidos para hacer inserciones 00:11:22
y sacados y tener que especificar 00:11:25
posición y nada, para simular 00:11:26
pilas y colas, porque la cola 00:11:28
sería otro concepto, que es 00:11:31
yo voy 00:11:33
metiendo todos en filita 00:11:34
y la cola es justo 00:11:36
al contrario de la pila, como van todos 00:11:38
en fila, el 00:11:40
primero que entró 00:11:42
es el último, es el primero 00:11:43
que sale, ¿vale? una cola 00:11:46
es lo contrario de una 00:11:48
pila, ¿vale? 00:11:50
una cola es pues 00:11:55
la cola del cajero 00:11:56
como siempre, pues estás en la cola 00:11:59
del cajero, el primero 00:12:01
que llegó a la cola del cajero 00:12:03
es el primero que se va 00:12:05
el primero que termina 00:12:07
que es justo lo contrario 00:12:08
a una pila, entonces 00:12:11
una cola tiene un comportamiento 00:12:13
no lifo, sino fifo 00:12:14
el primero que llegó 00:12:17
es el primero que termina 00:12:19
¿vale? 00:12:20
bueno, pues simulando estas ideas 00:12:23
estos conceptos, LinkedList 00:12:25
me ofrece métodos 00:12:27
que uno pues los puede mirar 00:12:28
pero vamos, tampoco tienen mayor 00:12:32
por ejemplo 00:12:34
si yo me hago aquí solamente una LinkedList 00:12:37
para mirar 00:12:39
vale, porque antes no sé si los veíais bien 00:12:40
vale, pues LinkedList 00:12:58
vale, pues LinkedList 00:13:06
lógicamente implementa 00:13:16
todos los de list, ahí no hay alternativa 00:13:18
tiene que implementarlos todos 00:13:20
y luego además 00:13:22
Añade algunos que no hemos visto en la list 00:13:24
Añade algunos 00:13:26
Como 00:13:28
Estos de aquí 00:13:30
Estos de aquí 00:13:33
Los que empiezan con P 00:13:41
¿Vale? 00:13:42
Están relacionados con simular el comportamiento 00:13:44
De una cola 00:13:47
La lifo sería la pila 00:13:47
¿Vale? 00:13:51
Entonces uno puede mirar lo que hace cada uno de ellos 00:13:52
Pues si yo hago un pick a una lista 00:13:54
Te devuelve 00:13:56
El primero de todos 00:13:59
El que está en la cabecera 00:14:01
¿Vale? 00:14:03
Entonces este es el comportamiento 00:14:05
¿Vale? Un comportamiento como si fuera una cola 00:14:07
¿Vale? 00:14:10
Este 00:14:13
Te devuelve 00:14:14
Es como el otro ¿Vale? 00:14:15
Creo que la diferencia 00:14:18
En uno 00:14:21
Y este sin embargo 00:14:22
La única diferencia es esto de aquí 00:14:26
Este pues te devuelve 00:14:32
Pero no te elimina de la lista 00:14:36
No te lo elimina 00:14:37
El último 00:14:38
Paul 00:14:41
Te devuelve y te borra 00:14:43
La cabecera 00:14:45
¿Vale? 00:14:47
Entonces 00:14:54
El tema es que si vosotros hacéis 00:14:55
Un linked list y veis estos métodos 00:14:59
De aquí, pues estos métodos 00:15:01
De aquí, el push y el pop 00:15:03
Están aquí, pues el push 00:15:05
te apila un elemento 00:15:06
en la pila representada 00:15:08
por esta lista, te dice 00:15:11
esta lista podría representar una pila 00:15:12
lógicamente, porque no, es un montón de elementos 00:15:15
pues push 00:15:17
te lo pondría en la cabecera 00:15:20
de la lista esa que tú 00:15:23
estás usando como si fuera una pila, ya está 00:15:25
pop sin embargo 00:15:27
te lo quita 00:15:29
ves, te quita 00:15:31
el elemento de esa pila 00:15:33
lo borra y te lo devuelve 00:15:34
es lo mismo 00:15:38
que remove first 00:15:41
te lo dice aquí, es exactamente lo mismo 00:15:42
que remove first 00:15:45
pero ha cambiado el nombre, es el mismo método 00:15:45
con otro nombre 00:15:48
simplemente, pues bueno, porque si tú estás 00:15:49
trabajando con esa lista, pues va una pila 00:15:52
pues puedes hacerle un pop 00:15:54
y el código queda más claro 00:15:56
es a efectos de elegibilidad de código 00:15:57
de comodidad, de que el código 00:16:00
quede como más explicativo 00:16:02
Que es lo que está pasando 00:16:04
Tú ves un pop y dices, ah, es que esto es una pila 00:16:05
A lo mejor eso tiene implicaciones 00:16:08
Ves un remove first y a lo mejor 00:16:09
Y ahí no te queda tan claro que eso 00:16:11
Esté funcionando como una pila 00:16:13
¿Vale? 00:16:14
Bueno, pues ya está 00:16:17
Y poco más añade 00:16:18
Una linked list respecto a la list 00:16:20
Añade esos métodos relacionados 00:16:24
Con trabajar como si fuera una pila 00:16:25
Que no hacen falta ninguno de ellos 00:16:27
Todos ellos los podemos simular 00:16:29
Con los genéricos de list 00:16:32
Con add, con remove 00:16:33
Pero los añade con este nombre 00:16:34
Los añade con este nombre para simular 00:16:36
El funcionamiento de colas 00:16:39
Y de pilas 00:16:41
Para que quede como el código 00:16:43
Más explicativo 00:16:45
Ya está, vale 00:16:46
Bueno y vamos a hacer una cosa 00:16:49
Como ya os habéis 00:16:58
Aburrido mucho, ahora en el cambio 00:17:03
Voy a subir unos ejercicios 00:17:05
Lo del iterador y todo eso lo vamos a ir 00:17:06
Dejando para entre medias 00:17:09
De los ejercicios 00:17:11
Ahora en el cambio lo subo y arranca y va a hacer cosas 00:17:12
¿Vale? 00:17:15
Venga, pues paramos aquí entonces 00:17:17
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
9 de febrero de 2026 - 11:10
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
17′ 20″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
681.40 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid