Saltar navegación

ListaEnlazada pt1 - 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 3 de febrero de 2026 por Stefano C.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, voy a grabar esta clase, por lo tanto si habláis me autorizáis a grabar vuestra voz. 00:00:01
Entonces, nosotros en la vez anterior hemos visto cómo queremos dejar aparcados los arrays 00:00:07
y entonces nos hemos creado una interfaz que se llama lista. 00:00:20
Ahí está la interfaz de ahí, ¿vale? 00:00:24
Hemos dicho que nosotros con los arrays hacemos una serie de operaciones muy comunes, 00:00:25
como añadir un elemento, quitar un elemento, preguntar cuánto es grande la 00:00:30
rey, etcétera, etcétera, que queremos esconder, queremos esconder todo el 00:00:35
trabajo que está por detrás, creando una nueva forma de gestionar los objetos, lo 00:00:42
que se llama las colecciones. Además queremos que sean dinámicas, 00:00:49
mientras un array es fijo es ese tamaño y tengo que hacer cosas raras pues mis colecciones quiero 00:00:56
que yo pueda añadir cuantos objetos me da la gana y el por debajo haga lo que tiene que hacer para 00:01:02
añadir este nuevo objeto vale me quiero olvidar de la mira no lo he hecho grande cuatro posiciones 00:01:07
entonces no puedo poner cinco objetos pues no pongo lo que te haga falta hemos hecho la 00:01:13
implementación con un array entonces hemos visto que hemos reutilizado dentro la mayoría de los 00:01:19
métodos, ejercicios y cosas por el estilo que hemos hecho con los arrays. De extender el array, 00:01:25
acortar el array, copiar un array, pues hemos hecho esa cosa ahí. Al final hemos dicho, mira, 00:01:30
no hay una forma de hacer esto sin usar arrays. Puedo implementar una lista de otra forma sin 00:01:37
tener en cuenta los arrays y entonces nos hemos inventado esto, el concepto de la lista enlazada, 00:01:47
¿Qué es la lista enlazada? 00:01:54
Sustancialmente, es la idea de un objeto que estará aquí. 00:01:57
Esto será mi lista enlazada. 00:02:03
Por favor, chicos. 00:02:06
Sobre este objeto será donde le puedo pedir añadirme otro objeto, quítame otro objeto, 00:02:08
busca si hay este objeto, cosa por el estilo. 00:02:14
aquí tendré un puntero, una referencia a lo que hemos llamado cabeza o inicio o lo que sea, 00:02:16
¿vale? Que será un puntero a otro objeto, este objeto de tipo nodo. ¿Qué es un nodo? Un nodo es, 00:02:26
es algo que tiene un contenido, esto será el objeto nuevo que voy a almacenar, y además tiene 00:02:38
también un puntero a otro objeto, siempre de tipo nodo, o sea una referencia a un nodo, o sea una 00:02:52
variable de tipo nodo que apunta a un objeto de tipo nodo, que tendrá un contenido y un puntero. 00:03:01
a otro nodo, hasta llegar a un cierto momento al último, digamos, elemento de la cola, de la lista, 00:03:11
que tendrá null, o sea, una referencia a nada, no hay un siguiente nodo. Entonces ese es el último. 00:03:20
Al principio, cuando yo crearé la lista enlazada, lo que tendré es que en la cabecera, en la cabeza, 00:03:32
tengo null. Esto equivale al array vacío, al array de cero posiciones. Existe el array, 00:03:39
pero no hay nada dentro. Aquí existe la lista enlazada, pero no hay nada dentro. En el momento 00:03:49
en que añado un elemento, lo que haré es crearme un nodo, ponerle el contenido que me han dicho de 00:03:57
poner, poner que es null su siguiente salto, su siguiente elemento, y luego tendré que ir a la 00:04:06
cabecera, a la cabeza, y decirle tú ya no eres null, mas tu siguiente, o el inicio de la cabeza, 00:04:16
es este. Ahora cuando añado uno nuevo, crearé un nuevo elemento, con aquí null, con aquí el 00:04:23
contenido que quiero y este nul de aquí ahora no será nul, más será un puntero a 00:04:33
este elemento. Y así, así, así, así. Esta es la idea que está por debajo. Si yo quiero 00:04:41
eliminar un elemento, por ejemplo quiero eliminar este elemento de aquí, eliminar 00:04:47
este elemento quiere simplemente ir a su padre, al anterior, de alguna forma, y 00:04:52
modificar que su siguiente, ahora no es el elemento que quiero borrar, 00:04:58
más es el siguiente. O sea, el siguiente del elemento que quiero borrar. De esta forma, 00:05:03
esta cosa de aquí se borra y este elemento de aquí, como no tiene ninguna referencia, 00:05:10
pues desaparecerá como lágrimas en la lluvia. Ahora, decidme que tampoco sabéis esto. 00:05:18
Blade Runner, señores. 00:05:25
No el nuevo, el viejo. 00:05:34
De la hospice. 00:05:35
Puede ser informático 00:05:38
así, pero... Vale. 00:05:39
Entonces, ahora nosotros, 00:05:41
si la teoría está más o menos clara, 00:05:43
pues lo que vamos a hacer es intentar 00:05:45
implementar estas cosas, 00:05:47
pasito a pasito. ¿Vale? 00:05:49
La primera cosa que tenemos que hacer, porque si no, no empezamos, 00:05:50
es el nodo. 00:05:53
¿Vale? Necesito esta cosa aquí, 00:05:55
porque todo se basa sobre eso. Cuando yo 00:05:57
crearé una lista enlazada, el primer elemento será un nodo. Si yo no lo tengo, ¿qué creo? 00:05:58
Esto pasa muchas veces. Cuando yo tengo un programa complejo que usa otras cosas, pues 00:06:07
tengo que empezar desde las clases más sencillas. Si yo tengo una escuela que gestiona materias, 00:06:13
alumnos y profesores, no puedo empezar desde escuela. Porque en cuanto diga, vale, añade 00:06:20
un alumno, no tengo el elemento alumno, no tengo la clase alumno, ¿qué hago? Tengo 00:06:26
que empezar desde las cosas que no dependen de nada, como la clase alumno, o hacer una 00:06:31
estructura de persona, alumno y profesor. Vale, cuando tengo estas cosas aquí ya puedo 00:06:36
ponerme con la escuela diciendo, crea un nuevo alumno, añade un alumno, dar de baja 00:06:40
un alumno, asignar un alumno a un profesor, porque los tengo. Si no tengo alumnos y profesores 00:06:46
no puedo jugar con ellos. Entonces, ¿cómo hacemos nodo? Así. Mi clase nodo tiene un contenido que 00:06:52
por ahora es un object. Podría poner una cosa así. Ahora los nodos son de un objeto que le paso yo. 00:07:06
Son objetos de tipo string o son objetos de tipo gato. Lo defino en el momento en que creo la lista 00:07:16
y la lista tendrá solo nodos de esa materia ahí, ¿vale? 00:07:23
Pero por ahora, nos olvidamos los tipos genéricos y ponemos object, ¿vale? 00:07:27
Además del contenido, que es esta parte de aquí, esto, aquí es donde pondré el objeto, ¿vale? 00:07:33
El contenido va aquí dentro. 00:07:40
Pues necesito una referencia a un siguiente nodo. 00:07:42
entonces tengo una referencia 00:07:47
que se llama siguiente 00:07:50
que es el mal 00:07:52
si yo tengo un determinado nodo 00:07:53
para saber quién está detrás de él 00:07:55
tendré que hacer, si este nodo se llama A 00:07:57
¿qué tendré que hacer para saber 00:07:59
quién viene después de A? 00:08:01
es como tengo la referencia 00:08:10
yo tengo la referencia de A, tengo este objeto nodo que se llama A 00:08:11
¿cómo sé quién viene 00:08:14
después de A? 00:08:16
A punto siguiente 00:08:19
¿entiendes? 00:08:20
ahora vamos a ver cómo se usa pero para qué sentido y luego me he hecho una cosa maestro 00:08:23
un constructor vale para construir un nodo le doy el objeto contenido y él me construye un 00:08:32
objeto cuyo contenido es el que le he pasado yo lo almacena y luego como siguiente ponen un os 00:08:39
acordáis aquí no decíamos cuando nosotros queremos añadir uno nuevo creamos un nuevo objeto con null 00:08:45
y el contenido que sea, y luego me voy al último de mi lista y le digo que tú que apuntabas al null, 00:08:52
ahora no apuntas al null, sino apuntas a este nodo. Pero el que he creado nuevo es el que se queda 00:09:01
con null. Por lo tanto, he hecho un constructor que me crea un nodo con null. Luego ya veré yo 00:09:08
donde encajado, modificando esto. Podríamos ponerlos privados y que luego haya métodos para 00:09:14
modificarlos, que hagan controles y cosas así. Lo mantengo lo más sencillo posible. Todas esas 00:09:24
técnicas de allí ya las conocéis, ya las hemos usado y la tenéis que poner en algún lado de 00:09:29
vuestro cerebro y pensar esas cosas. O sea, ¿qué hago con el contenido? ¿Lo dejo abierto? ¿Lo pongo 00:09:35
en privado 00:09:41
pongo un set contenido para poderlo 00:09:44
modificar, hago algunas comprobaciones 00:09:45
pues todo esto depende del sistema 00:09:48
en el que estáis, nosotros estamos a un nivel más abstracto 00:09:49
estamos viendo como funciona 00:09:52
la lista enlazada, vale 00:09:53
entonces simplifico todo 00:09:55
para llegar a lo más sencillo posible 00:09:57
dudas hasta aquí 00:10:00
vale, entonces crea una extra lista 00:10:02
enlazada 00:10:05
¿Esta lista enlazada que tiene? 00:10:06
ahí 00:10:16
¿Qué es cabeza? Nodo cabeza. 00:10:17
Este es el primer nodo. Cuando creo una lista enlazada, ¿qué hago? 00:10:22
Es igual al nodo. Creo una lista vacía. 00:10:34
La lista vacía es que cabeza es null. ¿Por qué? Porque ¿cuántos elementos hay? Ninguno. ¿Dudas? 00:10:49
Yo lo había hecho directamente sin el constructor, poniendo en el atributo ya directamente que cabeza es igual a null. 00:11:05
Cambia un poquito el momento en que se instancia esa cabeza como cual es null, pero sustancialmente es casi lo mismo. 00:11:16
Yo lo dejo aquí porque así esto se instanciará en el momento en que se crea la lista. 00:11:24
Al crearla es cuando se instancia. 00:11:31
Ok, perfecto. 00:11:34
Entonces vamos a hacer el add. 00:11:36
Ok, perfecto. 00:11:38
Public, en la primera versión de add. 00:11:40
Public, ¿cómo era? 00:11:45
Porque este señor tiene que... 00:11:48
Perfecto. Entonces, ¿qué método tengo que hacer? Pues estos. Con el mismo prototipo, 00:11:52
con la misma declaración del método y sobreescribiéndolo para evitar que me equivoque. Entonces, esto 00:12:04
es mi prototipo. Esto lo que tengo que hacer es devolver nada y me pasa un Object Element. 00:12:11
Entonces, ¿qué tengo que hacer aquí? 00:12:16
¿Qué tenía que hacer? 00:12:18
¿Os acordáis? 00:12:19
Primer paso. 00:12:20
¿Qué hago? 00:12:22
No, no era el primer paso. 00:12:31
La cabeza no la toco. 00:12:34
Yo el primer paso, pues es la comprobación de si la cabeza es siguiente. 00:12:35
Pero ya que es cabeza... 00:12:41
Primer paso. 00:12:42
¿Creo el objeto? 00:12:43
Creo el objeto. 00:12:43
¿Vale? 00:12:45
Creo el nuevo nodo. 00:12:46
Tengo un nodo, no puedo hacer nada. 00:12:47
¿Vale? 00:12:50
Entonces, el primer paso es, creo un nuevo nodo. 00:12:51
Nodo nuevo es igual a new nodo element. 00:12:54
Pues ya está. Por algún lado del multiverso, ¿dónde lo ha creado? 00:13:01
¿Dónde se ha creado este objeto? Os suspendo a todos. 00:13:12
En el heap, que es donde se crean todos los objetos de Java. 00:13:27
en el heap, como si fuera la primera vez que lo digo, pero lo hemos dicho ya, hay una zona de la memoria que se llama heap, que quiere decir montón, que es donde se crean los objetos, en el heap se ha creado un objeto nuevo tipo nodo, donde, no tengo ni idea, dentro que tiene, el objeto que me ha pasado, como siguiente quien tiene, null, 00:13:31
¿Está enlazado con esta lista? No, ¿vale? Nuestra situación es que yo ahora tengo una lista enlazada con cabeza null y he creado por algún lado un objeto con dentro el contenido que me han pasado, ¿vale? 00:14:04
y un enlace a null. Otro nodo null. ¿Está de acuerdo? Esta es la situación actual. Es lo que he hecho aquí. 00:14:31
Esto. ¿Dudas? Yo, en lugar de crear un objeto, lo que hice fue, cuando ya era el momento de asignar cabeza al siguiente, 00:14:40
Pero aquí hay dos cosas. El objeto no es todo el objeto. El objeto que tú creas es un nodo, 00:14:56
porque luego tú querrás saber su contenido es su siguiente pero tú al ingresar ese objeto en teoría 00:15:24
tendrías que ingresar un nodo no esto no es un nodo es un objeto que tú quieres añadir tú cuando 00:15:31
añades añades un gato no añades un nodo con dentro un gato tú cuando cuando lo usabas antes no añades 00:15:37
un array con dentro del gato tú añades meteme este gato pues el gato se pondrá en el array o se pondrá 00:15:44
donde sea, pero tú lo que estás, cuando nosotros lo utilizamos aquí en el mail, tú lo que estás haciendo es poniendo un objeto. 00:15:49
Claro, es que en mi hipotético mundo siempre va a ser un nodo. 00:16:01
Tú por dentro creas un nodo, pero por fuera de la lista no puedes forzar que sea un nodo. 00:16:07
¿Por qué no puedes forzar que sea un nodo? Porque la lista te dice añádeme un objeto, no añádeme un nodo. 00:16:13
Entonces, y aquí te puede añadir, en tu caso, si tú has pensado que esto que se añade es un nodo, en cuanto tú intentes hacer esta cosa de aquí, que era mi main, te vas a explotar. 00:16:19
Porque esto, haciendo un downcasting al nodo, no te funciona. 00:16:31
Y nosotros habíamos dicho, técnicamente, que yo puedo pillar este mismo código, cambiar que aquí, en vez de usar mi lista array, poner mi lista enlazada, 00:16:37
y esto tiene que funcionar 00:16:47
porque las llamadas son las mismas 00:16:50
y si tú me estás diciendo 00:16:52
que la lista recibe un object 00:16:54
no lo puedes forzar a que sea un nodo 00:16:56
otra cosa es que aquí te pusiera nodo 00:16:58
entonces ya sé que tú me tienes que 00:17:00
añadir un nodo, pero 00:17:02
si me pones un object, no me puedo 00:17:04
yo, esto es 00:17:06
el objeto que se guarda 00:17:08
¿sí? 00:17:10
vale 00:17:12
entonces, he creado 00:17:12
el nuevo nodo. Ahora, ¿qué tengo que hacer? Tengo que buscar el final de mi lista. ¿Cómo 00:17:16
encuentro el final de mi lista? Empezando por cálculo. 00:17:33
¿Y haciendo qué? Preguntándole, oye, ¿tienes alguien después 00:17:38
Entonces, yo empiezo con, por ejemplo, nodo último es igual a cabeza. 00:17:45
Digo, empiezo por la cabeza. 00:17:59
Y aquí voy buscando el siguiente, siguiente, siguiente, siguiente, hasta que llegue al final. 00:18:02
Y aquí tengo dos casos. 00:18:11
El primer caso es que cabeza misma sea nula. 00:18:13
Si último, lo puedo hacer así, si cabeza es nul, entonces quiere decir que mi lista está vacía. 00:18:17
Entonces es fácil, ¿qué hago? 00:18:33
Cabeza siguiente, igualmente. 00:18:38
No, cabeza igual. 00:18:43
Cabeza con terminos. 00:18:50
Cabeza punto con terminos. 00:18:52
¿Qué tipo tiene cabeza? 00:18:56
Nodo. 00:18:58
¿Y este es un? 00:18:58
Nodo. 00:19:00
Pues le digo que mi cabeza apunta al nuevo nodo. 00:19:00
Ya está. Se acabó. Ya lo he metido. 00:19:05
Es el primero de la lista. 00:19:08
Antes estaba null. 00:19:09
No puedo hacer cabeza punto contenido. 00:19:10
Bueno, aquí. 00:19:15
¿Es que esto qué me daría? 00:19:19
¿Qué pasa si hago esto? 00:19:23
Null pointer exception. 00:19:30
Si estoy preguntando si cabeza es null, por lo tanto aquí cabeza es null, 00:19:31
no puedes hacer cabeza punto algo, porque me dará siempre un null pointer exception. 00:19:34
no existe el objeto todavía es un puntero vacío pero yo te digo vale ok este puntero de aquí esta 00:19:39
referencia ahora se referencia al objeto nuevo que creado sustancialmente en mi mundo estaba 00:19:47
en esta situación he creado este objeto quito el nul de aquí y le digo que esta referencia apunta 00:19:55
este objeto. Ya está, he creado una lista con un objeto dentro. La cabecera de esta lista pasa a 00:20:03
ser el nuevo nodo que he creado. Esto en el caso en que mi lista tenía una cabecera null. Si la 00:20:11
cabecera es null, quiere decir que no hay nada, pues este nodo es la cabecera. Os queda claro 00:20:20
en castellano 00:20:28
si yo tengo una lista sin cabeza 00:20:29
y tengo que añadir un nuevo elemento 00:20:32
ese nuevo elemento será un nodo 00:20:34
que será la cabeza de la lista, porque es el único 00:20:36
que hay 00:20:38
¿sí? ¿dudas? 00:20:38
¿dudas? 00:20:45
esa es la pregunta 00:20:46
¿qué es lo que está haciendo? 00:20:46
¿qué es la cabeza? porque no existe 00:20:48
la cabeza por ahora es null, quiere decir que no apunta 00:20:49
en ningún objeto, no puede hacer nada sobre él 00:20:53
si la cabeza es null 00:20:55
pues lo que hago es decir 00:20:57
Oye, mira, muy bien. Tu nuevo objeto eres la cabeza de mi lista. Y esto se hace así. ¿No veis que se hace así? Si la cabeza es nula, pues entonces nuevo es la cabeza. ¿Sí? 00:20:58
Si no, si esto no es verdad, quiere decir que ya antes se ha añadido a alguien, y por 00:21:16
lo tanto cabeza no es null, y por lo tanto se puede empezar a navegar la lista, que quiere 00:21:28
decir navegar. 00:21:39
Que yo empezaré desde cabeza y diré, ves al siguiente, y si el siguiente existe, diré 00:21:40
va a ser el siguiente. Y si el siguiente existe, va a ser el siguiente. Y si el siguiente no 00:21:46
es el siguiente. ¿Vale? Hasta llegar al fondo de la lista. 00:21:50
La cabeza sigue siendo el primer. La cabeza sigue siendo el primer. 00:22:04
Yo no pillo cabeza. Yo voy navegando la lista desde cabeza, porque ahí es donde 00:22:10
empieza mi lista, hacia el último nodo. Y ahora vamos a ver cómo se hace. 00:22:15
Vamos a ver, no lo he hecho. Esto no es la solución. Os estoy diciendo qué voy a hacer, 00:22:22
¿os molesta esto? Lo que tengo que hacer es empezar desde cabeza e ir navegando. Es que veis 00:22:32
el código y ya no razonáis, porque yo lo he dicho, ya está grabado, ahora lo escucháis en casa. Mientras 00:22:41
Ellos decían que voy a hacer, vosotros me echabais el código y decíais, no lo haces. 00:22:47
Pues no, no lo hemos hecho el código. 00:22:51
Pero no se puede picar código si no entendéis que se lo haces. 00:22:53
¿Vale? 00:22:57
Entonces mi idea es, empezaré desde cabeza y voy buscando el siguiente, el siguiente, el siguiente, el siguiente, hasta encontrar el último. 00:22:57
¿Cuál será el último? 00:23:07
El que tenga... 00:23:12
La base. 00:23:14
Es que tenga como siguiente nul. 00:23:15
Cuando yo me pillo un nodo, a partir de cabeza, y le pregunto ¿tu siguiente es nul o no? 00:23:23
Si tu siguiente no es nul, voy al siguiente. 00:23:33
Si tu siguiente es nul, tú eres el último. 00:23:38
¿Método que hago? 00:23:43
Voy a buscar el nodo último. 00:23:45
Dejádmelo hacer y luego, si no lo entendéis, 00:23:47
se lo hacemos preguntar, porque si no, no avanzamos. 00:23:49
Entonces, me pillo una deferencia 00:23:52
a la cabeza. 00:23:54
Y me pregunto, 00:23:56
me digo, mientras 00:23:57
último 00:23:59
punto siguiente 00:24:02
no es nul, 00:24:05
último es igual 00:24:11
a último punto 00:24:13
siguiente. Empieza desde la cabeza. Voy a mirar siguiente. Si siguiente no es nul, este 00:24:15
último ya no es esto, más el siguiente. Y ahora voy a mirar si su siguiente no es 00:24:32
nul, último no es esto, más esto. Y si este tiene siguiente que no es nul, pues último 00:24:38
no es esto, más esto. Hasta llegar a uno que cuando voy a mirar último punto siguiente 00:24:45
me dice es null. 00:24:50
Entonces salgo de este while 00:24:52
y mi último me está 00:24:54
apuntando al último nodo. 00:24:56
O sea, estás buscando el último. 00:24:59
Sí, por eso se llama último. 00:25:01
Lo repito. 00:25:05
¿No? 00:25:07
Si quieres, 00:25:13
si quieres esta cosa de aquí, 00:25:14
la puedes poner en 00:25:16
un método que se llama busca último 00:25:18
que hace esta cosa de aquí 00:25:21
y te devuelve un nodo y aquí se queda 00:25:23
más limpio, el último es igual a 00:25:25
busca último 00:25:27
esto no es un método 00:25:27
pero si es un método 00:25:34
lo tendría que sacar 00:25:36
pero, fijaos 00:25:37
este es un código que lo que hace es buscar el último 00:25:39
¿como funciona? 00:25:42
vamos a verlo aquí 00:25:46
en una lista ya creada, esta de aquí 00:25:47
Porque hemos dicho que, fijaos, que si cabeza es nul, ya lo hemos hecho antes. 00:25:50
O sea, es una parte distinta. 00:25:58
Si yo llego aquí, a este else, quiere decir que cabeza no es nul. 00:26:00
Cabeza ya es un objeto. 00:26:05
Entonces, imaginámonos que tengo esta lista de aquí. 00:26:07
Entonces, mi cabeza es este objeto de aquí. 00:26:11
Este es el objeto. 00:26:14
Entonces, yo me creo una referencia última que apunta a este objeto. 00:26:15
Esto es último. 00:26:22
¿Sí? 00:26:23
Y empiezo y digo, me pregunto, último punto siguiente, ¿es nulo o no? 00:26:26
¿Es nulo o no? 00:26:36
Hola, último punto siguiente, este campo de aquí, aquí dentro, ¿hay nulo o no? 00:26:42
No. 00:26:50
Por lo tanto, último punto siguiente no es nul, por lo tanto, yo digo que último es 00:26:51
igual a último punto siguiente, o sea, que esta referencia de aquí es igual a esta referencia 00:26:57
de aquí. 00:27:04
Es decir, que ahora no apunto a esto, más apunto a esto. 00:27:05
¿Y repite el último punto? 00:27:09
Me acuerdo que esa es una referencia, que se referencia a cabeza porque lo he puesto 00:27:13
aquí. 00:27:20
Ahora te digo que si último punto siguiente, o sea, si yo me voy a este objeto, porque último apunta aquí, 00:27:21
me voy a su campo siguiente y encuentro que aquí no hay null, hay null, no. 00:27:28
Pues entonces ejecuto esta cosa aquí, que me dice que en la referencia de último aquí dentro, 00:27:36
ahora pon lo que hay en último punto siguiente. 00:27:42
O sea, me voy a último, me voy a punto siguiente, último punto siguiente es este objeto de aquí, 00:27:45
y lo guardo dentro de la referencia de último. 00:27:52
O sea, que si el siguiente, si fuera el último, estaría a punto de ir a un nudo. 00:27:57
Ahora llegamos. 00:28:03
Claro, en este caso... 00:28:04
Ahora estoy aquí, no he acabado, porque el while no ha acabado. 00:28:07
El while vuelve aquí y se pregunta, último punto siguiente, ¿no es null? 00:28:12
Voy a mirar, ahora último apunta a este, me voy a mirar su siguiente, ¿y qué pone aquí? 00:28:20
Null. 00:28:28
Por lo tanto, salgo del while. 00:28:29
Y cuando llego aquí fuera del while, último está apuntando al último elemento de la lista. 00:28:32
¿Lo veis? Hacemos un ejemplo con tres. No tengo una lista con tres. No, hagamos una lista con tres. 00:28:39
Entonces, imaginaos que estamos en esta situación de aquí. Tengo una lista, que es esta de aquí, 00:28:46
que tiene la cabecera que apunta a este nodo de aquí. Este es un nodo que tiene un objeto y un 00:29:05
un puntero a otro nodo. Que tiene un objeto y un puntero a otro nodo. Y este de aquí tiene un 00:29:16
objeto y null, el último de la lista. Entonces, ¿qué hago yo? Entro en este while, entro en esta 00:29:26
parte de aquí, ¿vale? Entro en el método add. Me pregunta, ¿cabecero es igual a null? No, 00:29:37
No, porque cabecera apunta a un objeto, por lo tanto no es null. 00:29:44
Me salto esta parte del if, voy al elche, me dice, ok, créame una referencia que se 00:29:48
llama último, esta referencia aquí, que apunta a cabecera, aquí, ¿estamos a acuerdo hasta 00:29:54
aquí? 00:30:07
No apunta a donde apunta cabecera, estoy copiando lo que está aquí dentro, lo estoy copiando 00:30:09
aquí dentro. Por lo tanto, apuntan al mismo objeto. ¿Duda hasta aquí o no? 00:30:15
Hola. Vale. Entonces me pregunta, ¿último punto siguiente es distinto de null? 00:30:22
Último punto siguiente, ¿es null o no? No, es distinto de null. Por lo tanto, este while 00:30:33
es true. Esta condición es true. No es null. Por lo tanto, entro dentro y ejecuto. ¿Qué 00:30:43
dice esto? Dice, píllame último punto siguiente. ¿Quién es último punto siguiente? Último 00:30:51
punto siguiente. Es este nodo de aquí. Esto lo guardas dentro último. Quitas esto y haces 00:30:57
esto es como cuando hacíamos 00:31:09
x es igual a x más 5 00:31:13
¿os acordáis? 00:31:15
x es igual a x más 5 00:31:17
¿qué hacía? 00:31:18
si x vale 3 00:31:22
porque dices, píllame lo que hay dentro de x 00:31:23
suma de 5, hace 8 00:31:28
y me lo guardas en x 00:31:30
por lo tanto borras esto y pones 8 00:31:32
¿os acordáis? 00:31:34
es lo mismo 00:31:38
tú te estás diciendo dentro de último 00:31:38
que es una referencia a un objeto, ponme último punto siguiente. Entonces el siguiente objeto. 00:31:40
Y ahora aquí dentro esta referencia se ha borrado y último apunta a este objeto de aquí. Y vuelvo 00:31:48
al principio del while y me pregunto, último punto siguiente, es nulo o no? Pero esta vez último no 00:31:55
es este, porque ya he borrado esta referencia. Ahora último es este objeto de aquí. Llamamos 00:32:02
este es N1, esto es N2 y esto es N3. Ahora estoy apuntando a N2, ¿sí o no? 00:32:08
Entonces me va a preguntar, N2 punto, o sea, último punto siguiente, ¿es nulo o no? 00:32:16
No, porque tiene un puntero justo. Entonces, ¿qué hago? Me voy a mirar aquí y entro dentro, 00:32:26
y digo que último, dentro último, guárdame la referencia de último punto siguiente. Último es 00:32:35
esto, punto siguiente es este objeto de aquí, por lo tanto se borra esta referencia y se apunta a 00:32:43
esto y vuelvo al while y me pregunto último punto siguiente es distinto de null ahora no ahora este 00:32:51
de aquí apuntado por último punto siguiente es null por lo tanto no entro dentro del while y 00:33:08
salgo aquí fuera. Y después de esto while, en el campo último, en la variable último, 00:33:16
estoy apuntando al último objeto de la lista. He recorrido la lista hasta encontrar el último. 00:33:24
Yo tengo un puntero, un nodo. Último es un nodo. Y ahora tengo contenido y siguiente 00:33:36
del último nodo. Último me apunta al nodo último que he añadido, anterior que he añadido. 00:34:03
Entonces ahora tengo todos los elementos. Tengo el último de la lista guardado en último 00:34:10
Y el nuevo objeto que quiero añadir, que es esto, que he creado antes, ¿vale? 00:34:17
Este de aquí con un nuevo objeto y null es el que he creado aquí. 00:34:22
¿Recordáis? 00:34:28
Este es el nuevo elemento que quiero añadir, el nuevo nodo que quiero añadir, 00:34:28
con dentro el elemento que me has dicho de añadir. 00:34:34
Entonces, ¿qué tendré que hacer aquí? 00:34:38
Último punto siguiente es igual a el de aquí. 00:34:42
Último punto siguiente es igual. 00:34:46
En nuestra gráfica, último punto siguiente, que era null, ahora en vez de null, haz que apunte al nuevo objeto que he creado. 00:34:51
Y ahora el último es este, que ya tiene null allí, entonces la siguiente vez que añado algo, me volverá a hacer este último que lo pone en cabeza, pasa aquí, pasa aquí, pasa aquí, encuentra null. 00:35:10
Y ahora encuentra este volumen y lo añadirá después. 00:35:26
¿Y ese sería el primero de la lista? 00:35:32
¿Quién? 00:35:34
El último. 00:35:35
No. 00:35:36
¿Pero de la lista quién es? 00:35:37
Cabeza. 00:35:38
Cabeza. 00:35:39
Por eso se llama cabeza. 00:35:40
Nosotros, por la lista que hemos creado, nos dice, explícitamente, se añade al final. 00:35:45
porque si lo añadiera al principio sería más fácil y yo cabeza lo apuntó al nuevo y siguiente es la 00:35:55
cabeza vieja pero aquí me han dicho que lo tengo que añadir al final 00:36:08
pero eso después 00:36:14
dudas hasta aquí se puede mejorar esto claro pero me interesa esta cosa de aquí 00:36:39
si la entendéis o no. No que seáis capaces de replicarla para los próximos dos o tres 00:36:51
días, pero entendéis que estoy haciendo o no. Porque aquí, la base aquí es que nosotros 00:36:59
hemos hablado de referencias, hemos hablado de objetos, hemos hablado de referencia a 00:37:07
un objeto, de variables de tipo objeto y hemos hablado de instancias de objetos. Pero vosotros 00:37:11
No le veis la diferencia. 00:37:17
Aún así lo hemos usado. 00:37:20
Hemos visto, por ejemplo, en el polimorfismo que se utiliza el método que está más cerca de la instancia, no de su referencia. 00:37:21
Entonces, ahí hemos visto que referencia e instancia son dos cosas distintas. 00:37:28
Aquí lo que estoy haciendo es jugar con la referencia. 00:37:34
Estoy cambiando la referencia de último a varias instancias distintas. 00:37:38
Ahora apuntas a este objeto, ahora apuntas a este otro objeto, ahora apuntas a este otro. 00:37:43
Estoy copiando el numerito que está aquí, aquí. 00:37:48
Y entonces ahora no me apunta a esta zona de memoria, me apunta a esta zona de memoria, donde está el segundo objeto. 00:37:57
Luego copio esto, aquí. Entonces ya no me apunta a esta zona de memoria, me apunta a la tercera zona de memoria. Y sigo así. 00:38:04
No, puedo pasar del primero al último porque no tengo un salto para llegar al último y 00:38:11
puedo solo saltar al siguiente. Como lo estamos implementando nosotros, así es. 00:38:35
Luego, ¿que queremos mejorarlo? Sí. 00:38:44
¿Puedo hacerme un array que apunta 00:38:47
a cada uno de los elementos? Sí, pero entonces 00:38:48
vuelvo a los array. 00:38:50
No quiero. 00:38:53
¿Sí? Ahora, 00:38:56
no está en lista. 00:39:00
¿Vale? Add es 00:39:02
lista, pero nosotros creamos 00:39:04
ahora aquí, porque nos gusta, 00:39:06
public void 00:39:08
addFirst 00:39:10
object 00:39:11
element. 00:39:14
AddFirst 00:39:17
es un método especial 00:39:18
de lista enlazada, no es 00:39:20
de lista, o sea que si tú 00:39:22
usas lista no lo puedes usar, pero 00:39:24
si usas una lista enlazada sí 00:39:26
¿vale? donde te está diciendo 00:39:28
añádelo primero 00:39:30
no lo añadas al fondo 00:39:32
como es la add normal 00:39:33
pero quiero que se añada como 00:39:35
primero de la lista 00:39:38
¿cómo añado un elemento 00:39:39
primero de la lista? primero me creo 00:39:42
nodo nuevo 00:39:44
es igual a new nodo de elemento. Vale, he creado el nuevo nodo. Ahora, para entendernos, 00:39:46
no quiero crearlo y añadirlo aquí. Lo quiero meter aquí. ¿Cómo lo hago? Aquí. Añado primero 00:39:57
Entonces tengo mi nuevo nodo con dentro no sé qué, con null detrás. ¿Qué hago? 00:40:09
La referencia de la cabecera. 00:40:19
Cabeza, punto siguiente, es igual al nuevo, ¿os gusta? 00:40:27
No estoy sobreescribiendo nada. 00:40:50
Cabeza, punto siguiente, igual a nuevo. Y después tienes que, de nuevo, punto siguiente, igual a cabeza, punto siguiente, más arriba. 00:41:12
La estoy mirando como un rey, creo. Yo también. 00:41:24
Si yo hago esto, ¿qué he hecho? He dicho que cabeza no apunta aquí, 00:41:29
Va, apunta aquí. 00:41:40
Resultado. 00:41:42
Me he cargado la lista. 00:41:44
He perdido toda esta referencia. 00:41:48
Porque van en cadena. 00:41:53
Si quitas del primero, 00:41:55
todo lo demás van, puede igual. 00:41:56
Si ahora intento hacer cabeza aquí, 00:41:58
cabeza, punto siguiente, 00:42:01
cabeza, punto siguiente, 00:42:03
es nulo. 00:42:05
He acabado. 00:42:06
Me he cargado todo el resto de la lista. 00:42:07
En el cable, referenciando a N2, hago punto siguiente, es igual a, puede ser punto siguiente, punto siguiente, es igual a, 00:42:17
Yo antes de hacer esto, pillo, o sea, antes de hacer esto, lo que hago es pillar y decir, 00:42:42
al nodo nuevo, copio en su siguiente, nuevo punto siguiente, le copio a donde apunta cabeza, 00:43:13
esto. Se lo copio aquí. Entonces ahora esto apunta aquí. Y después de haber guardado 00:43:24
esta referencia, borro esto y apunto aquí. Entonces ahora sí me funciona. Y es mucho 00:43:34
más sencillo que añadirla al final. No tengo que recorrer todo. 00:43:50
Y el nuevo apuntaría al siguiente nodo. 00:43:58
He copiado lo que antes, antes de hacer el cambio, he copiado a donde apuntaba 00:44:05
cabeza, lo he copiado en su siguiente. 00:44:13
Por lo tanto, se ha quedado, se ha quedado guardado este enlace de aquí, esta referencia de aquí. 00:44:18
Entonces, ahora tengo N1 en posición 2. 00:44:25
Y después he borrado la cabeza que apuntaba N1 y le he dicho, la cabeza ahora es este nuevo. 00:44:29
Pero se ha quedado que si yo hago cabeza, punto siguiente, me estoy yendo a este. 00:44:39
Punto siguiente a este, punto siguiente a este. 00:44:45
Que me ha quedado toda la lista, no la he perdido, añadiendo el nuevo elemento, en vez que al final, al principio. 00:44:48
Dejadme hacer así. 00:45:06
Tengo una lista vacía. 00:45:16
Esta lista vacía tiene una referencia a null. 00:45:23
¿Estamos de acuerdo? Voy a utilizar ADD por ahora, no ADD first, ADD, el que añade al final. 00:45:29
Entonces, ¿qué hago? Añado un nuevo elemento. Vale, creo un nuevo nodo, que da N1, con dentro un objeto, y aquí null. 00:45:41
¿Estamos de acuerdo con esto? Y luego modifico cabecera, que no es un objeto, es un puntero, 00:45:53
le quito el null de dentro y le pongo un enlace a n1. ¿Estamos de acuerdo con esto? Entonces, 00:46:06
La cabecera es ésta, tiene un solo elemento. Si ahora uso otra vez add, creo un segundo 00:46:26
objeto en una posición de memoria que llamaré n2, que tiene dentro su objeto no sé qué, 00:46:35
que apunta null, luego pillo una referencia que se llama último, le pongo que dentro 00:46:44
tiene lo que tiene ce, o sea la cabecera, la cabeza, o sea n1, y voy a n1, o sea que 00:46:55
esto es un entero aquí, y voy a n1 y le pregunto, oye mira, n1 punto, perdón, que antes se 00:47:03
me ha olvidado, no, ok, n1 punto siguiente es nul, sí, por lo tanto el último es n1. 00:47:10
Y si os acordáis cómo funcionaba ADD, ahora le digo, vale, entonces al último punto siguiente le pongo N2, es decir, que borro esto, y aquí dentro le pongo N2, para que apunte aquí. 00:47:20
Y he añadido como último N2. ¿Dudas? Hay un borrador. Borrar, borrar. 00:47:41
Este último ya no me interesa, lo borramos, porque solo se usa cuando añado. 00:47:55
¿Sí? ¿Dudas hasta aquí? Voy a añadir uno primero. Ahora voy a usar Add First. 00:48:06
Entonces, ¿qué hace Add First? Sigámoslo aquí. 00:48:14
Add First me dice, crea un nuevo nodo. Vale, creo un nuevo nodo. 00:48:19
un nuevo nodo, lo creo aquí, por ejemplo, esa hará el nodo 3, o sea, en posición de memoria N3, 00:48:31
sea lo que sea lo que quiera decir. ¿Vale? Con dentro su elemento y una referencia null. 00:48:38
Vale, muy bien. Ahora, ¿qué me dice? Me dice, nuevo punto siguiente, nuevo es esto, 00:48:47
Punto siguiente es este de aquí. Es igual a cabeza. Es decir, que aquí quito el null y pongo n1. 00:48:57
Estoy copiando dentro de esta referencia lo que está escrito dentro de esta referencia. 00:49:16
Es decir, que ahora esto es un puntero aquí. Y después digo, cabeza, punto siguiente igual nuevo. 00:49:23
No. Esto es cabeza. Esto lo veo, se me ha quedado de lado. Esto es así, cabeza igual nuevo. Así. Justo. 00:49:36
O sea, que digo que cabeza, ahora en vez que N1, me quitas N1 y guardas aquí. 00:49:51
Y ahora aquí dentro pones, ¿cómo se llama esto? N3. 00:50:11
Porque cabeza es un nodo y directamente apunta al primero de la lista. 00:50:22
No sé por qué había escrito siguiente allí, creo que antes hicimos una prueba o cosa por el estilo y no funcionó, pero bueno, debería ser así, ¿vale? 00:50:33
Cabeza lo sustituyo con el nuevo nodo que he creado. 00:50:40
Entonces ahora, cabeza va a N3 y desde dentro de N3 encuentro la referencia para llegar a N1, porque la he guardado antes. 00:50:48
El problema es si esto lo hago al revés, o sea, antes hago la cabeza, pues pierdo la referencia. 00:50:58
Si yo hago cabeza nuevo aquí, sustituyo esto con n3 y he perdido n1. 00:51:04
Ya no tengo escrito n1 por ninguna parte, entonces no lo puedo añadir aquí. 00:51:12
Pero mi pregunta es, ahí la cabeza solo tiene referencia a n1. 00:51:16
O sea, no tiene un contenido como tal. 00:51:27
Si tú haces cabeza.contenido, estás accediendo a esto. 00:51:30
en el 3 ahora si haces cabeza punto siguiente estás haciendo a esto 00:51:39
entonces tú le estás pasando todo esto como referente apunta al primero 00:52:03
es el nuevo objeto que has creado 00:52:10
tú acabas de crear este objeto nuevo 00:52:20
es lo que quieres insertar 00:52:26
entonces a este objeto de aquí 00:52:28
tú tendrás una variable nuevo aquí 00:52:30
como antes tenías una variable 00:52:32
que tiene dentro 00:52:34
o sea un puntero aquí 00:52:37
y entonces una vez que tienes esto 00:52:39
nuevo punto siguiente sería n3 punto siguiente guardas la cabeza lo que estaba antes aquí o sea 00:52:43
n1 lo guardas aquí y luego cabeza es igual al nuevo o sea el principio es n3 copias esto aquí 00:52:50
y tienes tú un lado lo que a mí me confunde es que tú estás apuntando a toda la cabeza toda la 00:53:02
cabeza no solo es N1, en teoría, también es contenible, entonces… 00:53:14
Pero es como cuando tú tienes una casa, cuando tú creas una persona, un alumno, tú tienes 00:53:25
Por un lado, y haces alumno a es igual a new alumno, con sus datos. 00:53:39
Tú por un lado te creas el objeto, donde tienes el nombre, el apellido, las materias, los profesores, lo que sea. 00:53:50
Pero esta cosa de aquí, que es la referencia, es una variable de tipo alumno que se llama a y que 00:53:59
tiene una referencia a la zona de memoria donde están las cosas. Tú no tienes aquí dentro el 00:54:12
el objeto. Tú aquí dentro tienes la referencia al objeto. O sea, dónde buscarlo dentro del 00:54:20
I. Un código, que nosotros hemos llamado N1 y esto será A1, aquí dentro está escrito 00:54:27
A1, que es la zona de memoria donde lo vas a encontrar. Entonces, cuando tú luego haces 00:54:34
A punto nombre 00:54:40
Lo que estás haciendo es 00:54:42
Vete a esta zona de memoria 00:54:45
Aquí 00:54:48
Y desde aquí busca nombre 00:54:49
Esto 00:54:52
Entonces, cabecera 00:54:53
No apunta al siguiente 00:54:59
Apunta a un objeto 00:55:02
Es el primo objeto de mi lista 00:55:03
¿Cuál es? 00:55:05
Todo este objeto 00:55:06
Luego tú podrás preguntar 00:55:07
Cabeza punto contenido 00:55:10
entonces llegarás a este objeto 00:55:12
e irás a la parte de contenido 00:55:14
o cabeza punto siguiente 00:55:16
entonces llegarás a esta cabeza 00:55:18
y te irás al siguiente 00:55:20
entonces alcanzarás el siguiente 00:55:22
o sea, primero 00:55:24
vas apuntando a la referencia 00:55:26
para después apuntar al siguiente 00:55:28
si quieres 00:55:30
pero si tú 00:55:33
apuntas solo a las referencias 00:55:34
si tú apuntas solo a la cabeza 00:55:37
estás llegando al objeto entero 00:55:38
si quieres aquí no lo estoy haciendo aquí como esto es un nodo esto es un nodo estoy 00:55:40
solo cambiando la referencia como si estoy diciendo alumno ahora es de 00:55:54
estoy cambiando que a en vez de apuntar al primer alumno apunta a otro alumno 00:55:57
a un alumno distinto todo el alumno apuntaba antes todo el alumno apunta ahora pero son 00:56:04
dos objetos distintos. Antes cabeza apuntaba al primer objeto nodo que representaba el primero 00:56:08
de la lista, ahora apunta a otro objeto nodo que se representa el primero de la lista. 00:56:14
Claro, entiende que en este caso n3 apunta acá. Es decir, que hace una... 00:56:18
No, es que cabeza contiene n3 que apunta al primer elemento nodo, al primer objeto nodo de la lista. 00:56:24
Entonces, con esto hemos hecho el add. 00:56:32
Antes de poder hacer algo, tenemos que escribir este señor. 00:56:46
No sabemos cómo escribirlo. 00:56:51
Entonces, lo que vamos a hacer ahora es crear el show, ¿os acordáis que teníamos show? 00:56:52
así, si tenemos a 00:57:00
the show, podemos empezar a hacer 00:57:02
pruebas, a añadir cosas 00:57:04
a la lista y luego enseñarme si efectivamente lo he 00:57:06
hecho bien. 00:57:08
Entonces, ¿cómo 00:57:10
hacemos show? 00:57:11
Pues show debería 00:57:14
recorrer mi lista 00:57:15
y por cada elemento de 00:57:17
nodo, por cada nodo, perdón, 00:57:19
enseñarme lo que contiene. 00:57:22
Entonces 00:57:27
empiezo por cabeza 00:57:27
y imprimo el contenido de cabeza. 00:57:29
Luego me voy al siguiente. Imprimo el contenido del siguiente. Luego me voy al siguiente. Imprimo el contenido del siguiente. Me voy al siguiente. ¿Hasta cuándo? 00:57:32
Hasta null. Entonces, nodo actual es igual a cabeza. 00:57:40
Empiezo por cabeza. Dile actual no sea null. 00:57:47
lo que hago es actual.contenido, lo tengo que guardar por algún lado, 00:58:01
entonces hacemos un string, de verdad un string, string res es igual a nada. 00:58:13
Entonces, mientras actual no sea nul, res es igual a res más, 00:58:20
le pego detrás 00:58:30
actual.contenido.tostring 00:58:31
que será la representación 00:58:34
en formato string del contenido 00:58:41
todos los objetos la tienen 00:58:42
porque tu string es de 00:58:44
¿qué clase es tu string? 00:58:46
object, entonces o tiene 00:58:50
el de object o tiene una 00:58:52
versión mejorada para 00:58:54
ese objeto, pero lo tiene 00:58:56
entonces si yo te digo 00:58:58
vete al actual, al nodo actual 00:58:59
pilla su contenido 00:59:02
y escríbemelo como un string. 00:59:05
Y pégamelo al resultado. 00:59:07
A lo mejor lo separo por coma. 00:59:10
¿Sí? 00:59:17
Y después de haber hecho esto sobre el 00:59:18
nodo actual, antes de 00:59:21
volver aquí, ¿qué hago? 00:59:23
Paso al siguiente. 00:59:30
Que podría ser null, pero si es null 00:59:34
no entrará aquí. Habrá llegado 00:59:36
al final. Si no es null, 00:59:38
me añade el contenido del siguiente 00:59:40
y pasa al siguiente. 00:59:42
Si su siguiente es null, pues 00:59:44
habrá acabado. Si su siguiente no es null, pues pasará al siguiente. Y así, así, así. Al final, 00:59:46
return es. Entonces, esta empezará aquí, dice actual. Esta actual apunta a donde apunta cabeza, 00:59:52
pues a este de aquí. Escribe su contenido. Y luego, actual es igual al actual, o sea, 01:00:08
este de aquí, punto siguiente. Por lo tanto, borro esto y lo apunto al siguiente. 01:00:16
Ahora añado este de aquí, borro esto y apunto a su siguiente. Entonces voy aquí, 01:00:21
escribo este de aquí, borro esto y voy a su siguiente, que es null. Por lo tanto 01:00:29
salgo y devuelvo rest. Ahora vamos a ver si esto funciona. 01:00:35
Necesito main, mi lista enlazada. Mi lista enlazada y aquí pongo main. Y el main me dice, tengo main, crea una lista enlazada. Lista enlazada, le es igual a new lista enlazada. 01:00:42
Y ahora puedo hacer le.add y puedo hacer siso le.show. Vamos a ver si funciona. 01:01:19
Está escribiendo add, que es el único elemento. Me pone un coma adelante porque siempre he puesto 01:01:40
esto en forma de arco. Lo puedo poner detrás. Por ahora no da igual. Ahora ¿qué hago? Añado 01:01:48
uno nuevo. lee.add perro. ¿Dónde me lo tiene que ir a juntar? Al final. Hace que no lo 01:01:58
Y lo voy a escribir. Y ahora puedo hacer, oye, mira, lee.addFirst, ok. Ahora me lo tiene que 01:02:12
añadir primero. Si no lo escribo, no me lo escribo. Mi lista está funcionando. Fijaos que 01:02:32
si yo pillo el otro main, todavía me falta busco, pero esto es igual, le da igual, porque 01:02:58
yo lo estoy utilizando como lista, fijaos que aquí puedo usar addFirst porque esto 01:03:14
es una lista enlazada, pero yo podría hacer esto, porque lista enlazada es una lista, 01:03:20
Lo único es que ahora esto no lo puedo usar porque dentro del contrato de lista no está AdWords. 01:03:29
Podría hacer un downcasting de ley para que sea una lista enlazada, entonces sí que me 01:03:45
funcionaría. 01:03:50
No me funcionaría si fuera una lista de Array, ¿sí? 01:03:51
Dudas hasta aquí. 01:03:59
Con esto nosotros hemos hecho e implementado dentro de nuestra lista enlazada el show, el add, el add first, que es una cosa adicional que hemos añadido nosotros. 01:04:07
Ahora vosotros vais a implementar size. 01:04:23
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
1
Fecha:
3 de febrero de 2026 - 13:45
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 04′ 39″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
542.51 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid