Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 26-02-24 - 2 - 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 26 de febrero de 2024 por Raquel G.

8 visualizaciones

Más información Transcripción

Descargar la transcripción

cuando queramos ya una lista concreta 00:00:00
para guardar datos, instanciaremos 00:00:03
un objeto de estos, una lista enlazada 00:00:04
lo que instanciaremos 00:00:07
igual que cuando queríamos guardar datos en un array 00:00:08
instanciamos un array 00:00:11
pues aquí instanciaremos 00:00:13
un objeto de estos para guardar datos 00:00:15
vale, este objeto ya hemos 00:00:17
dicho antes, ¿por qué se va a caracterizar 00:00:19
este objeto? se caracteriza 00:00:21
única y exclusivamente por la dirección 00:00:23
del primer elemento, nada más, por la dirección del 00:00:25
primero 00:00:27
esto es una lista enlazada, se caracteriza por la dirección 00:00:27
del primero, vale, pues la dirección del primero 00:00:31
¿de qué tipo es? pues de esta clase 00:00:34
que tendremos que programar 00:00:39
vale, entonces en principio esto es una propiedad 00:00:41
interna 00:00:45
privada del objeto lista 00:00:46
una propiedad privada que nadie tiene por qué conocer 00:00:49
la dirección inicial de la lista nadie tiene por qué conocerla 00:00:53
vale 00:00:56
pues nada 00:01:00
lo que pasa es que claro 00:01:02
tendremos que crear la clase 00:01:04
nodo para que cuanto antes nos quite 00:01:06
este error de compilación 00:01:08
bueno pues entonces esta lista enlazada 00:01:09
tenemos que decidir 00:01:17
que tipo de datos va a guardar 00:01:18
va a guardar números, va a guardar 00:01:21
cadenas, que va a guardar 00:01:23
bueno vamos a hacer un ejemplo de lista enlazada 00:01:24
para guardar cadenas 00:01:27
que es el que hemos dicho en la pizarra y ya está 00:01:29
luego tendremos que ver como generalizarlo 00:01:31
claro, pero para guardar cadenas hay que elegir 00:01:33
qué tipo de dato quieres que guarde 00:01:35
pues venga, cadenas, igual que cuando 00:01:36
instanciamos un array, elegimos 00:01:39
qué tipo de dato queremos que guarde 00:01:41
vale, pues la clase 00:01:46
esta será la clase a la que pertenecen 00:01:47
cada uno de los objetos 00:01:50
que están dados de la mano en mi lista 00:01:51
cada uno de ellos, y ya hemos dicho 00:01:53
que tendrán dos campos 00:01:56
el dato en sí 00:01:57
y la dirección del siguiente 00:01:59
que la tiene que llevar ahí 00:02:01
acoplada de la mano la dirección del siguiente 00:02:04
¿Vale? 00:02:06
Entonces 00:02:12
Para que no se complique mucho el código 00:02:12
Como las dos van juntitas 00:02:15
En el mismo paquete 00:02:17
Y se van a estar usando la una a la otra 00:02:18
Pues no voy a poner privado 00:02:20
Para que lista enlazada 00:02:23
Pueda usar los atributos 00:02:25
De nodo sin get y set 00:02:27
¿Vale? Los dos como en pack hacen una estructura 00:02:28
Esto no es que sea una entidad 00:02:31
No estoy haciendo yo una aplicación 00:02:32
Entonces así más común 00:02:34
lo que sí que vamos a hacer va a ser un constructor con parámetros 00:02:36
que eso sí que siempre es muy cómodo para instanciar 00:02:40
un nodo, vale 00:02:43
entonces, punto dato 00:02:44
igual a dato 00:03:03
punto siguiente, igual a 00:03:05
vale, tiene el constructor y repito, no le pongo get y set 00:03:11
porque no le he puesto el privado para que lista enlazada pueda acceder 00:03:18
directamente y puedan trabajar los dos en pack 00:03:22
más cómodamente 00:03:24
bueno, pues el nodo es esto 00:03:25
la clase nodo es esta, la clase nodo es la que 00:03:27
pertenece a cada uno de los nodos que tienen 00:03:30
sus dos partes, dato y siguiente 00:03:32
y ya está, con su constructor 00:03:34
cuando hago un constructor con parámetros 00:03:36
inhabilito 00:03:38
el vacío sin parámetros 00:03:40
entonces eso puede hacer 00:03:41
limita un poco la funcionalidad 00:03:44
porque si yo quiero usar alguna vez el sin parámetros 00:03:48
si he creado 00:03:50
este, ya sabéis que este entonces 00:03:52
o lo pongo específicamente o ya no existe 00:03:53
bueno, lo ponemos específicamente 00:03:56
para poder usarlo si es que queremos 00:03:58
es de lista enlazada 00:03:59
vale, y ahora 00:04:00
cuando nosotros tengamos un main 00:04:03
a ver, yo voy a hacer 00:04:05
un paquete aparte con un main para ver 00:04:08
qué es lo que esperamos de estos objetos 00:04:09
qué es lo que esperamos 00:04:11
esperamos que guarden datos, claro 00:04:12
entonces me voy a hacer yo el paquete main 00:04:14
con una clase 00:04:18
main 00:04:25
vale 00:04:27
pues para que hemos hecho estas dos clases 00:04:34
que es lo que esperamos de ellas 00:04:37
pues esperamos instanciar 00:04:38
un objeto lista enlazada 00:04:40
esperamos 00:04:42
instanciarlo 00:04:45
lo que queremos es simular este comportamiento 00:04:46
que yo me hago 00:04:58
mi objeto lista enlazada 00:05:00
como si me hiciera una array 00:05:02
lista, ah es que he puesto enlazado 00:05:04
vale, enlazada 00:05:12
ahí 00:05:14
yo lo que espero 00:05:17
de esto que estoy haciendo es 00:05:19
crearme un objeto de estos 00:05:20
como me creaba un array 00:05:22
y ahora con este objeto 00:05:24
lo que a mi me gustaría es poder usarlo para 00:05:26
meter string 00:05:29
dentro de ellos, por ejemplo así 00:05:31
esto, me gustaría poder hacer esto 00:05:32
que ahora quiero meter otra cadena 00:05:36
más en mi lista 00:05:38
pues mira, me gustaría poder 00:05:39
hacer esto y ahora ponerle otra cadena 00:05:42
que ahora quiero recuperar 00:05:44
elemento que está en la posición 0 00:05:48
de esta lista, por ejemplo 00:05:50
pues me encantaría poder hacer esto 00:05:52
lista.get y pasarle yo la posición 00:05:55
por ejemplo, un método get 00:05:57
que me recupera el elemento de posición 0 00:06:01
también me encantaría poder hacer esto 00:06:03
si yo tengo la lista 00:06:06
poder borrar 00:06:07
el elemento que está en la posición 1 00:06:09
por ejemplo, me encantaría poder hacer esto 00:06:11
decirle, oye, bórrame el que está en la posición 1 00:06:14
estaría estupendo 00:06:16
esto es lo que nosotros pretendemos 00:06:17
cuando hacemos esta clase 00:06:21
pretendemos tener ahí un objeto 00:06:22
que yo pueda usar para guardar 00:06:25
cosas en él, para recuperarlas 00:06:27
por posición 00:06:29
para eliminarlas por posición 00:06:30
y muchas otras que se me puedan ocurrir 00:06:32
aquí he puesto tres básicas 00:06:35
insertar dato 00:06:37
recuperar por posición 00:06:40
borrar por posición 00:06:42
y si yo tuviera esto, esto es mucho más cómodo 00:06:43
que un array 00:06:46
esto sería mucho más cómodo que un array 00:06:46
si quisiéramos 00:06:49
estas cadenas en un array y quisiéramos 00:06:51
recuperar del array y eliminar 00:06:53
pues meter en el array 00:06:55
ya hemos visto que no es tan fácil, meter en el array 00:06:57
cada vez que hemos tenido que meter 00:06:59
hemos tenido que hacer una adicional, copiar 00:07:00
pegar, etcétera, si yo pudiera 00:07:03
hacer esto, mira que fácil 00:07:05
añado y ya está y que la lista vaya creciendo 00:07:06
en el caso de 00:07:09
recuperar por posición, el array eso sí que era sencillo 00:07:11
el array poníamos corchetes 0 00:07:13
y se acabó, eso sí, ahí no vamos a ganar nada 00:07:15
eliminar 00:07:17
pues mira que estupendo, si yo tuviera 00:07:19
un método que le doy la posición y me lo quita de la lista 00:07:21
genial 00:07:23
en el array teníamos que hacer un montón de cosas 00:07:24
para eliminar, pues esto es lo que queremos 00:07:27
simular, un objeto 00:07:29
de esta clase que yo me estoy haciendo 00:07:31
al que puedo meter datos 00:07:33
puedo consultarlos 00:07:35
por posición, recuperarlos, borrarlos 00:07:37
lo que quiera, eso es lo que queremos simular 00:07:39
bueno, pues que es lo que tendremos que hacer 00:07:41
entonces? Pues meter estos 00:07:43
métodos, add, get, remove 00:07:45
estos métodos, meterlos aquí 00:07:47
programarlos yo 00:07:48
programarlos y ya está 00:07:51
la estructura ya la tenemos 00:07:52
cada objeto de la lista va a tener 00:07:54
estos campos 00:07:57
y la lista se caracteriza por 00:07:58
su inicio y por nada más, no le hace 00:08:01
falta nada más para caracterizarse su inicio 00:08:03
¿ahora qué nos falta? 00:08:05
pues hacer los métodos, vamos a hacer los métodos 00:08:07
que me han dicho, pues venga 00:08:09
¿cuál me gustaría hacer? el de añadir 00:08:11
pues venga, vamos a hacer un método de añadir 00:08:13
aquí 00:08:17
si yo lo quiero usar desde fuera 00:08:20
de la clase 00:08:22
que querré, porque esta es una 00:08:25
estructura que yo estoy haciendo para usar luego 00:08:26
para guardar datos de donde quiera 00:08:28
pues hombre, este método debería ser público 00:08:29
vale, y este 00:08:32
método de añadir 00:08:34
¿qué le tengo que pasar yo? 00:08:36
pues un dato del tipo 00:08:38
de los que tú vas a guardar en tu lista 00:08:40
pues en nuestro caso, como estamos trabajando 00:08:42
con string 00:08:44
pues este es el método que queremos programar 00:08:45
vale 00:08:49
pues entonces 00:08:52
ahí que tenemos que hacer 00:08:54
pues lo que tenemos que hacer aquí 00:08:56
tenemos nuestra lista 00:09:00
en principio nuestra lista es esto 00:09:07
tenemos aquí el inicio 00:09:10
este 00:09:12
el inicio, bueno, no se ve mucho 00:09:13
pero da igual 00:09:19
inicio, apunta 00:09:19
En el caso genérico 00:09:23
Pues aquí tenemos 00:09:26
Esto 00:09:27
Este a su vez 00:09:29
Apunta 00:09:31
A este 00:09:34
Y este a su vez 00:09:37
Este ya apunta 00:09:42
A nulo 00:09:48
Vale 00:09:57
Esta es la lista genérica 00:09:58
Vale, ¿qué queremos hacer? 00:10:05
Cuando añadimos 00:10:08
Pues lo que vamos a tener que hacer va a ser 00:10:09
crear un nodo nuevo, es obligatorio 00:10:11
habrá que crear un nodo nuevo 00:10:14
donde en el 00:10:15
dato le pondremos 00:10:20
lo que me han pasado, esto es lo primero que habrá 00:10:21
que hacer, crear un nodo nuevo sí o sí 00:10:23
es lo primero que habrá que hacer en el añadir 00:10:25
pues venga, vamos a hacer eso primero, sí o sí 00:10:27
vamos a crear el nodo nuevo 00:10:29
este es el nodo nuevo 00:10:31
ala, eso es lo primero 00:10:33
que ya hemos hecho, crear mi 00:10:38
nodo nuevo que tengo que meter en la lista 00:10:40
tengo que meterla, vale 00:10:42
crear mi nodo nuevo 00:10:44
vale 00:10:45
ahora, a ese nodo 00:10:46
le vamos a poner como dato 00:10:49
esto que me han pasado aquí 00:10:52
eso está claro, ¿no? 00:10:56
silencio los de atrás 00:11:02
este nodo nuevo 00:11:03
tendré que pasarle yo en su campo 00:11:05
dato, en su campo dato 00:11:07
que es este de arriba, porque cada 00:11:09
cada nodo 00:11:11
recordad que tiene dos campos 00:11:13
el campo dato 00:11:15
Y el campo 00:11:17
Siguiente 00:11:20
¿Vale? Tiene los dos 00:11:26
El campo dato y siguiente 00:11:28
Pues al campo dato 00:11:30
Y este nodo se llama 00:11:32
Esto que hemos hecho aquí 00:11:33
Este es el 00:11:35
El nodo que acabo de hacer 00:11:39
El objeto nodo que acabo de hacer 00:11:42
¿Vale? Este 00:11:44
Moisés 00:11:46
¿Te callas o te corto la cabeza? 00:11:48
Bueno 00:11:51
No sé si es lo que más 00:11:52
lo que más te costaría prescindir 00:11:54
a ver 00:11:56
este es el objeto 00:11:58
que acabamos de crear 00:12:02
¿vale? 00:12:03
que es este 00:12:06
el objeto que acabamos de crear 00:12:07
este 00:12:09
a su campo dato 00:12:09
le estamos poniendo 00:12:14
el dato que me pasan 00:12:15
está claro ¿no? 00:12:17
y ahora viene lo complicado 00:12:18
decir vale 00:12:20
y ahora 00:12:21
¿cómo hago yo con estos enlaces? 00:12:22
¿cómo hago yo con estas flechitas? 00:12:25
para que se dé de la mano con los otros 00:12:26
y forme parte de la lista. 00:12:29
¿Cómo hago? 00:12:32
A ver, hay dos opciones. 00:12:34
Podríamos meterlo al principio o meterlo al final. 00:12:36
La lista enlazada que ya está hecha en Java 00:12:41
me da las dos posibilidades. 00:12:43
Una es más fácil de programar que la otra. 00:12:45
Vamos a programarla fácil ahora mismo, la facilita. 00:12:48
Porque tampoco vamos a perder tiempo 00:12:51
programando todas las funcionalidades 00:12:53
si ya están hechas. 00:12:55
Vamos a programarla facilita. 00:12:56
Bueno, vamos a pensar, ¿cómo podría yo meter este aquí? 00:12:58
Hombre, pues mira, con dos únicas sentencias ya lo inserto. 00:13:01
Es decir, si yo copio en el campo siguiente lo que hay en inicio. 00:13:07
Imaginaos que hago esta asignación. 00:13:13
Imaginaos que hacéis esta. 00:13:15
Nodo punto siguiente igual a inicio. 00:13:17
Mirad esta asignación de aquí. 00:13:24
Nodo siguiente igual a inicio 00:13:25
¿Qué estamos haciendo con esta asignación? 00:13:27
Con esta asignación lo que estamos haciendo es 00:13:30
Que este pase a apuntar 00:13:32
A donde apunta este 00:13:34
Luego lo que estamos haciendo es que este empiece a apuntar 00:13:35
No, esto no quiero 00:13:39
Que este 00:13:40
Empiece a apuntar 00:13:42
Ahí, ¿verdad? 00:13:43
Eso es lo que estamos haciendo 00:13:49
Eso es lo que hemos hecho con esta única sentencia 00:13:50
¿verdad? con esta única sentencia 00:14:03
hola 00:14:06
pasa 00:14:07
con esta única sentencia 00:14:08
lo que hemos hecho es que 00:14:12
este pase a apuntar 00:14:13
aquí ¿está claro? 00:14:16
modo siguiente 00:14:19
igual a inicio 00:14:20
implica esto 00:14:21
¿si o no? 00:14:22
¿si? vale, entonces ya se ha dado 00:14:25
de la mano, pero hombre esto sigue 00:14:28
estando mal porque ahora inicio tendría que apuntar a esta 00:14:30
Y entonces lo habríamos acogido al principio, ¿verdad? Lo habríamos acogido al principio. Vale, pues ¿cómo hacemos que inicio ahora ya deje de apuntar a este enlace fuera y empiece a apuntar a esta y entonces ya la lista ya está otra vez construida? 00:14:32
este se ha cogido dentro y ya la lista 00:14:50
es una lista enlazadita 00:14:53
donde hemos metido a este al principio 00:14:55
pues que sentencia tendríamos que hacer 00:14:57
para que inicio ahora a apuntar 00:14:59
a este nodo 00:15:01
que sentencia escribiríais 00:15:02
alguien me la dictaría 00:15:05
para conseguir 00:15:09
que inicio ahora en lugar 00:15:12
de llevarme aquí, me lleve al 00:15:13
nodo que yo acabo de crear 00:15:15
al que yo acabo de crear, a este, que se llama nodo 00:15:17
Que se llama nodo. 00:15:20
¿Qué sentencia pondríais aquí? 00:15:21
Para que esta que es inicio 00:15:28
empiece a apuntar 00:15:31
a esta variable que se llama 00:15:51
nodo, cuya referencia es nodo. 00:15:53
¿Qué sentencia pondríais? 00:15:56
¿Nadie me la dicta? 00:15:58
Piensa lo mejor. 00:16:01
Al revés. 00:16:03
Inicio igual a nodo. 00:16:05
Ya está, ya hemos acabado. 00:16:06
Se acabó el método. 00:16:07
Ya está. 00:16:09
Joder, ¿qué he escrito aquí? 00:16:10
Inicio. 00:16:13
Ya lo tenemos. 00:16:15
Luego son tres partes. 00:16:17
Primero, creamos el nodo y le damos el dato. 00:16:19
Ya está. 00:16:22
Ahora, hacemos que su campo siguiente apunte al principio de la lista. 00:16:23
Y luego cambiamos el principio de la lista para que apunte a este nodo. 00:16:29
Ya está. 00:16:34
Ya hemos agrandado la lista metiéndole dentro un nodo nuevo. 00:16:35
al principio en vez de al final 00:16:39
pero estos son 00:16:41
líneas de código 00:16:43
que no le cuesta nada a la máquina virtual 00:16:46
hacer, nada 00:16:48
y sin embargo lo del array lo rompo 00:16:48
lo parto, copio todo, lo recorro 00:16:51
para copiar, imaginaos que son 20.000 00:16:53
pues es una locura, sin embargo aquí 00:16:55
insertar ha sido sencillísimo 00:16:57
¿vale? 00:16:59
tenemos el método add 00:17:06
ahora ya desde mi main 00:17:07
que yo le meto un hola 00:17:11
pues ese hola 00:17:14
se quedará en la lista 00:17:16
que yo le meto luego un adiós 00:17:19
pues aparecerá otro nodo con ese adiós 00:17:21
y así todos los que yo quiera 00:17:23
vale 00:17:24
o sea, para comprobarlo vamos a hacernos el get 00:17:26
bueno, a ver 00:17:29
lo que pasa es que el get no es tan sencillo 00:17:32
vamos a 00:17:35
primero comprobar que no hay errores de ejecución 00:17:36
no vamos a poder ver nada porque no tenemos la consulta 00:17:40
pero vamos a hacer esta primera ejecución del main 00:17:43
yo me hago mi objeto lista 00:17:46
y le meto cadenas, hola Dios 00:17:47
vamos a ver 00:17:49
que no nos dé error de ejecución al menos 00:17:51
para ver que no hemos programado 00:17:53
algún null pointer exception o algo mal 00:17:55
bueno 00:17:56
al menos no hay errores de ejecución 00:17:59
no se nos ha escapado ninguna burrada 00:18:03
pero hombre, vamos a ver si realmente 00:18:05
vamos a hacer el método get, al menos 00:18:07
vamos a hacer al menos el método get 00:18:09
para poder recuperar los datos por posición 00:18:10
vamos a hacerle el get 00:18:13
este de aquí 00:18:16
para tener ya una estructura de datos operativa 00:18:17
mucho más útil que el array 00:18:20
esto es mucho más útil que un array 00:18:22
vale, pues el get 00:18:23
aquí 00:18:27
el get que me tiene que devolver 00:18:29
el contenido de uno de los nodos 00:18:31
que es de tipo string 00:18:33
y que recibe una posición 00:18:34
vale, este será el get 00:18:37
vale, pues el get no es tan sencillo 00:18:45
porque el get ahora ya implica 00:18:56
la operación de ir avanzando en la lista 00:18:57
de ir avanzando 00:19:00
porque yo tengo la dirección del primero 00:19:02
pero solo tengo la del primero 00:19:04
que está aquí en inicio 00:19:06
está aquí arriba, solo tengo esta 00:19:07
con lo cual 00:19:10
el primer dato lo tengo facilísimo 00:19:11
porque tengo la dirección del primero 00:19:14
que es inicio 00:19:16
entonces si la posición que me dicen es la del primero 00:19:16
es muy sencillo 00:19:20
pero claro, me pueden decir cualquiera 00:19:21
entonces tenemos que saber 00:19:23
avanzar a través del inicio 00:19:25
ir avanzando por la lista hasta pararnos en la que toque. 00:19:27
Bueno, pues esto, el avance en la lista, ¿cómo se hace? 00:19:34
Pues lo que se nos ocurriría es hacer un puntero, 00:19:38
una referencia, perdón, una referencia auxiliar. 00:19:41
Que inicialmente, la inicializamos inicialmente con la del primero. 00:19:45
Vamos a llamarle aux, ¿vale? 00:19:50
Vamos a llamarle aux y la inicializamos. 00:20:06
A ver qué suena. 00:20:11
¿alguien tiene un péndulo por ahí dando la brasa? 00:20:12
a ver, venga 00:20:17
bueno, la del primero ahora mismo es esta 00:20:18
ahí 00:20:23
vale, cogemos una variable auxiliar 00:20:24
y le inicializamos a la del primero 00:20:28
y ahora, le hacemos que esa variable auxiliar 00:20:30
vaya avanzando, vaya avanzando 00:20:33
tantas veces como me diga 00:20:34
posición, tantas veces como me diga 00:20:36
eso será un contador 00:20:38
un contador que cuando ha llegado a posición 00:20:40
nos paramos 00:20:43
y cuando este puntero ya ha ido avanzando 00:20:44
tantas veces como me diga posición 00:20:47
recupero 00:20:49
su campo dato 00:20:50
y ya está 00:20:52
entonces, coger una 00:20:53
referencia auxiliar a nodo e inicializarla 00:20:57
a la primera 00:20:59
eso lo tenemos fácil 00:21:00
me cojo yo 00:21:01
una referencia a nodo auxiliar 00:21:04
y la inicializo 00:21:07
a esto, a inicio 00:21:09
ya tengo la primera parte 00:21:11
tengo esta referencia 00:21:13
anodo auxiliar que está 00:21:15
apuntando al primero de todos 00:21:17
que está apuntando al primero 00:21:18
¿vale? 00:21:21
está apuntando al primero, a este primero 00:21:24
y ahora 00:21:26
antes de meterlo del contador y eso 00:21:28
la sentencia 00:21:31
de avanzarlo para que 00:21:33
apunte al siguiente 00:21:35
¿cuál se os ocurre que podría hacer? 00:21:36
es decir 00:21:39
¿qué sentencia habría que poner aquí 00:21:40
para hacer que aux apunte 00:21:42
al siguiente? 00:21:44
al que está apuntando en ese momento. 00:21:47
aux igual a 00:21:50
¿qué pondríais ahí 00:21:51
para que aux pasara 00:21:53
de apuntar a un nodo al que 00:21:55
esté para apuntar al otro, al que 00:21:57
está consecutivo? 00:21:59
¿qué pondríais ahí? 00:22:01
aux igual a qué? 00:22:03
¿a? 00:22:05
nodo no, aquí no hay nada que se llame nodo. 00:22:08
aux igual a va por ahí pero no 00:22:10
aux igual a qué? 00:22:12
no, a ver, aux 00:22:19
es la dirección de este 00:22:20
que tiene dentro dato y siguiente 00:22:22
aux tiene dentro dato y aux tiene dentro siguiente 00:22:24
que a su vez es la del siguiente 00:22:27
pues para que aux que tiene dentro dato 00:22:29
y tiene dentro siguiente 00:22:33
apunte a su siguiente 00:22:34
sí pero ese t no puede ir suelto 00:22:36
porque es un campo de alguien 00:22:41
tiene que apuntar al siguiente de alguien 00:22:42
sí pero al siguiente de quién 00:22:45
de sí mismo 00:22:46
tiene que apuntar al siguiente de sí mismo 00:22:48
y el siguiente de sí mismo, ¿quién es este? 00:22:50
esta es la sentencia 00:22:54
con la que aux avanza 00:22:55
una posición 00:22:57
con esta sentencia 00:22:58
aux avanza una posición 00:23:10
porque aux.siguiente 00:23:12
es la dirección de su siguiente 00:23:14
pues yo la cojo y le sobrescribo a él 00:23:15
con la de su siguiente 00:23:18
le sobrescribo a él con la de su siguiente 00:23:19
luego con esta, aux avanza en una posición 00:23:21
le sobrescribo a él con la de su siguiente 00:23:24
y ahora ¿cuántas veces hay que hacer eso? 00:23:27
tantas como me indique posición 00:23:30
tengo que hacerlas tantas veces como posición 00:23:31
y cuando ya lo haya avanzado 00:23:34
tantas veces como me diga posición 00:23:37
pues recupero su campo dato 00:23:38
recupero su campo dato 00:23:40
¿vale? entonces esto ya sí que será un bucle 00:23:42
un bucle que podríamos plantearnos así 00:23:44
pues while posición 00:23:47
sea mayor o igual que 0 00:23:49
esto es lo primero que se os ocurriría 00:23:51
ya de programación que lo hemos hecho mil veces 00:23:53
Pues aux igual 00:23:55
Aux, esto 00:23:57
Lo quito de aquí, claro 00:23:59
Aux igual a aux punto 00:24:01
Siguiente 00:24:03
¿Vale? 00:24:05
Y posición 00:24:07
Menos menos 00:24:08
Por ejemplo 00:24:10
Me ahorro contador y me ahorro todo 00:24:12
Esto ya es de programación de toda la vida 00:24:16
Voy decrementando posición 00:24:18
Y mientras no haya llegado a cero 00:24:21
Voy avanzando el puntero 00:24:24
entonces cuando hayamos salido del while 00:24:27
aux ha avanzado 00:24:30
una cantidad de veces 00:24:32
igual a posición 00:24:34
¿si o no? 00:24:35
si ¿no? es un bucle con contador 00:24:38
el papel del contador lo está haciendo aquí posición 00:24:40
lo voy decrementando 00:24:42
y cuando llega a cero 00:24:44
pues ya ha avanzado tantas veces 00:24:45
entonces 00:24:48
cuando ya estoy 00:24:49
con aux 00:24:53
aux ha ido avanzando 00:24:54
avanzado, primero apuntaba a este 00:24:56
luego a este, luego a este 00:24:59
cuando ha avanzado tantas veces 00:25:00
como me dice 00:25:02
posición, ya se queda apuntando 00:25:04
al nodo que yo quiero 00:25:07
y cuando ya está apuntando al nodo 00:25:08
que queremos, lo único que 00:25:10
toca hacer es devolver el 00:25:12
dato, aux.dato 00:25:14
ya está 00:25:21
luego, hacemos un auxiliar 00:25:23
que apunte al primero 00:25:25
lo avanzamos tantas veces como me diga 00:25:26
posición 00:25:29
y cuando ya lo he avanzado 00:25:30
hasta el nodo objetivo 00:25:33
cuando ya ha llegado al nodo objetivo 00:25:34
devuelvo el dato que está 00:25:37
en ese nodo objetivo 00:25:39
y ya está 00:25:40
ya tendría mi get hecho 00:25:43
vale, porque me da 00:25:46
por el public, no le he puesto public 00:26:01
es por eso por lo que me da, ah si, pero no le he puesto public 00:26:03
por eso me da en 00:26:05
vale, pues ya tendría mi primera versión del get 00:26:06
vale, no estamos 00:26:12
verificando si hay casos que no hemos 00:26:22
comprobado errores, lo que sea, no lo estamos 00:26:25
pero vamos a hacer una primera prueba 00:26:27
a ver si me devuelve 00:26:29
¿qué me tendrá que devolver? este 00:26:30
cuando yo ejecute este programa, ¿qué me tendrá 00:26:32
que devolver de cero? 00:26:35
¿hola o adiós? no, adiós 00:26:38
porque mirad que el add 00:26:43
lo hemos hecho en la versión sencilla que 00:26:44
los va insertando al principio 00:26:47
entonces el último que llegó 00:26:49
se ha metido al principio, está haciendo como 00:26:51
una pila, está simulando una pila 00:26:53
¿vale? entonces 00:26:55
el hola 00:26:56
primero será el primero que meterá el hola 00:26:58
luego cuando llegue el adiós 00:27:01
el adiós se colará delante del hola 00:27:02
y así todos 00:27:05
entonces la posición 0 será la del último que se ha metido 00:27:05
la del último 00:27:08
en realidad estamos haciendo una pila 00:27:09
que es un caso concreto de listag 00:27:12
enlazada genérica 00:27:14
pero porque es más fácil de programar que 00:27:15
meterlo al final 00:27:18
vale, vamos a probarlo 00:27:19
a ver si 00:27:23
hacemos nuestro main 00:27:24
vale 00:27:27
Anda, ¿por qué no saca Lola? 00:27:34
Ah, por el mayor o igual 00:27:44
¿Vale? 00:27:45
Pero vamos a meterle más nodos 00:27:46
Para ver mejor 00:27:50
A ver, vamos a poner 00:27:51
Cadena 1 00:27:55
Para ver mejor lo que está haciendo 00:27:59
Solo con estos dos 00:28:00
Control C 00:28:01
Vamos a meterle 4 00:28:05
Cadena 1, cadena 2 00:28:12
Cadena 3, cadena 4 00:28:15
¿Vale? 00:28:18
Entonces él irá emitiendo cadena 4 00:28:19
Luego cadena 3 se colará delante 00:28:22
Luego cadena 2 se colará delante 00:28:23
Y luego cadena 1 se colará delante 00:28:25
¿Vale? O sea, ya sabemos que en nuestra lista 00:28:27
Tal y como hemos hecho el app 00:28:30
Ya sabemos que en nuestra lista está la cadena 1 00:28:31
Cadena 2, cadena 3, cadena 4 00:28:34
Porque el app nos va colando delante 00:28:35
Vale, ahora vamos a probar nuestro get 00:28:37
Con 4 datos que vamos a ver mejor 00:28:39
Lo que está haciendo 00:28:41
Lo probamos 00:28:44
Vale 00:28:46
vale, me está sacando 00:28:48
no me está sacando el primero de todos 00:28:51
vale, me está sacando 00:28:54
cadena 3 00:28:55
entonces, vale 00:28:56
aquí 00:29:02
tendremos que revisar entonces que el 00:29:03
número de avances 00:29:07
no es el correcto 00:29:08
el número de avances no es el correcto 00:29:12
¿qué modificaríais 00:29:13
aquí? es decir, si me 00:29:15
saca el 0, por lo pronto 00:29:20
quitaríamos el igual, porque está avanzando uno de más 00:29:23
entonces vamos a ponernos en el caso extremo 00:29:25
si yo le doy el 0 00:29:27
no tiene que avanzar ni una sola vez 00:29:28
no tiene que avanzar ninguna, ni una sola 00:29:31
¿vale? si yo le doy el 0 no tiene que avanzar ninguna 00:29:33
porque si yo le doy el 0, la posición 0 00:29:35
aux ya está apuntando a la primera 00:29:38
de todas, aux ya está apuntando 00:29:39
a la primera, no tiene que avanzar ninguna 00:29:41
entonces igual se quita, lo que pasa es que 00:29:43
yo esperaba que me hubiera sacado cadena 2 00:29:45
no cadena 3, no sé por qué me ha sacado cadena 3 00:29:47
porque este mayor 00:29:49
igual sí que estaba a propósito 00:29:51
pero no sé por qué me ha sacado cadena 3 00:29:54
vamos a volverlo a probar 00:29:55
ahora, vale 00:29:57
avanzamos y decrementamos 00:29:58
aux.dato 00:30:01
vamos a ver 00:30:05
le meto cadena 1, cadena 00:30:06
2, cadena 3, cadena 4 00:30:09
aminista enlazada y le saco la posición 00:30:10
vale 00:30:13
ahora sí, ah claro, sí, es que estoy al revés 00:30:16
me lo había saco correctamente, perdón, perdón 00:30:20
vale, sí, sí, me tenía que sacar el último 00:30:22
me había hecho yo un lío 00:30:24
antes me sacaba este por el mayor o igual 00:30:26
al haber quitado el igual 00:30:28
ya me saca el 0 que es este 00:30:30
recordad que esta es la posición 0 00:30:32
esta es la 1, esta es la 2 y esta es la 3 00:30:33
porque la última que se mete 00:30:36
se cuela la primera 00:30:40
entonces nuestro get funciona 00:30:41
funciona correctamente 00:30:43
lo único es que 00:30:45
el haber hecho esta versión sencilla 00:30:48
pues hombre, me los está metiendo 00:30:49
de forma antiintuitiva 00:30:51
en lugar de ponérmelos al final 00:30:53
es como si los insertara al principio 00:30:55
pero la estructura de datos me está funcionando 00:30:57
me vale para meter, consultar 00:30:59
borrar cuando hagamos 00:31:02
el método, etc. 00:31:04
Aquí claro, esto se hace muy poco operativo 00:31:06
esto querríamos usarlo como si fuera 00:31:08
un array, que es, oye yo quiero recorrerlo con un for 00:31:10
querríamos poder hacer esto 00:31:12
querríamos poder hacer 00:31:14
un recorrido de este estilo 00:31:16
desde i sea igual a 0 00:31:17
mientras i 00:31:19
sea menor 00:31:22
que 00:31:22
el tamaño de la lista 00:31:24
¿Qué mi lista cómo se llama? Lista. Entonces, hombre, estaría bien tener un método, ojalá tuviéramos un método que me dijera cuántos datos tiene la lista, que me los dijera. Porque si lo tuviéramos, yo podría hacer un recorrido igual que hago con los arrays, ¿verdad? 00:31:27
vale, o sea, si tuviéramos un método 00:31:45
como la propiedad 00:31:58
punto length de los arrays, pues igualito 00:32:01
un método 00:32:03
que me devolviera el tamaño de la lista 00:32:04
podría usarlo exactamente igual 00:32:07
que un array, recorrerlo con 00:32:09
un índice 00:32:10
y consultar cada posición 00:32:11
pero claro, me falta el método 00:32:14
porque yo aquí cuando he hecho la lista 00:32:16
hombre, yo sé que tengo cuatro 00:32:18
pero porque los he metido yo, pero esa lista 00:32:19
puede llegar de otro sitio, puede llegar de otro lado 00:32:22
entonces este método lo necesitamos para poder hacer recorrido 00:32:25
bueno, pues no pasa nada, vamos a programarlo 00:32:27
vamos a programar 00:32:29
un método que nos 00:32:31
da el 00:32:35
tamaño de la lista 00:32:36
vale, pues ¿cómo 00:32:39
programaríais este método? ¿cómo se os ocurre? 00:32:44
lo primero, ¿qué operación 00:32:50
hay que hacer? o sea, que hay 00:32:51
la lista que nos 00:32:56
tiene que devolver 00:32:58
¿cuántos nodos hay? ¿no? 00:32:59
luego, para saber 00:33:03
cuántos hay de algo que hay que hacer? 00:33:04
Contar. 00:33:08
Pues tenemos que contar. 00:33:09
Eso es lo primero de todo. 00:33:10
Pues si tenemos que contar, no hay tutía. 00:33:12
Tendremos que hacer un contador. 00:33:16
Porque lo que tenemos es que contar. 00:33:17
Vale. 00:33:19
¿Y ahora qué tendremos que hacer? 00:33:20
Contar 00:33:23
cuántos avances 00:33:23
necesito 00:33:26
hasta llegar a dónde. 00:33:28
¿Ah? 00:33:33
Bueno, 00:33:35
contar, bueno 00:33:35
los avances salen desde el principio 00:33:37
entonces a dónde llegas al final 00:33:40
entonces ¿cuántos avances hay hasta llegar a 00:33:41
el final de la lista? ¿cuál es? 00:33:44
nul, vale, bueno pues lo mismo 00:33:47
un puntero auxiliar que se 00:33:50
inicializa aquí y lo vamos avanzando 00:33:52
lo vamos avanzando y vamos contando 00:33:53
mientras no haya llegado a nul 00:33:56
mientras no haya llegado a nul 00:33:58
cuando haya llegado a nul, ya ha terminado 00:33:59
entonces 00:34:02
aquí ya simplemente 00:34:05
nos hacemos nuestro nodo auxiliar 00:34:07
que lo inicializamos al principio 00:34:09
y ahora 00:34:13
mientras aux 00:34:15
sea 00:34:17
diferente de null 00:34:19
mientras sea diferente de null 00:34:21
¿qué hacemos? 00:34:23
lo avanzamos 00:34:24
y contamos 00:34:25
aux 00:34:27
igual a aux 00:34:30
punto siguiente 00:34:34
siguiente 00:34:36
¿vale? uy, ¿qué hago yo? 00:34:36
esta es la sentencia 00:34:41
y incrementamos 00:34:42
la cuenta, claro 00:34:44
¿vale? entonces 00:34:45
si aux es null ya desde el principio 00:34:49
si aux es null desde el principio es porque la lista está vacía 00:34:52
¿verdad? la lista está vacía, inicia punta null 00:34:54
está vacía, en ese caso 00:34:56
no entrará en el while nunca 00:34:58
porque aux ya es null 00:35:00
y en ese caso el método también funcionará 00:35:01
porque entonces me devolverá cont que es 0 00:35:04
¿vale? que aux 00:35:06
no es null, significa que al menos 00:35:10
hay un nodo, pues ahí empezamos 00:35:12
a avanzar, y ya mi 00:35:14
bucle va avanzando, mientras 00:35:16
aux sea diferente de null 00:35:18
avánzalo y cuenta 00:35:19
sigue siendo aux diferente de null 00:35:22
avánzalo y cuenta 00:35:24
y así 00:35:26
todo el rato 00:35:28
vale, bueno, parece que esto tiene sentido 00:35:29
vamos a probarlo, porque aquí nos pueden haber fallado los extremos 00:35:32
uy, cuidado que es una más, una menos 00:35:34
lo más cómodo aquí es 00:35:36
probarlo, vamos a, ah, yo lo he llamado 00:35:38
de nuevo no le he puesto el public 00:35:41
y además 00:35:43
lo he llamado lista en vez de size 00:35:45
ahora sí 00:35:47
¿vale? este método, ahora el tamaño 00:35:52
¿vale? pues 00:35:55
ahora ya sí 00:35:58
tengo mi método size, aparentemente bien 00:36:02
hecho, y ya puedo recorrer 00:36:06
con mi bucle for, como recorro 00:36:08
la raíz, exactamente igual con mi bucle for 00:36:10
desde cero, mientras sea menor que 00:36:12
el total de elementos de la lista 00:36:14
incrementando uno, muéstrame 00:36:16
el contenido uno por uno, que lo sacas con getE. 00:36:18
Vamos a ver 00:36:22
si nos saca, nos tendrá que sacar 00:36:22
cadena 4, cadena 3, cadena 2, cadena 1. 00:36:24
Si es que lo hemos hecho bien todo. 00:36:27
Vamos a ver. 00:36:30
Vale, pues ahí los tenemos. 00:36:34
Vale, entonces esto funciona 00:36:37
como un array. 00:36:38
Pero mucho más 00:36:41
computacionalmente, infinitamente 00:36:42
más eficiente. 00:36:44
Aquí no estamos usando arrays por 00:36:46
ningún lado, no los estamos usando 00:36:48
el efecto es 00:36:52
estar usando efectivamente una estructura 00:36:54
en la que yo meto, saco o no 00:36:56
porque no le hemos programado el método de sacar, que es un poquito 00:36:58
más complicado, recupero 00:37:00
por posición, etcétera 00:37:02
vale, entonces aquí claro, para 00:37:09
uno hacerse ya su estructura estupenda 00:37:10
pues hombre, habría cosas 00:37:12
que, pues podría hacer 00:37:15
un remove por posición 00:37:18
pues un remove por posición 00:37:19
que tú le das una posición 00:37:22
y te devuelve 00:37:24
o sea, te lo elimina 00:37:28
de la lista 00:37:31
podríamos eliminar por contenido 00:37:32
también, donde tú le 00:37:36
pasas un dato 00:37:42
y te elimina 00:37:45
el nodo o todos los nodos 00:37:47
depende de la versión que tú quieras hacer 00:37:49
que contienen este dato 00:37:51
es una versión de remove distinta a la de arriba 00:37:53
aquí estaríamos haciendo un remove 00:37:55
sobrecargado, ¿vale? 00:37:57
recordad que lo que era la sobrecarga 00:37:59
de métodos, que eran métodos 00:38:01
que se llaman igual pero son 00:38:03
perfectamente distinguibles porque sus parámetros 00:38:05
son distintos 00:38:07
aquí este remove no se puede 00:38:08
confundir con este otro 00:38:11
porque a ese se le pasa un int y a ese se le pasa un string 00:38:13
pues podríamos hacer esto 00:38:15
¿vale? podríamos hacer 00:38:17
este en realidad 00:38:20
add, si lo hubiéramos 00:38:22
llamado bien, lo tendríamos 00:38:24
que haber llamado addFirst porque es añádelo 00:38:26
pero al principio, añádelo al principio 00:38:28
con lo cual esto que estamos haciendo aquí 00:38:30
sería este 00:38:33
sería este un nombre 00:38:35
un poco más claro 00:38:39
vale, bueno pues además 00:38:40
del añade al principio 00:38:50
esto se quedaría, esta estructura ya de datos 00:38:51
se quedaría estupenda si le añadimos un método 00:38:54
que sea añadir al final 00:38:56
el otro 00:39:00
añadir al final 00:39:02
public void 00:39:03
y ya si que se quedaría 00:39:13
completísima y divina 00:39:16
si le añadimos un 00:39:18
método que sea añadir 00:39:20
en la posición que yo te diga 00:39:22
no al principio y al final, sino añadir en la que yo te diga 00:39:24
eso ya sí que 00:39:27
sería estupendo 00:39:28
una versión de app que tú le pasas el dato 00:39:29
tú le pasas el dato 00:39:33
y le pasas una posición 00:39:40
y te lo añade 00:39:42
insertado en la posición 00:39:47
que tú le digas, por ejemplo 00:39:49
vale, así 00:39:50
aquí podríamos programar esto 00:39:52
ya más completito 00:39:54
y ya con mi main 00:39:55
yo uso esta lista 00:39:57
y no tengo ni idea de cómo está hecha por dentro 00:40:00
ni me importa, yo llamo a sus métodos 00:40:02
llamo a los métodos de añadir 00:40:04
al principio, recorrer con el 00:40:06
índice, recuperar 00:40:08
por posición, ahora quiero añadir al final 00:40:10
pues atlas, ahora quiero borrar 00:40:12
pues quiero borrar el 00:40:14
de posición, lo que sea 00:40:15
pues llamo a 00:40:18
venga, ya está 00:40:20
a borrar el de posición 1, por ejemplo 00:40:21
lo que yo quiera, ahora mismo no me haría nada 00:40:24
porque el método está vacío 00:40:26
claro, el método está vacío y no me haría nada 00:40:27
pero yo podría completar toda esta funcionalidad 00:40:29
y con lo que hemos visto 00:40:32
lo podéis hacer perfectamente 00:40:36
porque es lo mismo que yo he hecho 00:40:38
parecido, se basa en combinar 00:40:40
la sentencia de avanzar con punteros auxiliares 00:40:42
y ya está 00:40:45
borrar por posición 00:40:46
¿cómo sería? 00:40:49
pues borrar por posición es un poco más complicado 00:40:51
porque de nuevo es un puntero auxiliar 00:40:53
que tienes que avanzar hasta la posición 00:40:55
y cuando ya has llegado 00:40:57
tienes que sobre, si este es el que 00:40:58
hay que eliminar 00:41:01
pues eliminar será puentearle 00:41:03
al anterior 00:41:05
asignarle la dirección de este 00:41:06
así, y lo puenteas 00:41:09
al apuenteado, eso será eliminar 00:41:12
con un auxiliar llegar hasta el que quieras borrar 00:41:13
luego a este puntero 00:41:17
darle su siguiente 00:41:19
darle su siguiente, asignárselo 00:41:20
pues lo ha esponteado 00:41:22
entonces no es 00:41:24
difícil de programar, lo podéis hacer 00:41:26
el de añadir al final 00:41:28
añadir al final, habrá que hacer de nuevo 00:41:30
un puntero auxiliar 00:41:33
o sea, la parte de añadir, habrá que crear un nodo 00:41:33
eso está claro, un nodo como aquí 00:41:37
en el añadir al principio, un nodo y darle el dato 00:41:38
pero luego ya 00:41:41
habrá que con un auxiliar 00:41:43
navegar hasta el final 00:41:44
y cuando ya ha llegado al final, a este 00:41:45
a este ya darle la dirección 00:41:48
del nuevo. 00:41:52
Una sentencia de asignación, nada más. 00:41:53
Nada más. 00:41:56
Bueno, pues yo querría que hicierais 00:41:58
estos métodos que faltan. 00:42:00
¿Vale? Queréis estos métodos 00:42:02
que faltan. Bueno, pues esta 00:42:04
estructura de datos ya existe, ya está hecha. 00:42:11
Y está hecha como la hemos hecho 00:42:13
nosotros. Punto pelota. 00:42:15
¿Vale? Se llama de otra manera, pero 00:42:17
ya está hecha. 00:42:19
Esta en particular se llama Linked List 00:42:20
o en lista enlazada en inglés, nos da lo mismo 00:42:22
vale 00:42:24
bueno, a ver 00:42:26
enteraos todo el mundo 00:42:29
¿lo pilláis? ¿cogido? 00:42:31
bueno, cuando 00:42:37
al menos tratad de hacer 00:42:38
alguno de los cuatro 00:42:41
con que alguno de los cuatro 00:42:45
los hagáis 00:42:47
vosotros ya 00:42:48
os va a ser suficiente 00:42:50
para entender del todo lo que hemos hecho arriba 00:42:52
con que alguno de los 4 ya lo hagáis votos de 0 00:42:55
este get por ejemplo 00:42:57
se ha quedado 00:43:00
no le he verificado errores 00:43:03
imagínate que le damos una posición 00:43:06
mayor 00:43:07
que la que existe 00:43:09
por ejemplo imaginaos que en este main de aquí 00:43:10
en este main 00:43:13
yo digo 00:43:15
yo tengo solo 4 y de repente digo 00:43:16
recupérame las 7 00:43:19
que creéis que va a salir aquí abajo 00:43:20
justo 00:43:22
efectivamente me va a salir 00:43:25
un null pointer exception, ¿por qué? 00:43:27
porque 00:43:30
este va a estar avanzando, va a estar avanzando 00:43:31
la lista se va a acabar 00:43:36
y esto va a ser null 00:43:38
y va a tratar de hacer un siguiente de algo que ya es null 00:43:40
porque ya ha terminado 00:43:43
la lista 00:43:45
y entonces aquí cuando trate de hacer 00:43:45
un acceso a siguiente de algo que es null 00:43:48
va a decir null pointer exception 00:43:51
entonces hombre, este método get 00:43:52
se quedaría mucho mejor si decimos 00:43:54
Oye, si la posición que me pasas es mayor que el tamaño, retún, retún nul, devuélveme nul porque no tienes nada. No, o sea, esto, si yo le pongo aquí esto, sería mucho mejor. 00:43:56
si la posición que me pasas 00:44:06
resulta que es mayor 00:44:09
que 00:44:11
el tamaño de la lista 00:44:13
y afortunadamente tengo el método 00:44:15
size que me lo dice 00:44:17
en ese caso 00:44:18
si la posición 00:44:20
es mayor que el tamaño de la lista 00:44:23
pues en ese caso mira 00:44:26
fuera 00:44:27
return null 00:44:29
devuélveme el contenido 00:44:31
string que sea null 00:44:33
entonces esto mayor o mayor que menos 1 00:44:34
porque 00:44:38
10.6 y la lista tiene 00:44:39
10.6 es 4 00:44:43
y posición solamente tiene que ser 00:44:45
0, 1, 2 o 3, con lo cual esto sería mayor o igual 00:44:48
¿verdad? 00:44:50
si posición es mayor o igual que 6 00:44:51
entonces esa posición no existe 00:44:53
porque solo existen desde 0 hasta 6 menos 1 00:44:56
solo existen desde 0 hasta 6 menos 1 00:44:58
entonces si es mayor o igual 00:45:01
lo siento 00:45:03
Entonces ahora ya 00:45:04
Si ejecutamos este main 00:45:07
Aquí no voy a dar null pointer exceptio 00:45:09
Me va a mostrar null porque ese valor tiene null 00:45:12
Claro, pero no me va a dar null pointer exceptio 00:45:14
Me va a decir, hay null 00:45:16
En la posición 7 hay null, no hay nada 00:45:17
Vale 00:45:19
Bueno 00:45:21
Vamos a parar aquí un segundin 00:45:30
¿Vale? 00:45:33
Venga, pues 00:45:37
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
8
Fecha:
26 de febrero de 2024 - 18:48
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
45′ 38″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
188.27 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid