Saltar navegación

20260203 Colecciones_5_enlazada - 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 7 de febrero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues habéis hecho este método 00:00:02
Ay, que listos sois, que todos sabéis 00:00:05
Vale, a ver 00:00:10
¿Cuántos habéis hecho este método? 00:00:17
Levantad la manita 00:00:22
¿Tres solo? 00:00:23
¿Cuatro? 00:00:26
Vale, ¿qué habéis hecho? 00:00:28
vale, esa es la clave, ¿no? 00:00:32
un contador, ya está, pues eso es lo que habréis 00:00:40
hecho 00:00:42
un contador 00:00:43
porque aquí hay que contar y cuando hay que contar 00:00:46
ponemos un contador igual a cero 00:00:48
y ahora nuestra variable 00:00:50
aux, esto de aquí 00:00:52
y ahora, la sentencia clave 00:00:53
está clara, es esta 00:01:05
aux igual a aux punto 00:01:06
siguiente, cada vez 00:01:09
Cada vez 00:01:12
Que avancemos 00:01:13
Cada vez que avancemos 00:01:15
Incrementamos un contador 00:01:18
Cada vez que avancemos 00:01:19
Y ahora 00:01:23
¿Cuántas veces tenemos que avanzar? 00:01:23
Antes la avanzábamos tantas veces como me decía posición 00:01:25
Ahora la tengo que avanzar 00:01:28
Hasta el final 00:01:30
Entonces ahora la tengo que avanzar 00:01:31
Mientras aux 00:01:33
Sea distinta de null 00:01:35
Mientras no haya llegado 00:01:37
Al final, avánzamela 00:01:40
¿Vale? Mientras no haya llegado al final 00:01:41
Avanzala 00:01:45
Cuando hayas llegado al final 00:01:46
Ya no hay más que avanzar 00:01:48
Ya me has contado todas las posiciones 00:01:50
Pues la devuelves 00:01:51
¿Vale? 00:01:54
Entonces ahora ya sí 00:02:03
Ahora ya sí 00:02:04
Podríamos recorrerlo 00:02:07
Con el for 00:02:08
Que es la idea 00:02:10
¿Vale? Recorrerlo con el for 00:02:11
Esto ya nos funcionaría 00:02:15
Bueno pues 00:02:17
tenemos una estructura muy 00:02:23
cómoda, que uno la puede 00:02:25
distribuir, la mete en un jar y la distribuye 00:02:27
y ahora ya cualquiera 00:02:30
la puede usar para meter cadenas de forma 00:02:31
cómoda y consultar, ni array 00:02:33
que se rompe y hay que hacerlo 00:02:36
ni nada, me hago mi array linked list 00:02:37
inserto según me vaya 00:02:40
haciendo falta y recorro 00:02:41
¿vale? a ver 00:02:44
le faltan funcionalidades 00:02:45
vamos a dejar planteada la del remove 00:02:47
para que la hagáis 00:02:49
la del remove 00:02:51
Porque claro, yo he hecho una estructura en la cual puedo insertar en la lista, solo al principio, eso sí, podríais hacer la variante e insertar al final, solo al principio, puedo recuperar por posición y ya está, no puedo hacer más que eso, insertar y recuperar lo que hay en una posición. 00:02:53
Pero bueno, me gustaría también quitar cosas. Lo que hacemos con los contenedores de cosas es meter cosas, consultar lo que hay por posición o por clave, si es un diccionario, pero si es otra historia, y sacar alguna. 00:03:11
vale 00:03:29
bueno pues 00:03:30
como haríamos aquí un método remove 00:03:32
pues tendríamos que 00:03:34
incorporar algo parecido 00:03:36
a esto por ejemplo 00:03:39
remove 00:03:40
int por posición 00:03:42
y ahora 00:03:44
vemos aquí la pista en la pizarra 00:03:54
para que lo hagáis este ya vosotros 00:03:56
vale 00:03:58
aquí 00:04:09
si lo utilizamos esta lista 00:04:10
¿cuál es la operación que tenemos que hacer 00:04:21
para eliminar este de aquí, por ejemplo 00:04:24
para eliminar a este pobre de aquí 00:04:27
el de posición 1 en este caso 00:04:30
pues la única sentencia que hay que hacer 00:04:33
esto es más fácil que el array, que ya hemos visto que había que hacer otro array 00:04:36
con una menos, copiar, pegar, aquí es tan fácil como 00:04:39
a esta de aquí 00:04:42
asignarle 00:04:44
su siguiente 00:04:46
y punto pelota 00:04:48
¿vale? a esta 00:04:50
asignarle su siguiente 00:04:52
entonces he puenteado a este 00:04:54
este se ha quedado sin referencia 00:04:56
ha perdido la que tenía 00:04:59
se ha quedado sin referencia 00:05:00
y el recolector de basura en algún momento 00:05:02
lo tirará a la basura 00:05:04
esta es la que hay que hacer 00:05:05
entonces si yo tengo 00:05:08
un puntero aux, si yo tuviera un puntero aux 00:05:10
que apuntara a este 00:05:12
Pues el borrado sería precisamente hacer aux.siguiente, aux.siguiente, igual aux.siguiente.siguiente. 00:05:13
Es decir, esta sería la sentencia de borrado. 00:05:35
Siempre y cuando aux apunte al anterior al que yo quiero borrar. 00:05:40
si quiero borrar este 00:05:45
aux tiene que apuntar 00:05:47
al anterior al que quiero borrar 00:05:50
una vez que consiga 00:05:51
que aux apunte al anterior 00:05:54
al que quiero borrar 00:05:56
hago esta sentencia, aux.siguiente 00:05:57
que es este, por favor apúntame 00:06:00
aux.siguiente, el punto siguiente 00:06:02
que es este 00:06:03
entonces lo que tengo que hacer en el remove es 00:06:04
un bucle, primero hacerme mi auxiliar 00:06:07
por supuesto 00:06:10
un bucle que va avanzando aux 00:06:10
hasta que llegue 00:06:13
a una posición menos 00:06:15
que el que quiero borrar. 00:06:17
Un bucle, un contador 00:06:19
que en lugar de posición 00:06:21
se ejecute posición menos una vez. 00:06:22
Y una vez que ya ha llegado 00:06:25
me hace esta sentencia con aus 00:06:27
y se acabó. 00:06:29
Y ese sería el remove. 00:06:31
Si hacemos el remove 00:06:33
y luego volvéis a recorrer 00:06:34
con el get y el for 00:06:35
pues veréis que efectivamente 00:06:37
se ha eliminado. 00:06:38
¿Vale? 00:06:40
Entonces, eliminar de una lista enlazada 00:06:41
esta línea 00:06:44
eliminar un array es mucho más 00:06:47
entonces computacionalmente 00:06:49
es más costoso, son mucho más ciclos 00:06:52
de memoria, trabajar con 00:06:54
un array para eliminar e insertar que 00:06:56
trabajar con una lista enlazada 00:06:58
¿vale? y si quisierais 00:06:59
hacer en la lista, va a haber una lista súper 00:07:14
completa, añadir al 00:07:16
final, el remove está claro ¿no? 00:07:18
un aux, aux que 00:07:20
avance hasta pararse al 00:07:22
anterior a la posición que quiero 00:07:24
vamos a un for que lo va avanzando 00:07:25
y luego esta sentencia, se acabó 00:07:28
ese sería el remove 00:07:30
que queréis hacer el add 00:07:31
sin más, añadir al final, no añadir al principio 00:07:33
que parece raro, ¿no? 00:07:36
normalmente cuando uno añade a una colección 00:07:37
a una lista, añade al final 00:07:40
pues si quisierais 00:07:41
hacer el método, que lo vamos a dejar ahí 00:07:44
escrito, para que lo hagáis 00:07:46
de añadir al final 00:07:48
¿qué habría que hacer en el añadir al final? 00:07:49
pues tendríamos que 00:07:54
crear el nuevo nodo, sí o sí, por supuesto 00:07:58
crear el nuevo nodo, con el dato 00:08:01
que me han dado nuevo 00:08:03
inicialmente, siguiente 00:08:04
anul, ahora este 00:08:07
nuevo nodo, lo tengo que hacer 00:08:09
colgar de aquí 00:08:11
no insertar aquí 00:08:12
bueno, pues no pasa nada, me hago yo 00:08:15
un aux, que avance hasta el 00:08:17
final, hasta 00:08:19
este, y cuando ya lo tengo 00:08:21
me hago, aux 00:08:23
punto siguiente igual al nodo nuevo 00:08:25
al nodo nuevo que acabo de hacer 00:08:27
con lo cual este siguiente 00:08:29
empezará a apuntar al nodo nuevo 00:08:31
¿vale? 00:08:33
entonces repito 00:08:36
¿qué habremos tenido que hacer para añadir al final? 00:08:37
una variable 00:08:40
aux que va avanzando con la 00:08:41
sentencia de avance, aux igual aux punto siguiente 00:08:43
va avanzando hasta que 00:08:45
se quede apuntando al último 00:08:47
no hasta que se quede apuntando 00:08:49
al último, sino al último 00:08:51
al último 00:08:52
una vez que está apuntando al último 00:08:53
aux.siguiente 00:08:56
igual al nodo nuevo, y ya está 00:08:58
con lo cual aux.siguiente 00:09:00
se quedará apuntando al nodo nuevo 00:09:03
con eso podría hacer 00:09:04
añadir al final 00:09:06
¿y el parámetro que pasa por la posición o el dato? 00:09:07
el parámetro o el dato 00:09:14
el dato, el dato, ¿vale? 00:09:15
entonces, la cabecera del este 00:09:18
sería 00:09:20
entonces este método 00:09:21
pues se queda ahí 00:09:37
para que lo hagáis 00:09:38
¿cuáles dos más 00:09:40
hemos mencionado? 00:09:43
bueno, hemos mencionado uno más, el de añadir 00:09:45
al final, pues public 00:09:47
void add 00:09:51
add sin más 00:09:53
un dato 00:09:55
add last, añádeme 00:09:57
add first, perdón 00:10:04
este sería el añadir por defecto cuando tú ya 00:10:05
es una lista, añades al final. 00:10:08
Hemos hecho añade al principio. 00:10:10
Ahora queremos añadir al final. 00:10:12
Pues venga. 00:10:16
Una cosa es añadir al principio. 00:10:20
A ver, en una lista las cosas tienen orden. 00:10:21
Luego no es igual estar aquí que estar aquí. 00:10:24
Ya tienen posición. 00:10:26
En esta lista no da igual el orden, ¿no? 00:10:27
Yo he dicho que da igual el orden. 00:10:29
Yo he dicho que si me hago mi método addFirst, 00:10:31
tal y como lo he hecho, que es una versión sencilla, 00:10:33
me lo mete al principio. 00:10:35
entonces tú puedes 00:10:36
querer añadir en la lista 00:10:41
puedes querer colocar al final o puedes 00:10:43
querer insertar por el principio, te da 00:10:45
las dos opciones, tú colocas 00:10:47
como quieras, venga pues ahora 00:10:49
que tenéis el cerebro caliente 00:10:52
y el corazón frío 00:10:53
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:
7 de febrero de 2026 - 18:44
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
10′ 57″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
261.62 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid