Saltar navegación

20250131 Linked List 1 - 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 31 de enero de 2025 por Stefano C.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, voy a grabar la clase hoy, por lo tanto si habláis me dais el permiso de grabar vuestra voz. 00:00:00
La última vez estuvimos haciendo un ejercicio de intentar esconder detrás de un objeto lo que era un array. 00:00:04
O sea, nosotros hemos llegado a un momento en que los arrays nos molestan, entre comillas, 00:00:18
o sea, son útiles, seguiremos utilizando y cosas así, pero son engorrosos de utilizar. 00:00:23
Entonces hemos dicho, ¿por qué no creamos unos métodos que nos esconden lo que hacemos normalmente con los arrays? 00:00:28
Es un poco el mecanismo que hacemos siempre, ¿vale? 00:00:37
Es decir, nosotros aprendemos cómo se hacen las cosas y luego abstraemos estas cosas y hacemos que otros más las hagan para nosotros. 00:00:41
todo lo que es el API de Java, todo lo que es el JDK 00:00:50
que viene con un mogollón de clases ya hechas 00:00:54
y que nosotros utilizamos, in primis string 00:00:59
nosotros desde el día uno estamos utilizando la clase string 00:01:01
y no la hemos hecho nosotros, es un objeto que ha hecho alguien más 00:01:04
sin embargo lo utilizamos como abstracción 00:01:08
si no deberíamos estar trabajando con Array de Char 00:01:11
y nosotros no queremos trabajar con Array de Char 00:01:14
entonces a partir de allí lo que hemos hecho es crear este objeto milista 00:01:17
habíamos creado al principio un milista que trabajaba con string 00:01:22
os acordáis que aquí había un array de string 00:01:26
y lo que hacíamos era identificar un constructor para crear un nuevo objeto de este milista 00:01:29
y luego teníamos una serie de métodos como añadir un string 00:01:35
Saber el tamaño de la lista 00:01:41
Escribir la lista en pantalla 00:01:45
Pillar un cierto elemento en una posición 00:01:47
Que te paso como parámetro y me devolvía un string, etc, etc, etc 00:01:52
Vimos que esto del string se nos quedaba un poquito corto 00:01:56
Porque debería haber hecho un milista por cada clase que existe 00:02:01
Ok, utilice 00:02:05
Quiero hacer un milista de string, pues tengo que hacer una clase 00:02:07
Milista string 00:02:09
¿Quiero hacer ahora una lista de animales? 00:02:10
Debería hacer mi lista de animales 00:02:14
¿Ahora quiero hacer de coches? 00:02:16
Pues mi lista de coches 00:02:20
Y así, así, así, así 00:02:21
Esto sería inviable 00:02:22
Porque clases hay infinitas 00:02:24
Y cada vez que yo quiera hacer una lista de estas clases 00:02:26
Debería crearme un nuevo mi lista 00:02:29
¿Vale? 00:02:31
Entonces, vinieron a ayudarnos 00:02:32
El concepto de tipos genéricos 00:02:35
¿Vale? 00:02:38
que veremos también ahora en el próximo tema, que son las listas, las colas, las ashmap y set y cosas por el estilo. 00:02:38
Volverá a existir esta cosa aquí, entonces aprenderemos a utilizarlo. 00:02:48
Pero esto es un comodín que me dice, yo no voy a saber qué me vas a dar tú como tipo, 00:02:52
pero cuando crearás un milista me dirás el tipo que quieres insertar en este milista 00:03:00
y yo usaré este t aquí dentro para referirme a este tipo que todavía no sé cuál es, ¿vale? 00:03:06
Entonces, donde antes tenía string, voy a poner este t y aquí tengo lista que es un array de t. 00:03:14
¿Qué es t? No lo sé. 00:03:21
Cuando crearé mi lista, si le digo eres de string, será un array de string. 00:03:22
Si le digo animal, eres un array de animal. 00:03:27
Cuando esto... Llego aquí en un momento. 00:03:30
Cuando añado algo 00:03:33
Le digo que añado un tipo T 00:03:35
Porque yo digo, hago una lista 00:03:37
De vehículos 00:03:39
Pues entonces voy a añadir 00:03:41
Un vehículo, vale 00:03:43
Y aquí dentro el método que me permite 00:03:45
Extender, crear un array 00:03:47
Un poquito más grande, de una posición más grande 00:03:50
Copiar todos los vehículos 00:03:52
Que tenía antes en el nuevo array 00:03:54
Añadir al final del array 00:03:56
El elemento que me has pasado tú 00:03:58
Que es un vehículo 00:04:00
y a este punto te digo que la lista, esta lista de aquí, es este nuevo array, 00:04:01
que es el más grande con el nuevo elemento insertado. 00:04:07
Para saber el tamaño, pues fácil, busco cuántos elementos tengo en mi array de lista 00:04:10
y te lo digo, ya está. 00:04:15
Para pillar algo, pues te digo la posición, la voy a buscar y lo devuelvo. 00:04:17
Cuidado que lo que devuelvo es un objeto T. 00:04:23
¿Qué es T? Pues siempre dependerá de cómo lo has creado. 00:04:25
¿Cómo se crea? Cuando yo creo aquí un miLista, le digo que este miLista va a contener string. 00:04:28
Lo llamo de algún nombre y creo un nuevo miLista de string. 00:04:37
Esto quiere decir que ahora dentro tendré string. 00:04:42
De hecho, estos métodos de aquí son métodos T. 00:04:46
Por ejemplo, si yo miro este, este es un add de T. 00:04:52
¿Sí? Pero si yo hago 00:04:55
M punto 00:04:58
Y voy a mirar el add 00:04:59
No hago zoom porque no puedo 00:05:01
Si no se bloquea la cosa 00:05:03
Pues veis que aquí como parámetro me da string 00:05:05
No T 00:05:08
No object, no cualquier cosa 00:05:09
Me da string porque 00:05:12
Este se ha asociado 00:05:13
Con este T de aquí 00:05:16
Con este T de aquí 00:05:18
Y por lo tanto allá donde yo tenga un T 00:05:19
Pues ahora es un string 00:05:22
¿Sí? 00:05:23
Si yo cambio esto y pongo otra cosa, aquí pongo scanner, que es otro objeto, ¿vale? 00:05:25
M2, no lo tengo que importar. 00:05:40
Pues ahora, cuando yo hago M2 punto, la add me dice que puede añadir un scanner, ¿no? Un string. 00:05:48
Porque ahora este scanner se ha asociado con el T, por lo tanto estoy trabajando con scanner, ¿vale? 00:05:55
Esto es un poquito el concepto de tipo genérico. 00:06:02
Yo creo una clase sin decir qué tipo es, pero a la hora de utilizarla, instancio ese tipo, en un cierto sentido. 00:06:05
Es como si fuera una variable que en vez de jugar con valores, juega con tipos. 00:06:14
¿Sí? Vale. 00:06:19
La única cosa que nos quedó un poquito así rara es esto. 00:06:21
¿Vale? 00:06:25
Porque a la hora de crear este objeto, de implementarlo, de instanciarlo, no lo puedo hacer con T directamente. 00:06:26
Se enfada, porque el compilador necesita saber este T que es. 00:06:37
Y como este T solo se ejecutará en un futuro cuando ya la uso y le digo que es, pues aquí se enfada. 00:06:42
Entonces, la solución que hemos encontrado nosotros es crear un tipo de objetos, o sea, una red de objetos, porque la red de objetos me admite cualquier cosa, ¿vale? Como es object, desde object hereda cualquier clase, pues en algún punto de la cadena de adherencia de cualquier objeto llegamos a object. 00:06:50
Entonces, si yo me he creado un objeto, pues aquí podré poner todos los objetos que me da la gana. 00:07:09
Y a este punto, lo que hago es decirle, pero no quiero, una vez que lo has creado, 00:07:14
has creado una red de objetos, castéalo a un objeto de tipo T. 00:07:19
Y esto es peligroso, porque normalmente esto podría dar problemas. 00:07:24
Si aquí en esta red de objetos yo había puesto gatos, coches y aviones, 00:07:29
y ahora le digo, hazme este de aquí 00:07:34
un casteo a string, pues 00:07:36
explotaría, le daría problemas 00:07:38
pero a mí no me da problemas porque 00:07:40
está de toda forma controlado, esta es una 00:07:42
cosa que estamos haciendo en el constructor 00:07:44
y por lo tanto esto cuando se crea 00:07:46
está vacío, no hay ningún objeto 00:07:48
dentro, por lo tanto no hay 00:07:50
problema de que había un gato y ahora le he dicho que es 00:07:52
un string, pues no, no había nada 00:07:54
y ahora le digo que a partir de ahora 00:07:56
es esto, y fijaos que 00:07:58
en mi lista nadie puede 00:08:00
acceder directamente a la lista, entonces nadie 00:08:02
puede acceder a la lista y decir, meto dentro un gato 00:08:04
no obstante sea una lista 00:08:06
de vehículos, y que el añadir 00:08:08
no me permita añadir cualquier 00:08:11
cosa, me permite añadir sólo lo que 00:08:12
tú me has dicho, por lo tanto 00:08:14
estoy seguro que dentro de object 00:08:16
no pueda ir algo que no es 00:08:18
un T 00:08:21
¿se entiende? 00:08:22
todo esto 00:08:26
repaso, la última vez 00:08:27
os dejé con, bueno 00:08:28
Decimos el contains, decimos cosas por el estilo, hablamos de esta cosa de que el contains va a buscar la igualdad entre los objetos de la lista y el objeto que me ha pasado aquí. 00:08:30
Y esto se hará con un equals y funciona porque en automático él elegirá el equals de la instancia. 00:08:51
vale, entonces si aquí había elegido string 00:08:59
pues esto será el equals de string 00:09:02
si yo aquí había elegido como t animal 00:09:04
pues me irá a buscar el equals de animal 00:09:06
por lo tanto me funciona 00:09:08
pero lo que tengo que hacer es claramente 00:09:09
definir un equals dentro 00:09:12
de mi objeto, si no lo hago 00:09:14
el equals será el igual 00:09:16
igual, como es el 00:09:18
equals de object 00:09:20
¿sabes? 00:09:21
os dejé 00:09:24
la última vez 00:09:25
haciendo esto 00:09:27
el remove 00:09:29
no sé si lo habéis hecho, lo más probable es que no 00:09:31
¿por qué? porque no estudiáis en casa 00:09:34
y hay dos 00:09:36
opciones de hacer el remove 00:09:38
el remove de una posición o remove 00:09:40
de un objeto 00:09:42
el remove de un objeto se podría 00:09:43
ver como busco ese objeto 00:09:46
cuando sé que posición es 00:09:48
llamo el remove 00:09:50
de la posición donde está 00:09:51
entonces rápidamente 00:09:54
vamos a implementar solo esto 00:09:56
para ver cómo se hace, ¿vale? 00:09:58
Pero muy rápidamente porque quiero hacer otras cosas hoy. 00:10:00
Entonces, 00:10:03
el remove me han dado una posición 00:10:04
del array, por lo tanto yo tengo que 00:10:06
remover esa posición. 00:10:08
El hecho es que nosotros queremos que 00:10:10
el array sea siempre compacto, no haya 00:10:12
null allí, porque 00:10:14
si pudiera emitir los null, sería 00:10:16
simplemente lista de 00:10:18
posición 00:10:20
es igual a null. Ya está. 00:10:21
Ningún problema. 00:10:29
vale pero como no quiero esto yo quiero que el lista siempre porque si no si yo hiciera esto 00:10:30
funciona pero ya el 6 no funciona porque ahora me diría tienes 10 elementos pero había borrado uno 00:10:36
y ahora en realidad hay nueve elementos pero la casilla sigue restando por lo tanto no funcionaría 00:10:45
el 6 como lo he hecho así pues tengo hacer algo un poquito más distinto que es parecido a cuando 00:10:49
lo hemos extendido, solo que esta vez tengo que encogerlo. 00:10:55
Tengo que crear un 00:10:58
array nuevo 00:10:59
de t, como 00:11:01
hacía aquí, 00:11:03
pero en vez de crearlo 00:11:06
más 00:11:08
grande, lo creo 00:11:10
más pequeño, 00:11:12
porque voy a quitar uno. 00:11:13
Luego, 00:11:18
for int 00:11:20
y es igual a 0 00:11:21
y menor 00:11:25
que posición 00:11:26
y más más, o sea, por todos los números 00:11:30
anteriores a posición, excluyendo posición, la posición 00:11:37
que me has dicho no la quiero, entonces no pongo menor o igual 00:11:42
¿vale? Tengo que copiar simplemente lista 00:11:45
dentro del nuevo, no se ven afectados los que están antes 00:11:49
entonces nuevo de y es igual 00:11:52
a lista 00:11:56
de ahí 00:11:58
ahora 00:11:59
cuando he hecho esto 00:12:01
he llegado a la posición 00:12:03
y ahora tengo un problemita 00:12:05
yo tenía este 00:12:06
array de aquí antes 00:12:10
he creado un array 00:12:11
un poquito más pequeño 00:12:13
esta es la posición 00:12:15
que quiero quitar 00:12:17
entonces hasta llegar a esta posición 00:12:18
es simplemente copiado 00:12:21
cuando 00:12:23
llego a esta posición, lo que 00:12:25
tengo que empezar a hacer es copiar 00:12:27
la posición más 1 00:12:29
dentro de la anterior. 00:12:30
¿Se entiende? 00:12:36
¿Sí? O sea, hasta 00:12:39
la posición, copio 00:12:40
directamente la 0 en la 0, la 1 00:12:42
en la 1. Cuando encuentro 00:12:44
esta de aquí, 00:12:47
empiezo a copiar la 00:12:48
3, 0, 00:12:50
1, 2, 3, la 3 en la 2, 00:12:52
la 4 en la 3, la 5 00:12:55
en la 4. 00:12:56
¿Sí? Hasta el final, saltándome la que me has dado tú. 00:12:58
Entonces, hago esta de aquí que copia la primera parte. 00:13:03
La parte a la izquierda de la posición. 00:13:07
Luego empiezo otro for, que for int y es igual a posición y menor que... 00:13:09
Depende, aquí lo puedo hacer... 00:13:25
Ponemos uno. 00:13:27
Razonamos siempre sobre lista, ¿vale? 00:13:28
Y menor que lista.length 00:13:30
Y más más 00:13:35
No, porque es menor 00:13:38
Y estoy trabajando sobre lista 00:13:40
O sea que este Y será el recorrido de este array de aquí 00:13:42
Ha llegado a posición 00:13:47
Se la salta y empieza desde posición más uno 00:13:49
Entonces, si ahora me vale posición más uno 00:13:53
Tendré que copiar en nuevo de i-1 lo que está en lista de i. 00:13:57
Si lista de i me vale 3, copio lo que hay en lista de 3 en nuevo de i-1, o sea, en nuevo de 2. 00:14:12
Si vale la posición 4, lo copio en i-1, o sea, en 3. 00:14:29
Y así hasta que acabo este array. 00:14:35
Al final, lista, es igual a 9. 00:14:40
Esto no es la primera vez que lo hacemos. 00:14:49
Esto hay ejercicios sobre array que hacen esto. 00:14:53
Otra cosa que no lo hayáis hecho en vuestra vida. 00:14:56
Pero estos ejercicios de aquí son ejercicios básicos de arrays que nosotros hemos hecho ya en la primera evaluación, 00:14:59
que están en los enunciados, buscadlos, de añade un elemento a un array o quita un elemento al array sin que haya null. 00:15:07
Son ejercicios que deberíais ya saber hacer y simplemente ahora le estamos dando un significado. 00:15:14
Hemos aprendido a hacer las cosas sin significado, a hacer ejercicios generales y ahora lo utilizamos para cosas útiles. 00:15:19
Repito que esto sería 00:15:26
Búscame el elemento S dentro del array 00:15:31
Cuando lo has encontrado 00:15:34
Me dice la posición 00:15:36
Y llamas este método de aquí 00:15:37
De esa posición 00:15:39
Ya está 00:15:40
Si ya hemos hecho el contains 00:15:40
Lo hemos hecho con boolean 00:15:47
Si en vez de hacerlo con boolean 00:15:48
Hacemos contains que me devuelve 00:15:50
O esta misma cosa de aquí 00:15:51
Que me devuelve las posiciones 00:15:52
Y yo puedo llamar este método de aquí 00:15:56
Me devuelve las posiciones donde estás 00:15:58
Y luego llamo por cada posición de este array que me ha devuelto 00:16:00
Pues llamo remove de esa posición 00:16:05
Y ya está 00:16:09
Pues esto completa lo del otro día 00:16:11
Vale, entonces hoy lo que vamos a hacer es lo siguiente 00:16:19
Paso número A 00:16:23
Recordarme esto, mi lista 00:16:24
¿Vale? 00:16:27
Hemos hecho este mi lista 00:16:29
Perfecto 00:16:30
Ahora, si nosotros vemos, mi lista tiene una serie de funcionalidades 00:16:31
Que son quita, que son añade, que son escribirlo como array 00:16:37
La idea que tengo hoy es decir 00:16:44
Vale, yo quiero hacer ahora la misma cosa 00:16:48
Pero con una implementación completamente distinta 00:16:51
¿Qué quiere decir? 00:16:54
Quiere decir que como primer paso me creo una interfaz 00:16:57
La interfaz, listas, por ejemplo 00:17:03
Y aquí escribo lo que yo quiero que haga una lista en general 00:17:08
O sea, mis listas, habíamos dicho que podía añadir un elemento 00:17:14
Pues esto de aquí, lo pongo aquí 00:17:21
Cuidado, ¿qué es este t? 00:17:26
Pues lo tendré que decir, es un tipo genérico 00:17:32
O sea, que la interfaz de listas de dime tú qué, pues tendrán que tener un método que añade un no sé qué. 00:17:35
Si string, un string. Si un animal, un animal. 00:17:45
¿Qué más puede hacer una lista en general? 00:17:49
¿Qué estoy haciendo aquí en un cierto sentido? 00:17:52
Estoy haciendo como una generalización. 00:17:56
No es lo mismo porque eso era inherencia, pero estoy haciendo algo por estilo. 00:17:59
Lo estoy diciendo, vale, me he hecho una lista, ¿vale? 00:18:03
Pero yo quiero sacar de la lista lo que todas las listas tienen que tener en común. 00:18:06
Y todas las listas tienen que poder añadir un elemento. 00:18:11
Por lo tanto, he puesto aquí un método para añadir un elemento. 00:18:16
Ahora, ¿qué más pueden hacer todas las listas? 00:18:20
Pues decir cuántos elementos tienen. 00:18:22
Pues aquí añado esto. 00:18:25
¿Qué más puede hacer una lista? 00:18:32
pues se puede escribir en pantalla 00:18:34
vale 00:18:36
tiene que tener un toString 00:18:37
que luego en realidad lo tiene siempre 00:18:40
porque tiene el de object 00:18:44
¿qué más? pues quiero poder 00:18:45
pillar el elemento n 00:18:48
de una lista 00:18:50
quiero poder 00:18:53
saber si un elemento 00:18:57
está o no en la lista 00:19:00
y finalmente 00:19:02
para no complicarlo demasiado 00:19:07
quiero saber 00:19:10
Quiero poder eliminar un cierto elemento de la lista 00:19:11
Y asumamos que aquí había otros métodos 00:19:21
Como este método de aquí, como este método de aquí 00:19:30
Pero asumamos que estos son propios de mi lista 00:19:33
Las listas en general lo que tienen que hacer es implementar estos 00:19:37
Una vez que lo he guardado 00:19:42
Yo lo que podría hacer es que mi lista 00:19:47
Implements 00:19:49
Listas 00:19:54
Y no me da errores 00:19:58
Porque ya estos métodos de aquí 00:20:06
Los tengo implementados 00:20:08
¿Están de acuerdo en lo que he hecho? 00:20:09
¿Sí? Vale 00:20:14
Entonces, lo que voy a hacer hoy en vez 00:20:15
Es el siguiente, vale 00:20:18
Ahora quiero hacer otra lista 00:20:20
Quiero hacer un objeto que haga lo mismo que esto 00:20:21
Que me esconda los arrays otra vez 00:20:24
Que sea lo que se llama una estructura 00:20:26
De datos dinámicas 00:20:28
Y veremos el lunes por qué es dinámica 00:20:29
Que yo tenga este objeto 00:20:32
Le puedo decir, añádeme un string, añádeme un animal 00:20:34
Añádeme lo que sea 00:20:36
Y él lo vaya añadiendo 00:20:36
Sin con un array decir 00:20:38
Mira, se ha acabado el espacio, tengo que poner otra cosa 00:20:41
Para esto 00:20:43
Me creo una nueva implementación 00:20:45
De listas 00:20:48
La llamaré 00:20:49
MiListaEnlazada 00:20:50
sí mi lista enlazada tendrá un tipo e implementará listas se enfada porque dice hoy mira me estás 00:20:54
diciendo que implementa listas pero no has implementado nada pues aquí le digo añade 00:21:20
los métodos no implementados y él me lo pone aquí tienes que hacer estos tengo acuerdo hasta aquí 00:21:26
O sea, que yo ahora aquí tengo una estructura, un esqueleto de una nueva clase que hará lo mismo que mi lista, pero en una versión distinta. 00:21:33
Ahora vamos a ver cómo lo hacemos distinto. 00:21:45
Pero una vez que yo la tenga, yo podré aquí hacer tranquilamente una mi lista enlazada de string, llamándola como quiera, 00:21:48
hago new mi lista enlazada de string y ponerle dentro gato, perro, banana, murciélago 00:21:56
y hacer todo lo que pueda hacer esta cosa aquí. 00:22:01
O sea, hacer la get, hacer el tu array, hacer el size. 00:22:04
¿Se entiende lo que quiero decir? 00:22:12
¿Dudas? 00:22:15
Vale. 00:22:16
Ahora, en esta implementación yo no quiero usar los arrays. 00:22:18
Si os acordáis, aquí la base de mi implementación era usar un array. Tengo un array y almacenaba las cosas allí, hacía más grande o más pequeño el array, contaba sobre el array, etc. 00:22:23
Aquí, esta de aquí, quiero que sea una implementación distinta. ¿Por qué? Porque a lo mejor implementación distintas me dan ventajas o desventajas en determinados casos. 00:22:36
Por ejemplo, yo he visto que usar el array es un poco engorroso en el añadir y quitar, ¿sí? 00:22:48
Añadir un elemento o quitar un elemento, esta implementación lo hace complejo, porque tengo que hacer un nuevo array, copiarlo, es lento. 00:23:01
Sin embargo, es súper rápido, es súper eficaz en size, porque me lo da así directamente, no hace ningún cálculo. 00:23:11
Y también en esta, la get de una posición es súper eficiente dentro de una red. 00:23:19
Pero imaginaos que yo tengo una lista donde no se hace mucho la get, se hace pocas veces, 00:23:29
pero sí lo que se hace mucho es insertar y quitar elementos. 00:23:35
Entonces, esta implementación podría ser lenta. Y a lo mejor yo hago ahora un sistema completamente distinto, un modo completamente distinto de hacer lo mismo, de almacenar estos datos, que a lo mejor es muy bueno para añadir y quitar objetos, pero a lo mejor muy lento para pillar uno, no lo sé. 00:23:38
Pero se entiende la idea de hacer distintas implementaciones 00:24:00
Se pueden hacer para lograr lo mismo 00:24:05
Pero que luego en términos de eficiencia 00:24:09
Puede ser eficiente en ciertas cosas y menos eficiente en otras 00:24:14
Yo tengo implementaciones distintas 00:24:17
Y a la hora de hacer mi programa me pregunto 00:24:20
¿Qué hago yo mucho? 00:24:23
Si hago muchas veces este tipo de operación 00:24:25
Pon esta operación de aquí 00:24:28
pues mejor que tú uses esta implementación. 00:24:30
Si en vez haces muchas veces esta operación de aquí, mejor que haga esta otra implementación. 00:24:33
Entonces elegiré entre mi lista o mi lista enlazada dependiendo de si hago muchos estos o si hago muchos estos. 00:24:39
¿Se entiende? 00:24:47
Entonces, ¿cómo vamos a hacer esta nueva implementación? 00:24:52
Es decir, si no podemos usar los arrays, ¿qué elemento de los que conocemos vamos a utilizar para poder crear una lista enlazada? 00:24:57
Y lo que vamos a utilizar son nuestros mejores amigos, los objetos. 00:25:08
Es decir, que aquí en vez de basarme sobre el array, me baso sobre un objeto. 00:25:18
¿Qué objeto? Pues un objeto que vaya a definir. No, array también es un objeto, pero array hemos dicho que no lo vamos a usar. Vamos a usar nodo. ¿Qué es nodo? Nodo es un objeto que tiene un valor y luego tiene un puntero a otro nodo. 00:25:27
entonces tendrá 00:25:59
un objeto 00:26:04
un valor 00:26:06
¿cómo se lo pongo el valor? 00:26:08
que tiene que contener 00:26:11
este nodo 00:26:12
¿qué le hacemos contener este nodo? 00:26:21
probablemente 00:26:32
no lo sé 00:26:32
porque si mi lista es de cocodrilos 00:26:34
quiero que controle cocodrilos 00:26:38
si mi lista es de gatos 00:26:40
quiero que contenga gatos 00:26:43
podría 00:26:45
hacer una trampilla y decir 00:26:46
cualquier objeto, ¿sí? Pero como ya tengo 00:26:48
los de aquí, pongámoslos así. Entonces el 00:26:55
nodo, el nodo es un objeto 00:27:07
es un objeto que tiene un campo valor 00:27:16
aquí dentro tiene el valor de este objeto, un string 00:27:24
un gat, lo que sea, ¿vale? Y luego tiene una otra 00:27:28
variable que lo que hace es 00:27:32
apuntar a otro nodo. 00:27:35
Y este tendrá un valor y apuntará a otro nodo. 00:27:44
Y esto tendrá otro valor y apuntará a otro nodo. 00:27:48
Sustancialmente, en vez de tener un array 00:27:54
con dentro todas las cosas, tengo una cadena 00:27:57
de objetos. ¿Qué es esto? 00:28:02
¿Cómo plasmo esto aquí dentro? 00:28:16
Ahora vamos a ver cómo lo hacemos 00:28:19
¿Qué es esto? 00:28:38
Este es un campo siguiente 00:28:45
¿Vale? 00:28:46
Que apunta a otro nodo 00:28:48
Porque os acordáis que cuando yo creo un objeto 00:28:50
Cuando yo creo el objeto 00:28:53
Animal x es igual a animal 00:28:54
¿Qué contiene x? 00:28:58
Contiene un objeto 00:29:02
Nope 00:29:03
El objeto animal se crea por algún lado con sus características 00:29:06
Y dentro de x yo tengo un puntero a este objeto 00:29:10
David, hola, porque si no, no salimos de esta. 00:29:16
Cuando yo hago animal x es igual a animal, aquí se crea el animal, este es el animal. 00:29:21
Pero dentro de mi variable x, dentro de mi referencia x, no está el objeto. 00:29:26
Está una coordinada en la que puedo encontrar el objeto. 00:29:32
Ahora, cuando yo creo un objeto así, ¿qué hay dentro del siguiente? 00:29:38
Un puntero, una referencia a otro objeto de tipo nodo de T, que será el siguiente nodo. 00:29:46
Esto. 00:29:57
Espera un segundo. 00:29:59
Entonces, si yo, por alguna magia, tengo este objeto de aquí, y este objeto de aquí se llama N, 00:30:00
¿cómo puedo, dado este objeto de aquí, obtener este objeto de aquí? 00:30:11
Repito la pregunta. 00:30:21
Imaginaos que yo tengo una variable n 00:30:22
Hecha de alguna forma 00:30:27
Que desde aquí 00:30:29
Me apunta este objeto 00:30:31
O sea, yo tengo una referencia a este objeto 00:30:33
¿Cómo hago? 00:30:35
A partir de n 00:30:37
A pillar este objeto 00:30:38
No es una red 00:30:40
Y el valor que tengo aquí 00:30:48
Pongámoslo que sea nodo de string 00:30:51
Esto es gato 00:30:53
Escrito como string gato 00:30:54
Esto es perro 00:30:57
como string pair. 00:30:59
Y esto es 00:31:02
Cormorano. 00:31:04
El valor no me interesa. 00:31:08
Si desde n acedo a este 00:31:10
señor y hago n.valor 00:31:13
me dirá 00:31:15
gato 00:31:17
¿Cómo acedo a este señor? 00:31:19
n.siguiente 00:31:25
n.siguiente 00:31:28
me dirá vete a este de aquí 00:31:36
y desde aquí me pillas el objeto 00:31:37
el valor, lo que hay dentro 00:31:40
del siguiente, que es este campo de aquí 00:31:43
es su segunda variable 00:31:45
ahí, ahora ya 00:31:46
lo veremos, todavía 00:31:52
estamos pillando la idea 00:31:54
luego ya veremos como lo enlazamos 00:31:56
como lo enlazamos 00:31:58
como lo enlazas, pues será 00:32:00
el encargado, este método de aquí 00:32:01
aquí tendremos que ver como lo enlazamos 00:32:04
pero por ahora, estamos 00:32:06
solo hablando del nodo 00:32:08
¿si? 00:32:09
Entonces, mi nodo tendrá, cuando yo haré en algún main, en un main de prueba, yo puedo hacer nodo de string igual a new nodo string. 00:32:11
Imaginamos que funcione 00:32:38
Luego ahora vemos que hacemos 00:32:44
No string 00:32:46
Mi nodo 00:32:47
¿Si? 00:32:50
Y ahora si yo quiero saber 00:32:52
Lo que hay dentro de este nodo 00:32:54
Haría mi nodo 00:32:56
Punto valor 00:32:58
Esto 00:32:59
Sería 00:33:05
Lo que hay aquí dentro 00:33:06
¿Si o no? 00:33:08
Y si yo quiero saber el siguiente nodo 00:33:11
El que viene después de esto, pues haría mi nodo punto siguiente. 00:33:13
Esto es un objeto de tipo nodo que apunta. 00:33:22
Y si quiero saber el nodo, el valor del siguiente nodo, ¿cómo lo haría? 00:33:27
Punto nodo, punto valor. 00:33:33
Esto es, empieza de mi nodo, vete al siguiente nodo al que apunta él, y luego mira su valor. 00:33:37
entonces en nuestro día sería 00:33:44
si esto es el primero, si este es mi nodo 00:33:48
estaría aquí, sería 00:33:50
siguiente, iría a este de aquí 00:33:52
y miraría su valor, miraría perro 00:33:54
no estamos en la lista, estamos en el concepto 00:33:56
de nodo, ahora luego 00:34:06
luchamos 00:34:07
y pensamos a cómo se hacen estas cosas 00:34:09
¿dudas? 00:34:11
ahora, para entender 00:34:15
esto, tenéis que saber 00:34:16
que es un objeto 00:34:17
y que es una referencia 00:34:18
si no tenéis idea de estas dos cosas 00:34:20
que son un mes y medio que estamos 00:34:23
hablando de estas cosas 00:34:25
pues tenemos un problema serio 00:34:26
¿sí? y probablemente 00:34:29
no vais a entender 00:34:34
las próximas 00:34:35
hora y media de clase 00:34:37
¿sí? 00:34:39
pero 00:34:42
asumamos que esto más o menos 00:34:43
está aquí, ahora, yo necesito un constructor 00:34:45
¿vale? ¿cómo 00:34:47
construyo un nodo? 00:34:49
public nodo 00:34:51
No sé si tengo que ponerle t aquí 00:34:53
Que pillará un 00:34:59
T valor 00:35:01
Lo que hará es que 00:35:03
This.valor 00:35:07
Es igual 00:35:11
A valor 00:35:13
Perfecto 00:35:15
¿Qué le pongo en siguiente? 00:35:18
Null 00:35:29
Y yo estoy creando un nodo 00:35:29
No sé todavía a quién tiene que apuntar 00:35:34
Se lo diré después 00:35:37
¿Sí? 00:35:38
Puedo hacer que estos sean accesibles directamente 00:35:41
Puedo ponerlos privados 00:35:45
Para que los maneje yo 00:35:48
Si los manejo yo 00:35:53
Tendré que poner un public tgetValor 00:35:55
Que hará return valor 00:36:02
Y luego quiero un public 00:36:07
Siguiente 00:36:11
public nodo siguiente, que lo que hace es return this.siguiente, fijaos que esto es siguiente como método, esto es siguiente como variable, son dos cosas distintas. 00:36:16
Y luego tendré un publicNodo, public void, setSiguiente, en el que me darás un nodo, en el que si tú llamas este método sobre un nodo, le estás pasando otro nodo y le estás diciendo que this.Siguiente es igual al siguiente nodo. 00:36:40
Estos son getter y setter. 00:37:19
Ahora yo aquí pondría esto. 00:37:22
Para estar seguros. 00:37:25
Todas las veces que ponéis nodo, ponéisle la T. 00:37:26
Esto se enfada. 00:37:34
Así no. 00:37:39
Bueno, ya está. 00:37:39
¿Sí? 00:37:41
Entonces yo tengo mi nodito que no es nada. 00:37:42
No hace nada nodo por sí mismo. 00:37:45
Es solo el objeto que voy a utilizar. 00:37:46
Es el elemento que me permite crear lo que se llama una lista enlazada. 00:37:48
Estoy enlazando nodos. 00:37:53
donde acaba mi lista 00:37:55
esto apunta aquí, esto apunta aquí, donde acaba 00:38:00
en aquel nodo cuyo siguiente 00:38:07
de null, si yo tengo un nodo 00:38:14
voy a mirar su siguiente y me dice null, he acabado al final de la lista 00:38:20
¿make sense? ¿donde empieza mi lista? 00:38:24
en el primer nodo, yo tendré un nodo especial 00:38:35
que es el primer nodo, que me lo guardaré 00:38:38
y diré, aquí es donde empieza la lista 00:38:41
¿y cómo es una lista vacía? 00:38:43
si este inicio de lista 00:38:50
apunta null 00:38:52
pues la lista es vacía 00:38:54
¿se entiende? 00:38:56
entonces, con estos 00:39:01
elementos, vamos a trabajar 00:39:02
entonces, nodo no lo tengo 00:39:04
aquí, ¿vale? si lo tengo que modificar 00:39:06
el considera que esta cosa aquí no me sirve 00:39:08
si tengo que modificarla o cosarla 00:39:10
pues puedo venir aquí y cambiarla 00:39:12
si se me ha olvidado algo, cosa por el estilo 00:39:14
Por ahora, vamos a mi lista enlazada. 00:39:15
¿Qué necesito como variable, como atributo, como cosa interesante para mi lista? 00:39:18
Tipo lo tengo aquí. 00:39:31
Atributos. 00:39:32
Como aquí estaban atributos, aquí como atributo había puesto esto. 00:39:33
Aquí como atributo he puesto estos de aquí. 00:39:39
No, porque estoy haciendo todo esto para no usar los arrays. 00:39:41
Efectivamente, tengo un nodo de T 00:39:47
Que es el señor primero 00:39:54
Si este señor es nul, mi lista es vacía 00:39:57
Si este señor apunta un nodo 00:40:05
A partir de ese nodo puedo recorrer mi lista 00:40:08
Yendo al siguiente, al siguiente, al siguiente, al siguiente, al siguiente, al siguiente 00:40:10
Hasta que encuentre un siguiente nul 00:40:14
Y ahí se ha acabado mi lista 00:40:17
Cuando ponga nodo 2 00:40:18
No pongo nodo 2 00:40:25
no pongo nodo segundo 00:40:27
no lo necesito 00:40:30
porque no necesito 00:40:34
esta en mi lista 00:40:36
enlazada 00:40:39
que tiene el puntero 00:40:41
primero 00:40:43
todos estos elementos de aquí 00:40:44
no los necesito aquí dentro 00:40:47
a mi me interesa solo 00:40:49
el puntero 00:40:51
al primer elemento 00:40:53
luego a partir de aquí puedo seguir 00:40:55
la cadena 00:40:57
Siguiendo 00:40:58
Toda mi lista 00:41:00
Entonces, aquí dentro lo que necesito es el primero 00:41:01
Vale 00:41:05
Podría 00:41:11
Si quiero 00:41:15
Tener un int 00:41:16
De elementos 00:41:18
Para saber 00:41:21
Cuantos elementos hay en mi lista 00:41:23
Para simplificar 00:41:25
El size 00:41:27
Pero no es necesario 00:41:28
Por lo tanto no lo pongo 00:41:30
O si queremos lo añadimos después para modificación 00:41:32
Entonces, ahora voy a empezar, por ejemplo, la añadir 00:41:35
Para hacer la añadir, lo que tengo que hacer yo es añadir un nuevo elemento 00:41:42
¿Dónde se añade? 00:41:52
Dos opciones 00:41:54
O lo añado al principio de la lista 00:41:55
O lo añado al final de la lista 00:41:58
podría tener un add 00:42:01
que me pille un elemento 00:42:04
coma una posición 00:42:06
y que me añade este elemento 00:42:08
en esta posición, lo podría hacer 00:42:10
pero por ahora 00:42:12
mantenemos en lo easy 00:42:14
¿vale? y tengo añade un elemento 00:42:16
¿dónde lo queréis añadir? 00:42:18
si lo queréis 00:42:26
en la primera posición 00:42:27
estáis creando una lista invertida 00:42:28
yo te digo gato, cocodrilo y cebra 00:42:31
y él almacenará, cuando la voy a mirar, cebra, cocodrilo, gato. 00:42:33
Porque el primero que se encontrará es el último que has metido. 00:42:39
A lo mejor es lo que quieras. 00:42:42
Normalmente cuando yo hago una lista, 00:42:45
lo que me espero es que los últimos que he añadido estén al final. 00:42:47
Entonces hagamos lo que es más conceptualmente fácil de ver, 00:42:52
aun si es más difícil de programar. 00:42:58
luego nadie me prohíbe de poner 00:43:00
at the first, que en vez de añadirla 00:43:03
al final, pues la añade al principio 00:43:05
pero ya no estaría 00:43:07
en mi lista 00:43:08
es un método propio de mi lista enlazada 00:43:10
entonces, añadíamos 00:43:13
¿cómo hago esto? 00:43:15
paso número uno 00:43:18
no, paso número uno 00:43:19
¿el? 00:43:29
¿en qué sentido? 00:43:35
efectivamente, primera cosa, miro si 00:43:42
primer nodo es 00:43:45
Null 00:43:47
Porque si es null 00:43:49
Este que estás añadiendo es el primer nodo 00:43:50
Y es fácil 00:43:54
Si no es null 00:43:54
Pues a ver qué hago 00:43:56
Entonces, asumamos que 00:43:58
Me han añadido 00:44:01
Me están añadiendo 00:44:05
Un objeto T 00:44:06
Añadir un objeto T 00:44:08
Quiere decir que no me están añadiendo un nodo 00:44:09
Me están añadiendo un valor 00:44:12
Entonces, la primera cosa que hago 00:44:15
Es crearme un nodo 00:44:17
Nodo de tipo T nuevo es igual a new nodo de tipo T de S. 00:44:19
A mí me han dicho, trabajando como string, a mí me ha dicho añade cebra. 00:44:33
Y yo lo que he hecho es crearme un nodo nuevo que contiene cebra y cuyo nuevo punto siguiente, ¿qué será? 00:44:39
Null. 00:44:49
Y esto es el que va aquí. 00:44:50
Este nuevo elemento que he hecho es el que pondré aquí y apuntará a null. 00:44:56
Perfecto, tiene que apuntar a null porque es el último de la lista. 00:45:02
No, lo estás implementando tú. 00:45:09
Es como lo queremos hacer nosotros, como hemos dicho que lo vamos a hacer nosotros. 00:45:13
Porque en una lista tiene sentido que el último que añadas sea el último de la lista. 00:45:21
Pero no necesariamente. 00:45:27
Hay estructuras de datos en que lo último que pones tiene que ser el primero. 00:45:29
Pues entonces lo implementas como que sea el primero. 00:45:33
Pero no es lo que estamos haciendo. 00:45:35
Nosotros hemos decidido que lo implementamos, que el añadir añade al fondo de la lista. 00:45:37
¿Vale? 00:45:44
Entonces, me creo lo que quiero añadir. 00:45:44
¿Sí? 00:45:48
Y ahora me pregunto, si primero es null, ¿qué hago? 00:45:48
Primero es igual a nuevo. 00:46:00
He creado un nuevo objeto, ¿sí? 00:46:05
Y si mi lista está vacía, no apunta nada, le digo, vale, tú eres el primer objeto. 00:46:08
Y se acabó. 00:46:15
Estamos de acuerdo que este tiene el siguiente null. 00:46:19
Habría hecho lo siguiente, ¿vale? 00:46:22
Creo mi lista. 00:46:29
Mi lista tiene primero, ¿vale? 00:46:30
Este es primero, que es null. 00:46:32
Ahora hago add de cebra, por ejemplo. 00:46:36
Entonces, me creo un nodo nuevo que tiene dentro cebra y que apunta null, ¿sí? 00:46:39
Y luego le digo, primero, tú eres esto. 00:46:51
Y entonces ahora tengo mi lista que se acceda primero, accederá a su primer elemento. 00:47:02
¿Sí o no? 00:47:10
Vale. 00:47:11
Ahora, asumamos en vez que no es así, que primero no da null, por lo tanto primero hay algo en primero. 00:47:12
¿Qué hago si hay algo en primero? No, crear no puedo crear otro, porque yo tengo que añadir un solo elemento. 00:47:24
Entonces, ahora estaría en la situación en la que esto lo tengo ya, 00:47:50
tengo esto, imaginamos que esto ya está, 00:47:58
y yo quiero añadir un nuevo objeto que sea jirafa, no, que sea gato, 00:48:02
porque se escribe rápido, ¿vale? 00:48:09
Entonces, este primer paso me habrá creado el nuevo elemento. 00:48:11
Aquí ahora tengo gato, que apunta null, ¿sí? 00:48:17
Ahora, lo que pasa es que antes IOPET lo tenía nul, entonces solo he dicho apunta aquí y se acabó. 00:48:25
Ahora no lo puede hacer. 00:48:34
¿Qué tengo que hacer? 00:48:36
El código. 00:48:47
No. 00:48:55
Nuevo punto siguiente, ¿qué es? 00:48:55
Seguramente. 00:48:57
¿Qué es nuevo punto siguiente? 00:49:00
¿Cuánto vale? 00:49:02
¿Qué hay dentro de nuevo punto siguiente? 00:49:03
Nul. 00:49:04
Por lo tanto, porque lo acabo de crear y se crea nul. 00:49:05
Lo que tendré que hacer es, partiendo de primero, recorrerme toda la lista. 00:49:09
De primero al siguiente, a esto al siguiente, a esto al siguiente, hasta encontrar un nodo cuyo siguiente sea nul. 00:49:24
Y eso será el último nodo de la anterior lista. 00:49:34
Entonces, lo que tendré que hacer es, a ese nodo, cambiarle el siguiente al nuevo objeto. 00:49:41
Eso es lo que tengo que hacer 00:49:48
Después de recreo lo hago 00:49:50
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:
9
Fecha:
31 de enero de 2025 - 12:45
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
49′ 55″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
160.07 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid