1
00:00:01,139 --> 00:00:06,719
Vale, voy a grabar esta clase, por lo tanto si habláis me autorizáis a grabar vuestra voz.

2
00:00:07,379 --> 00:00:20,480
Entonces, nosotros en la vez anterior hemos visto cómo queremos dejar aparcados los arrays

3
00:00:20,480 --> 00:00:23,739
y entonces nos hemos creado una interfaz que se llama lista.

4
00:00:24,059 --> 00:00:25,420
Ahí está la interfaz de ahí, ¿vale?

5
00:00:25,660 --> 00:00:30,699
Hemos dicho que nosotros con los arrays hacemos una serie de operaciones muy comunes,

6
00:00:30,699 --> 00:00:35,420
como añadir un elemento, quitar un elemento, preguntar cuánto es grande la

7
00:00:35,420 --> 00:00:42,600
rey, etcétera, etcétera, que queremos esconder, queremos esconder todo el

8
00:00:42,600 --> 00:00:49,179
trabajo que está por detrás, creando una nueva forma de gestionar los objetos, lo

9
00:00:49,179 --> 00:00:56,200
que se llama las colecciones. Además queremos que sean dinámicas,

10
00:00:56,200 --> 00:01:02,859
mientras un array es fijo es ese tamaño y tengo que hacer cosas raras pues mis colecciones quiero

11
00:01:02,859 --> 00:01:07,840
que yo pueda añadir cuantos objetos me da la gana y el por debajo haga lo que tiene que hacer para

12
00:01:07,840 --> 00:01:13,120
añadir este nuevo objeto vale me quiero olvidar de la mira no lo he hecho grande cuatro posiciones

13
00:01:13,120 --> 00:01:19,180
entonces no puedo poner cinco objetos pues no pongo lo que te haga falta hemos hecho la

14
00:01:19,180 --> 00:01:25,060
implementación con un array entonces hemos visto que hemos reutilizado dentro la mayoría de los

15
00:01:25,060 --> 00:01:30,939
métodos, ejercicios y cosas por el estilo que hemos hecho con los arrays. De extender el array,

16
00:01:30,939 --> 00:01:37,040
acortar el array, copiar un array, pues hemos hecho esa cosa ahí. Al final hemos dicho, mira,

17
00:01:37,040 --> 00:01:47,500
no hay una forma de hacer esto sin usar arrays. Puedo implementar una lista de otra forma sin

18
00:01:47,500 --> 00:01:54,459
tener en cuenta los arrays y entonces nos hemos inventado esto, el concepto de la lista enlazada,

19
00:01:54,459 --> 00:01:56,099
¿Qué es la lista enlazada?

20
00:01:57,859 --> 00:02:03,599
Sustancialmente, es la idea de un objeto que estará aquí.

21
00:02:03,819 --> 00:02:05,319
Esto será mi lista enlazada.

22
00:02:06,459 --> 00:02:07,640
Por favor, chicos.

23
00:02:08,879 --> 00:02:14,340
Sobre este objeto será donde le puedo pedir añadirme otro objeto, quítame otro objeto,

24
00:02:14,599 --> 00:02:16,360
busca si hay este objeto, cosa por el estilo.

25
00:02:16,360 --> 00:02:26,919
aquí tendré un puntero, una referencia a lo que hemos llamado cabeza o inicio o lo que sea,

26
00:02:26,919 --> 00:02:38,800
¿vale? Que será un puntero a otro objeto, este objeto de tipo nodo. ¿Qué es un nodo? Un nodo es,

27
00:02:38,800 --> 00:02:52,400
es algo que tiene un contenido, esto será el objeto nuevo que voy a almacenar, y además tiene

28
00:02:52,400 --> 00:03:01,000
también un puntero a otro objeto, siempre de tipo nodo, o sea una referencia a un nodo, o sea una

29
00:03:01,000 --> 00:03:11,199
variable de tipo nodo que apunta a un objeto de tipo nodo, que tendrá un contenido y un puntero.

30
00:03:11,199 --> 00:03:20,020
a otro nodo, hasta llegar a un cierto momento al último, digamos, elemento de la cola, de la lista,

31
00:03:20,020 --> 00:03:32,860
que tendrá null, o sea, una referencia a nada, no hay un siguiente nodo. Entonces ese es el último.

32
00:03:32,860 --> 00:03:39,439
Al principio, cuando yo crearé la lista enlazada, lo que tendré es que en la cabecera, en la cabeza,

33
00:03:39,439 --> 00:03:49,520
tengo null. Esto equivale al array vacío, al array de cero posiciones. Existe el array,

34
00:03:49,520 --> 00:03:57,560
pero no hay nada dentro. Aquí existe la lista enlazada, pero no hay nada dentro. En el momento

35
00:03:57,560 --> 00:04:06,229
en que añado un elemento, lo que haré es crearme un nodo, ponerle el contenido que me han dicho de

36
00:04:06,229 --> 00:04:16,490
poner, poner que es null su siguiente salto, su siguiente elemento, y luego tendré que ir a la

37
00:04:16,490 --> 00:04:23,029
cabecera, a la cabeza, y decirle tú ya no eres null, mas tu siguiente, o el inicio de la cabeza,

38
00:04:23,029 --> 00:04:33,379
es este. Ahora cuando añado uno nuevo, crearé un nuevo elemento, con aquí null, con aquí el

39
00:04:33,379 --> 00:04:41,420
contenido que quiero y este nul de aquí ahora no será nul, más será un puntero a

40
00:04:41,420 --> 00:04:47,540
este elemento. Y así, así, así, así. Esta es la idea que está por debajo. Si yo quiero

41
00:04:47,540 --> 00:04:52,060
eliminar un elemento, por ejemplo quiero eliminar este elemento de aquí, eliminar

42
00:04:52,060 --> 00:04:58,160
este elemento quiere simplemente ir a su padre, al anterior, de alguna forma, y

43
00:04:58,160 --> 00:05:03,680
modificar que su siguiente, ahora no es el elemento que quiero borrar,

44
00:05:03,680 --> 00:05:10,720
más es el siguiente. O sea, el siguiente del elemento que quiero borrar. De esta forma,

45
00:05:10,720 --> 00:05:18,680
esta cosa de aquí se borra y este elemento de aquí, como no tiene ninguna referencia,

46
00:05:18,680 --> 00:05:25,699
pues desaparecerá como lágrimas en la lluvia. Ahora, decidme que tampoco sabéis esto.

47
00:05:25,699 --> 00:05:33,639
Blade Runner, señores.

48
00:05:34,019 --> 00:05:35,199
No el nuevo, el viejo.

49
00:05:35,720 --> 00:05:36,360
De la hospice.

50
00:05:38,360 --> 00:05:39,480
Puede ser informático

51
00:05:39,480 --> 00:05:40,980
así, pero... Vale.

52
00:05:41,779 --> 00:05:42,939
Entonces, ahora nosotros,

53
00:05:43,300 --> 00:05:44,920
si la teoría está más o menos clara,

54
00:05:45,360 --> 00:05:47,240
pues lo que vamos a hacer es intentar

55
00:05:47,240 --> 00:05:49,019
implementar estas cosas,

56
00:05:49,160 --> 00:05:50,439
pasito a pasito. ¿Vale?

57
00:05:50,680 --> 00:05:53,519
La primera cosa que tenemos que hacer, porque si no, no empezamos,

58
00:05:53,839 --> 00:05:55,120
es el nodo.

59
00:05:55,120 --> 00:05:57,120
¿Vale? Necesito esta cosa aquí,

60
00:05:57,199 --> 00:05:58,980
porque todo se basa sobre eso. Cuando yo

61
00:05:58,980 --> 00:06:05,899
crearé una lista enlazada, el primer elemento será un nodo. Si yo no lo tengo, ¿qué creo?

62
00:06:07,339 --> 00:06:13,420
Esto pasa muchas veces. Cuando yo tengo un programa complejo que usa otras cosas, pues

63
00:06:13,420 --> 00:06:20,240
tengo que empezar desde las clases más sencillas. Si yo tengo una escuela que gestiona materias,

64
00:06:20,399 --> 00:06:26,540
alumnos y profesores, no puedo empezar desde escuela. Porque en cuanto diga, vale, añade

65
00:06:26,540 --> 00:06:31,420
un alumno, no tengo el elemento alumno, no tengo la clase alumno, ¿qué hago? Tengo

66
00:06:31,420 --> 00:06:36,720
que empezar desde las cosas que no dependen de nada, como la clase alumno, o hacer una

67
00:06:36,720 --> 00:06:40,579
estructura de persona, alumno y profesor. Vale, cuando tengo estas cosas aquí ya puedo

68
00:06:40,579 --> 00:06:46,379
ponerme con la escuela diciendo, crea un nuevo alumno, añade un alumno, dar de baja

69
00:06:46,379 --> 00:06:52,939
un alumno, asignar un alumno a un profesor, porque los tengo. Si no tengo alumnos y profesores

70
00:06:52,939 --> 00:07:06,980
no puedo jugar con ellos. Entonces, ¿cómo hacemos nodo? Así. Mi clase nodo tiene un contenido que

71
00:07:06,980 --> 00:07:16,420
por ahora es un object. Podría poner una cosa así. Ahora los nodos son de un objeto que le paso yo.

72
00:07:16,420 --> 00:07:23,439
Son objetos de tipo string o son objetos de tipo gato. Lo defino en el momento en que creo la lista

73
00:07:23,439 --> 00:07:27,040
y la lista tendrá solo nodos de esa materia ahí, ¿vale?

74
00:07:27,139 --> 00:07:32,660
Pero por ahora, nos olvidamos los tipos genéricos y ponemos object, ¿vale?

75
00:07:33,360 --> 00:07:40,519
Además del contenido, que es esta parte de aquí, esto, aquí es donde pondré el objeto, ¿vale?

76
00:07:40,699 --> 00:07:42,279
El contenido va aquí dentro.

77
00:07:42,639 --> 00:07:47,600
Pues necesito una referencia a un siguiente nodo.

78
00:07:47,600 --> 00:07:50,620
entonces tengo una referencia

79
00:07:50,620 --> 00:07:52,519
que se llama siguiente

80
00:07:52,519 --> 00:07:53,800
que es el mal

81
00:07:53,800 --> 00:07:55,819
si yo tengo un determinado nodo

82
00:07:55,819 --> 00:07:57,680
para saber quién está detrás de él

83
00:07:57,680 --> 00:07:59,759
tendré que hacer, si este nodo se llama A

84
00:07:59,759 --> 00:08:01,759
¿qué tendré que hacer para saber

85
00:08:01,759 --> 00:08:02,959
quién viene después de A?

86
00:08:10,050 --> 00:08:11,230
es como tengo la referencia

87
00:08:11,230 --> 00:08:14,329
yo tengo la referencia de A, tengo este objeto nodo que se llama A

88
00:08:14,329 --> 00:08:16,430
¿cómo sé quién viene

89
00:08:16,430 --> 00:08:17,149
después de A?

90
00:08:19,089 --> 00:08:20,689
A punto siguiente

91
00:08:20,689 --> 00:08:22,990
¿entiendes?

92
00:08:23,970 --> 00:08:32,610
ahora vamos a ver cómo se usa pero para qué sentido y luego me he hecho una cosa maestro

93
00:08:32,610 --> 00:08:39,149
un constructor vale para construir un nodo le doy el objeto contenido y él me construye un

94
00:08:39,149 --> 00:08:45,750
objeto cuyo contenido es el que le he pasado yo lo almacena y luego como siguiente ponen un os

95
00:08:45,750 --> 00:08:52,529
acordáis aquí no decíamos cuando nosotros queremos añadir uno nuevo creamos un nuevo objeto con null

96
00:08:52,529 --> 00:09:01,269
y el contenido que sea, y luego me voy al último de mi lista y le digo que tú que apuntabas al null,

97
00:09:01,269 --> 00:09:08,149
ahora no apuntas al null, sino apuntas a este nodo. Pero el que he creado nuevo es el que se queda

98
00:09:08,149 --> 00:09:14,730
con null. Por lo tanto, he hecho un constructor que me crea un nodo con null. Luego ya veré yo

99
00:09:14,730 --> 00:09:24,090
donde encajado, modificando esto. Podríamos ponerlos privados y que luego haya métodos para

100
00:09:24,090 --> 00:09:29,610
modificarlos, que hagan controles y cosas así. Lo mantengo lo más sencillo posible. Todas esas

101
00:09:29,610 --> 00:09:35,230
técnicas de allí ya las conocéis, ya las hemos usado y la tenéis que poner en algún lado de

102
00:09:35,230 --> 00:09:41,669
vuestro cerebro y pensar esas cosas. O sea, ¿qué hago con el contenido? ¿Lo dejo abierto? ¿Lo pongo

103
00:09:41,669 --> 00:09:44,149
en privado

104
00:09:44,149 --> 00:09:45,830
pongo un set contenido para poderlo

105
00:09:45,830 --> 00:09:48,250
modificar, hago algunas comprobaciones

106
00:09:48,250 --> 00:09:49,710
pues todo esto depende del sistema

107
00:09:49,710 --> 00:09:52,149
en el que estáis, nosotros estamos a un nivel más abstracto

108
00:09:52,149 --> 00:09:53,730
estamos viendo como funciona

109
00:09:53,730 --> 00:09:55,389
la lista enlazada, vale

110
00:09:55,389 --> 00:09:57,509
entonces simplifico todo

111
00:09:57,509 --> 00:10:00,049
para llegar a lo más sencillo posible

112
00:10:00,049 --> 00:10:02,450
dudas hasta aquí

113
00:10:02,450 --> 00:10:05,690
vale, entonces crea una extra lista

114
00:10:05,690 --> 00:10:06,269
enlazada

115
00:10:06,269 --> 00:10:15,889
¿Esta lista enlazada que tiene?

116
00:10:16,789 --> 00:10:17,070
ahí

117
00:10:17,070 --> 00:10:22,070
¿Qué es cabeza? Nodo cabeza.

118
00:10:22,070 --> 00:10:34,460
Este es el primer nodo. Cuando creo una lista enlazada, ¿qué hago?

119
00:10:34,460 --> 00:10:49,120
Es igual al nodo. Creo una lista vacía.

120
00:10:49,120 --> 00:11:03,389
La lista vacía es que cabeza es null. ¿Por qué? Porque ¿cuántos elementos hay? Ninguno. ¿Dudas?

121
00:11:05,389 --> 00:11:12,769
Yo lo había hecho directamente sin el constructor, poniendo en el atributo ya directamente que cabeza es igual a null.

122
00:11:16,539 --> 00:11:24,919
Cambia un poquito el momento en que se instancia esa cabeza como cual es null, pero sustancialmente es casi lo mismo.

123
00:11:24,919 --> 00:11:31,879
Yo lo dejo aquí porque así esto se instanciará en el momento en que se crea la lista.

124
00:11:31,879 --> 00:11:34,580
Al crearla es cuando se instancia.

125
00:11:34,580 --> 00:11:36,500
Ok, perfecto.

126
00:11:36,500 --> 00:11:38,919
Entonces vamos a hacer el add.

127
00:11:38,919 --> 00:11:40,860
Ok, perfecto.

128
00:11:40,860 --> 00:11:45,320
Public, en la primera versión de add.

129
00:11:45,320 --> 00:11:48,100
Public, ¿cómo era?

130
00:11:48,100 --> 00:11:52,360
Porque este señor tiene que...

131
00:11:52,360 --> 00:12:04,559
Perfecto. Entonces, ¿qué método tengo que hacer? Pues estos. Con el mismo prototipo,

132
00:12:04,559 --> 00:12:11,799
con la misma declaración del método y sobreescribiéndolo para evitar que me equivoque. Entonces, esto

133
00:12:11,799 --> 00:12:16,740
es mi prototipo. Esto lo que tengo que hacer es devolver nada y me pasa un Object Element.

134
00:12:16,740 --> 00:12:18,179
Entonces, ¿qué tengo que hacer aquí?

135
00:12:18,700 --> 00:12:19,620
¿Qué tenía que hacer?

136
00:12:19,740 --> 00:12:20,259
¿Os acordáis?

137
00:12:20,600 --> 00:12:21,299
Primer paso.

138
00:12:22,480 --> 00:12:22,919
¿Qué hago?

139
00:12:31,289 --> 00:12:32,710
No, no era el primer paso.

140
00:12:34,929 --> 00:12:35,809
La cabeza no la toco.

141
00:12:35,809 --> 00:12:40,850
Yo el primer paso, pues es la comprobación de si la cabeza es siguiente.

142
00:12:41,570 --> 00:12:42,509
Pero ya que es cabeza...

143
00:12:42,509 --> 00:12:43,090
Primer paso.

144
00:12:43,230 --> 00:12:43,649
¿Creo el objeto?

145
00:12:43,850 --> 00:12:44,690
Creo el objeto.

146
00:12:45,649 --> 00:12:45,850
¿Vale?

147
00:12:46,149 --> 00:12:47,389
Creo el nuevo nodo.

148
00:12:47,990 --> 00:12:49,850
Tengo un nodo, no puedo hacer nada.

149
00:12:50,529 --> 00:12:50,789
¿Vale?

150
00:12:51,309 --> 00:12:54,110
Entonces, el primer paso es, creo un nuevo nodo.

151
00:12:54,110 --> 00:13:01,110
Nodo nuevo es igual a new nodo element.

152
00:13:01,110 --> 00:13:12,899
Pues ya está. Por algún lado del multiverso, ¿dónde lo ha creado?

153
00:13:12,899 --> 00:13:18,899
¿Dónde se ha creado este objeto? Os suspendo a todos.

154
00:13:27,259 --> 00:13:31,259
En el heap, que es donde se crean todos los objetos de Java.

155
00:13:31,259 --> 00:14:04,360
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,

156
00:14:04,360 --> 00:14:31,259
¿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?

157
00:14:31,259 --> 00:14:40,759
y un enlace a null. Otro nodo null. ¿Está de acuerdo? Esta es la situación actual. Es lo que he hecho aquí.

158
00:14:40,759 --> 00:14:56,480
Esto. ¿Dudas? Yo, en lugar de crear un objeto, lo que hice fue, cuando ya era el momento de asignar cabeza al siguiente,

159
00:14:56,480 --> 00:15:24,259
Pero aquí hay dos cosas. El objeto no es todo el objeto. El objeto que tú creas es un nodo,

160
00:15:24,259 --> 00:15:31,759
porque luego tú querrás saber su contenido es su siguiente pero tú al ingresar ese objeto en teoría

161
00:15:31,759 --> 00:15:37,220
tendrías que ingresar un nodo no esto no es un nodo es un objeto que tú quieres añadir tú cuando

162
00:15:37,220 --> 00:15:44,539
añades añades un gato no añades un nodo con dentro un gato tú cuando cuando lo usabas antes no añades

163
00:15:44,539 --> 00:15:49,879
un array con dentro del gato tú añades meteme este gato pues el gato se pondrá en el array o se pondrá

164
00:15:49,879 --> 00:16:01,659
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.

165
00:16:01,659 --> 00:16:07,659
Claro, es que en mi hipotético mundo siempre va a ser un nodo.

166
00:16:07,659 --> 00:16:13,659
Tú por dentro creas un nodo, pero por fuera de la lista no puedes forzar que sea un nodo.

167
00:16:13,659 --> 00:16:19,659
¿Por qué no puedes forzar que sea un nodo? Porque la lista te dice añádeme un objeto, no añádeme un nodo.

168
00:16:19,659 --> 00:16:31,200
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.

169
00:16:31,539 --> 00:16:34,360
Porque esto, haciendo un downcasting al nodo, no te funciona.

170
00:16:37,490 --> 00:16:47,750
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,

171
00:16:47,750 --> 00:16:50,450
y esto tiene que funcionar

172
00:16:50,450 --> 00:16:52,350
porque las llamadas son las mismas

173
00:16:52,350 --> 00:16:54,289
y si tú me estás diciendo

174
00:16:54,289 --> 00:16:56,570
que la lista recibe un object

175
00:16:56,570 --> 00:16:58,470
no lo puedes forzar a que sea un nodo

176
00:16:58,470 --> 00:17:00,730
otra cosa es que aquí te pusiera nodo

177
00:17:00,730 --> 00:17:02,509
entonces ya sé que tú me tienes que

178
00:17:02,509 --> 00:17:04,089
añadir un nodo, pero

179
00:17:04,089 --> 00:17:06,390
si me pones un object, no me puedo

180
00:17:06,390 --> 00:17:08,150
yo, esto es

181
00:17:08,150 --> 00:17:10,009
el objeto que se guarda

182
00:17:10,009 --> 00:17:10,650
¿sí?

183
00:17:12,190 --> 00:17:12,670
vale

184
00:17:12,670 --> 00:17:16,150
entonces, he creado

185
00:17:16,150 --> 00:17:33,089
el nuevo nodo. Ahora, ¿qué tengo que hacer? Tengo que buscar el final de mi lista. ¿Cómo

186
00:17:33,089 --> 00:17:38,490
encuentro el final de mi lista? Empezando por cálculo.

187
00:17:38,490 --> 00:17:45,490
¿Y haciendo qué? Preguntándole, oye, ¿tienes alguien después

188
00:17:45,490 --> 00:17:56,289
Entonces, yo empiezo con, por ejemplo, nodo último es igual a cabeza.

189
00:17:59,210 --> 00:18:00,930
Digo, empiezo por la cabeza.

190
00:18:02,390 --> 00:18:10,190
Y aquí voy buscando el siguiente, siguiente, siguiente, siguiente, hasta que llegue al final.

191
00:18:11,029 --> 00:18:12,309
Y aquí tengo dos casos.

192
00:18:13,190 --> 00:18:16,230
El primer caso es que cabeza misma sea nula.

193
00:18:17,630 --> 00:18:32,079
Si último, lo puedo hacer así, si cabeza es nul, entonces quiere decir que mi lista está vacía.

194
00:18:33,019 --> 00:18:34,279
Entonces es fácil, ¿qué hago?

195
00:18:38,140 --> 00:18:40,920
Cabeza siguiente, igualmente.

196
00:18:43,250 --> 00:18:44,049
No, cabeza igual.

197
00:18:50,210 --> 00:18:51,390
Cabeza con terminos.

198
00:18:52,069 --> 00:18:53,390
Cabeza punto con terminos.

199
00:18:56,089 --> 00:18:56,970
¿Qué tipo tiene cabeza?

200
00:18:58,349 --> 00:18:58,950
Nodo.

201
00:18:58,950 --> 00:18:59,869
¿Y este es un?

202
00:19:00,430 --> 00:19:00,910
Nodo.

203
00:19:00,910 --> 00:19:05,150
Pues le digo que mi cabeza apunta al nuevo nodo.

204
00:19:05,329 --> 00:19:07,089
Ya está. Se acabó. Ya lo he metido.

205
00:19:08,250 --> 00:19:09,190
Es el primero de la lista.

206
00:19:09,630 --> 00:19:10,470
Antes estaba null.

207
00:19:10,990 --> 00:19:13,750
No puedo hacer cabeza punto contenido.

208
00:19:15,250 --> 00:19:15,769
Bueno, aquí.

209
00:19:19,180 --> 00:19:20,119
¿Es que esto qué me daría?

210
00:19:23,839 --> 00:19:25,039
¿Qué pasa si hago esto?

211
00:19:30,089 --> 00:19:31,230
Null pointer exception.

212
00:19:31,490 --> 00:19:34,609
Si estoy preguntando si cabeza es null, por lo tanto aquí cabeza es null,

213
00:19:34,609 --> 00:19:39,170
no puedes hacer cabeza punto algo, porque me dará siempre un null pointer exception.

214
00:19:39,170 --> 00:19:47,470
no existe el objeto todavía es un puntero vacío pero yo te digo vale ok este puntero de aquí esta

215
00:19:47,470 --> 00:19:55,730
referencia ahora se referencia al objeto nuevo que creado sustancialmente en mi mundo estaba

216
00:19:55,730 --> 00:20:03,809
en esta situación he creado este objeto quito el nul de aquí y le digo que esta referencia apunta

217
00:20:03,809 --> 00:20:11,670
este objeto. Ya está, he creado una lista con un objeto dentro. La cabecera de esta lista pasa a

218
00:20:11,670 --> 00:20:20,369
ser el nuevo nodo que he creado. Esto en el caso en que mi lista tenía una cabecera null. Si la

219
00:20:20,369 --> 00:20:28,170
cabecera es null, quiere decir que no hay nada, pues este nodo es la cabecera. Os queda claro

220
00:20:28,170 --> 00:20:29,490
en castellano

221
00:20:29,490 --> 00:20:32,490
si yo tengo una lista sin cabeza

222
00:20:32,490 --> 00:20:34,529
y tengo que añadir un nuevo elemento

223
00:20:34,529 --> 00:20:36,250
ese nuevo elemento será un nodo

224
00:20:36,250 --> 00:20:38,509
que será la cabeza de la lista, porque es el único

225
00:20:38,509 --> 00:20:38,950
que hay

226
00:20:38,950 --> 00:20:42,329
¿sí? ¿dudas?

227
00:20:45,329 --> 00:20:45,650
¿dudas?

228
00:20:46,049 --> 00:20:46,930
esa es la pregunta

229
00:20:46,930 --> 00:20:47,890
¿qué es lo que está haciendo?

230
00:20:48,170 --> 00:20:49,809
¿qué es la cabeza? porque no existe

231
00:20:49,809 --> 00:20:53,369
la cabeza por ahora es null, quiere decir que no apunta

232
00:20:53,369 --> 00:20:55,349
en ningún objeto, no puede hacer nada sobre él

233
00:20:55,349 --> 00:20:57,170
si la cabeza es null

234
00:20:57,170 --> 00:20:58,650
pues lo que hago es decir

235
00:20:58,650 --> 00:21:16,619
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í?

236
00:21:16,619 --> 00:21:28,019
Si no, si esto no es verdad, quiere decir que ya antes se ha añadido a alguien, y por

237
00:21:28,019 --> 00:21:39,819
lo tanto cabeza no es null, y por lo tanto se puede empezar a navegar la lista, que quiere

238
00:21:39,819 --> 00:21:40,819
decir navegar.

239
00:21:40,819 --> 00:21:46,259
Que yo empezaré desde cabeza y diré, ves al siguiente, y si el siguiente existe, diré

240
00:21:46,259 --> 00:21:50,339
va a ser el siguiente. Y si el siguiente existe, va a ser el siguiente. Y si el siguiente no

241
00:21:50,339 --> 00:21:56,099
es el siguiente. ¿Vale? Hasta llegar al fondo de la lista.

242
00:22:04,650 --> 00:22:09,049
La cabeza sigue siendo el primer. La cabeza sigue siendo el primer.

243
00:22:10,230 --> 00:22:15,910
Yo no pillo cabeza. Yo voy navegando la lista desde cabeza, porque ahí es donde

244
00:22:15,910 --> 00:22:20,630
empieza mi lista, hacia el último nodo. Y ahora vamos a ver cómo se hace.

245
00:22:22,630 --> 00:22:32,569
Vamos a ver, no lo he hecho. Esto no es la solución. Os estoy diciendo qué voy a hacer,

246
00:22:32,569 --> 00:22:41,049
¿os molesta esto? Lo que tengo que hacer es empezar desde cabeza e ir navegando. Es que veis

247
00:22:41,049 --> 00:22:47,470
el código y ya no razonáis, porque yo lo he dicho, ya está grabado, ahora lo escucháis en casa. Mientras

248
00:22:47,470 --> 00:22:50,869
Ellos decían que voy a hacer, vosotros me echabais el código y decíais, no lo haces.

249
00:22:51,349 --> 00:22:53,109
Pues no, no lo hemos hecho el código.

250
00:22:53,710 --> 00:22:56,490
Pero no se puede picar código si no entendéis que se lo haces.

251
00:22:57,329 --> 00:22:57,529
¿Vale?

252
00:22:57,529 --> 00:23:07,170
Entonces mi idea es, empezaré desde cabeza y voy buscando el siguiente, el siguiente, el siguiente, el siguiente, hasta encontrar el último.

253
00:23:07,970 --> 00:23:09,630
¿Cuál será el último?

254
00:23:12,450 --> 00:23:13,549
El que tenga...

255
00:23:14,109 --> 00:23:15,230
La base.

256
00:23:15,230 --> 00:23:23,990
Es que tenga como siguiente nul.

257
00:23:23,990 --> 00:23:33,950
Cuando yo me pillo un nodo, a partir de cabeza, y le pregunto ¿tu siguiente es nul o no?

258
00:23:33,950 --> 00:23:38,029
Si tu siguiente no es nul, voy al siguiente.

259
00:23:38,029 --> 00:23:43,329
Si tu siguiente es nul, tú eres el último.

260
00:23:43,329 --> 00:23:45,569
¿Método que hago?

261
00:23:45,569 --> 00:23:47,289
Voy a buscar el nodo último.

262
00:23:47,710 --> 00:23:49,769
Dejádmelo hacer y luego, si no lo entendéis,

263
00:23:49,829 --> 00:23:51,150
se lo hacemos preguntar, porque si no, no avanzamos.

264
00:23:52,150 --> 00:23:54,049
Entonces, me pillo una deferencia

265
00:23:54,049 --> 00:23:54,589
a la cabeza.

266
00:23:56,170 --> 00:23:57,470
Y me pregunto,

267
00:23:57,890 --> 00:23:59,430
me digo, mientras

268
00:23:59,430 --> 00:24:02,819
último

269
00:24:02,819 --> 00:24:05,000
punto siguiente

270
00:24:05,000 --> 00:24:07,440
no es nul,

271
00:24:11,440 --> 00:24:13,619
último es igual

272
00:24:13,619 --> 00:24:15,640
a último punto

273
00:24:15,640 --> 00:24:32,240
siguiente. Empieza desde la cabeza. Voy a mirar siguiente. Si siguiente no es nul, este

274
00:24:32,240 --> 00:24:38,119
último ya no es esto, más el siguiente. Y ahora voy a mirar si su siguiente no es

275
00:24:38,119 --> 00:24:45,519
nul, último no es esto, más esto. Y si este tiene siguiente que no es nul, pues último

276
00:24:45,519 --> 00:24:50,519
no es esto, más esto. Hasta llegar a uno que cuando voy a mirar último punto siguiente

277
00:24:50,519 --> 00:24:51,480
me dice es null.

278
00:24:52,700 --> 00:24:54,400
Entonces salgo de este while

279
00:24:54,400 --> 00:24:56,440
y mi último me está

280
00:24:56,440 --> 00:24:57,880
apuntando al último nodo.

281
00:24:59,380 --> 00:25:00,720
O sea, estás buscando el último.

282
00:25:01,240 --> 00:25:02,799
Sí, por eso se llama último.

283
00:25:05,880 --> 00:25:07,000
Lo repito.

284
00:25:07,000 --> 00:25:07,079
¿No?

285
00:25:13,200 --> 00:25:14,279
Si quieres,

286
00:25:14,559 --> 00:25:16,779
si quieres esta cosa de aquí,

287
00:25:16,880 --> 00:25:18,640
la puedes poner en

288
00:25:18,640 --> 00:25:21,519
un método que se llama busca último

289
00:25:21,519 --> 00:25:23,039
que hace esta cosa de aquí

290
00:25:23,039 --> 00:25:25,380
y te devuelve un nodo y aquí se queda

291
00:25:25,380 --> 00:25:27,220
más limpio, el último es igual a

292
00:25:27,220 --> 00:25:27,839
busca último

293
00:25:27,839 --> 00:25:34,819
esto no es un método

294
00:25:34,819 --> 00:25:36,279
pero si es un método

295
00:25:36,279 --> 00:25:37,119
lo tendría que sacar

296
00:25:37,119 --> 00:25:39,680
pero, fijaos

297
00:25:39,680 --> 00:25:42,200
este es un código que lo que hace es buscar el último

298
00:25:42,200 --> 00:25:44,619
¿como funciona?

299
00:25:46,200 --> 00:25:47,259
vamos a verlo aquí

300
00:25:47,259 --> 00:25:50,059
en una lista ya creada, esta de aquí

301
00:25:50,740 --> 00:25:57,619
Porque hemos dicho que, fijaos, que si cabeza es nul, ya lo hemos hecho antes.

302
00:25:58,460 --> 00:26:00,160
O sea, es una parte distinta.

303
00:26:00,319 --> 00:26:04,740
Si yo llego aquí, a este else, quiere decir que cabeza no es nul.

304
00:26:05,319 --> 00:26:06,500
Cabeza ya es un objeto.

305
00:26:07,400 --> 00:26:09,940
Entonces, imaginámonos que tengo esta lista de aquí.

306
00:26:11,420 --> 00:26:14,519
Entonces, mi cabeza es este objeto de aquí.

307
00:26:14,740 --> 00:26:15,519
Este es el objeto.

308
00:26:15,519 --> 00:26:22,079
Entonces, yo me creo una referencia última que apunta a este objeto.

309
00:26:22,079 --> 00:26:23,079
Esto es último.

310
00:26:23,079 --> 00:26:26,160
¿Sí?

311
00:26:26,160 --> 00:26:36,880
Y empiezo y digo, me pregunto, último punto siguiente, ¿es nulo o no?

312
00:26:36,880 --> 00:26:42,049
¿Es nulo o no?

313
00:26:42,049 --> 00:26:50,509
Hola, último punto siguiente, este campo de aquí, aquí dentro, ¿hay nulo o no?

314
00:26:50,509 --> 00:26:51,509
No.

315
00:26:51,509 --> 00:26:57,569
Por lo tanto, último punto siguiente no es nul, por lo tanto, yo digo que último es

316
00:26:57,569 --> 00:27:04,269
igual a último punto siguiente, o sea, que esta referencia de aquí es igual a esta referencia

317
00:27:04,269 --> 00:27:05,269
de aquí.

318
00:27:05,269 --> 00:27:09,690
Es decir, que ahora no apunto a esto, más apunto a esto.

319
00:27:09,690 --> 00:27:13,710
¿Y repite el último punto?

320
00:27:13,710 --> 00:27:20,470
Me acuerdo que esa es una referencia, que se referencia a cabeza porque lo he puesto

321
00:27:20,470 --> 00:27:21,470
aquí.

322
00:27:21,470 --> 00:27:27,569
Ahora te digo que si último punto siguiente, o sea, si yo me voy a este objeto, porque último apunta aquí,

323
00:27:28,329 --> 00:27:35,549
me voy a su campo siguiente y encuentro que aquí no hay null, hay null, no.

324
00:27:36,089 --> 00:27:41,769
Pues entonces ejecuto esta cosa aquí, que me dice que en la referencia de último aquí dentro,

325
00:27:42,410 --> 00:27:45,670
ahora pon lo que hay en último punto siguiente.

326
00:27:45,670 --> 00:27:52,069
O sea, me voy a último, me voy a punto siguiente, último punto siguiente es este objeto de aquí,

327
00:27:52,710 --> 00:27:55,930
y lo guardo dentro de la referencia de último.

328
00:27:57,089 --> 00:28:03,009
O sea, que si el siguiente, si fuera el último, estaría a punto de ir a un nudo.

329
00:28:03,309 --> 00:28:03,829
Ahora llegamos.

330
00:28:04,650 --> 00:28:06,670
Claro, en este caso...

331
00:28:07,390 --> 00:28:12,089
Ahora estoy aquí, no he acabado, porque el while no ha acabado.

332
00:28:12,089 --> 00:28:18,910
El while vuelve aquí y se pregunta, último punto siguiente, ¿no es null?

333
00:28:20,589 --> 00:28:26,910
Voy a mirar, ahora último apunta a este, me voy a mirar su siguiente, ¿y qué pone aquí?

334
00:28:28,329 --> 00:28:29,049
Null.

335
00:28:29,890 --> 00:28:31,950
Por lo tanto, salgo del while.

336
00:28:32,930 --> 00:28:39,190
Y cuando llego aquí fuera del while, último está apuntando al último elemento de la lista.

337
00:28:39,190 --> 00:28:46,950
¿Lo veis? Hacemos un ejemplo con tres. No tengo una lista con tres. No, hagamos una lista con tres.

338
00:28:46,950 --> 00:29:05,349
Entonces, imaginaos que estamos en esta situación de aquí. Tengo una lista, que es esta de aquí,

339
00:29:05,349 --> 00:29:16,619
que tiene la cabecera que apunta a este nodo de aquí. Este es un nodo que tiene un objeto y un

340
00:29:16,619 --> 00:29:26,099
un puntero a otro nodo. Que tiene un objeto y un puntero a otro nodo. Y este de aquí tiene un

341
00:29:26,099 --> 00:29:37,180
objeto y null, el último de la lista. Entonces, ¿qué hago yo? Entro en este while, entro en esta

342
00:29:37,180 --> 00:29:44,920
parte de aquí, ¿vale? Entro en el método add. Me pregunta, ¿cabecero es igual a null? No,

343
00:29:44,920 --> 00:29:48,799
No, porque cabecera apunta a un objeto, por lo tanto no es null.

344
00:29:48,799 --> 00:29:54,599
Me salto esta parte del if, voy al elche, me dice, ok, créame una referencia que se

345
00:29:54,599 --> 00:30:07,200
llama último, esta referencia aquí, que apunta a cabecera, aquí, ¿estamos a acuerdo hasta

346
00:30:07,200 --> 00:30:09,200
aquí?

347
00:30:09,200 --> 00:30:15,259
No apunta a donde apunta cabecera, estoy copiando lo que está aquí dentro, lo estoy copiando

348
00:30:15,259 --> 00:30:22,579
aquí dentro. Por lo tanto, apuntan al mismo objeto. ¿Duda hasta aquí o no?

349
00:30:22,579 --> 00:30:33,700
Hola. Vale. Entonces me pregunta, ¿último punto siguiente es distinto de null?

350
00:30:33,700 --> 00:30:43,299
Último punto siguiente, ¿es null o no? No, es distinto de null. Por lo tanto, este while

351
00:30:43,299 --> 00:30:51,579
es true. Esta condición es true. No es null. Por lo tanto, entro dentro y ejecuto. ¿Qué

352
00:30:51,579 --> 00:30:57,579
dice esto? Dice, píllame último punto siguiente. ¿Quién es último punto siguiente? Último

353
00:30:57,579 --> 00:31:09,829
punto siguiente. Es este nodo de aquí. Esto lo guardas dentro último. Quitas esto y haces

354
00:31:09,829 --> 00:31:13,230
esto es como cuando hacíamos

355
00:31:13,230 --> 00:31:15,049
x es igual a x más 5

356
00:31:15,049 --> 00:31:17,069
¿os acordáis?

357
00:31:17,170 --> 00:31:18,769
x es igual a x más 5

358
00:31:18,769 --> 00:31:21,609
¿qué hacía?

359
00:31:22,329 --> 00:31:23,650
si x vale 3

360
00:31:23,650 --> 00:31:28,640
porque dices, píllame lo que hay dentro de x

361
00:31:28,640 --> 00:31:30,819
suma de 5, hace 8

362
00:31:30,819 --> 00:31:32,619
y me lo guardas en x

363
00:31:32,619 --> 00:31:34,880
por lo tanto borras esto y pones 8

364
00:31:34,880 --> 00:31:36,799
¿os acordáis?

365
00:31:38,039 --> 00:31:38,740
es lo mismo

366
00:31:38,740 --> 00:31:40,740
tú te estás diciendo dentro de último

367
00:31:40,740 --> 00:31:48,240
que es una referencia a un objeto, ponme último punto siguiente. Entonces el siguiente objeto.

368
00:31:48,240 --> 00:31:55,480
Y ahora aquí dentro esta referencia se ha borrado y último apunta a este objeto de aquí. Y vuelvo

369
00:31:55,480 --> 00:32:02,519
al principio del while y me pregunto, último punto siguiente, es nulo o no? Pero esta vez último no

370
00:32:02,519 --> 00:32:08,160
es este, porque ya he borrado esta referencia. Ahora último es este objeto de aquí. Llamamos

371
00:32:08,160 --> 00:32:16,380
este es N1, esto es N2 y esto es N3. Ahora estoy apuntando a N2, ¿sí o no?

372
00:32:16,380 --> 00:32:25,359
Entonces me va a preguntar, N2 punto, o sea, último punto siguiente, ¿es nulo o no?

373
00:32:26,759 --> 00:32:35,039
No, porque tiene un puntero justo. Entonces, ¿qué hago? Me voy a mirar aquí y entro dentro,

374
00:32:35,039 --> 00:32:43,279
y digo que último, dentro último, guárdame la referencia de último punto siguiente. Último es

375
00:32:43,279 --> 00:32:51,960
esto, punto siguiente es este objeto de aquí, por lo tanto se borra esta referencia y se apunta a

376
00:32:51,960 --> 00:33:08,690
esto y vuelvo al while y me pregunto último punto siguiente es distinto de null ahora no ahora este

377
00:33:08,690 --> 00:33:16,849
de aquí apuntado por último punto siguiente es null por lo tanto no entro dentro del while y

378
00:33:16,849 --> 00:33:24,589
salgo aquí fuera. Y después de esto while, en el campo último, en la variable último,

379
00:33:24,589 --> 00:33:36,890
estoy apuntando al último objeto de la lista. He recorrido la lista hasta encontrar el último.

380
00:33:36,890 --> 00:34:03,190
Yo tengo un puntero, un nodo. Último es un nodo. Y ahora tengo contenido y siguiente

381
00:34:03,190 --> 00:34:10,650
del último nodo. Último me apunta al nodo último que he añadido, anterior que he añadido.

382
00:34:10,650 --> 00:34:17,090
Entonces ahora tengo todos los elementos. Tengo el último de la lista guardado en último

383
00:34:17,090 --> 00:34:22,489
Y el nuevo objeto que quiero añadir, que es esto, que he creado antes, ¿vale?

384
00:34:22,869 --> 00:34:27,510
Este de aquí con un nuevo objeto y null es el que he creado aquí.

385
00:34:28,409 --> 00:34:28,769
¿Recordáis?

386
00:34:28,769 --> 00:34:34,489
Este es el nuevo elemento que quiero añadir, el nuevo nodo que quiero añadir,

387
00:34:34,610 --> 00:34:36,789
con dentro el elemento que me has dicho de añadir.

388
00:34:38,090 --> 00:34:39,250
Entonces, ¿qué tendré que hacer aquí?

389
00:34:42,679 --> 00:34:45,400
Último punto siguiente es igual a el de aquí.

390
00:34:46,159 --> 00:34:51,099
Último punto siguiente es igual.

391
00:34:51,380 --> 00:35:10,500
En nuestra gráfica, último punto siguiente, que era null, ahora en vez de null, haz que apunte al nuevo objeto que he creado.

392
00:35:10,820 --> 00:35:26,710
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.

393
00:35:26,710 --> 00:35:32,469
Y ahora encuentra este volumen y lo añadirá después.

394
00:35:32,469 --> 00:35:34,469
¿Y ese sería el primero de la lista?

395
00:35:34,469 --> 00:35:35,469
¿Quién?

396
00:35:35,469 --> 00:35:36,469
El último.

397
00:35:36,469 --> 00:35:37,469
No.

398
00:35:37,469 --> 00:35:38,469
¿Pero de la lista quién es?

399
00:35:38,469 --> 00:35:39,469
Cabeza.

400
00:35:39,469 --> 00:35:40,469
Cabeza.

401
00:35:40,469 --> 00:35:45,039
Por eso se llama cabeza.

402
00:35:45,039 --> 00:35:55,039
Nosotros, por la lista que hemos creado, nos dice, explícitamente, se añade al final.

403
00:35:55,039 --> 00:36:08,159
porque si lo añadiera al principio sería más fácil y yo cabeza lo apuntó al nuevo y siguiente es la

404
00:36:08,159 --> 00:36:14,989
cabeza vieja pero aquí me han dicho que lo tengo que añadir al final

405
00:36:14,989 --> 00:36:37,380
pero eso después

406
00:36:39,059 --> 00:36:51,289
dudas hasta aquí se puede mejorar esto claro pero me interesa esta cosa de aquí

407
00:36:51,289 --> 00:36:59,650
si la entendéis o no. No que seáis capaces de replicarla para los próximos dos o tres

408
00:36:59,650 --> 00:37:07,630
días, pero entendéis que estoy haciendo o no. Porque aquí, la base aquí es que nosotros

409
00:37:07,630 --> 00:37:11,730
hemos hablado de referencias, hemos hablado de objetos, hemos hablado de referencia a

410
00:37:11,730 --> 00:37:17,969
un objeto, de variables de tipo objeto y hemos hablado de instancias de objetos. Pero vosotros

411
00:37:17,969 --> 00:37:19,250
No le veis la diferencia.

412
00:37:20,090 --> 00:37:21,050
Aún así lo hemos usado.

413
00:37:21,230 --> 00:37:28,949
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.

414
00:37:28,949 --> 00:37:33,289
Entonces, ahí hemos visto que referencia e instancia son dos cosas distintas.

415
00:37:34,690 --> 00:37:37,429
Aquí lo que estoy haciendo es jugar con la referencia.

416
00:37:38,650 --> 00:37:43,949
Estoy cambiando la referencia de último a varias instancias distintas.

417
00:37:43,949 --> 00:37:48,949
Ahora apuntas a este objeto, ahora apuntas a este otro objeto, ahora apuntas a este otro.

418
00:37:48,949 --> 00:37:57,800
Estoy copiando el numerito que está aquí, aquí.

419
00:37:57,800 --> 00:38:04,800
Y entonces ahora no me apunta a esta zona de memoria, me apunta a esta zona de memoria, donde está el segundo objeto.

420
00:38:04,800 --> 00:38:11,800
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í.

421
00:38:11,800 --> 00:38:35,510
No, puedo pasar del primero al último porque no tengo un salto para llegar al último y

422
00:38:35,510 --> 00:38:44,789
puedo solo saltar al siguiente. Como lo estamos implementando nosotros, así es.

423
00:38:44,789 --> 00:38:46,409
Luego, ¿que queremos mejorarlo? Sí.

424
00:38:47,369 --> 00:38:48,929
¿Puedo hacerme un array que apunta

425
00:38:48,929 --> 00:38:50,789
a cada uno de los elementos? Sí, pero entonces

426
00:38:50,789 --> 00:38:51,429
vuelvo a los array.

427
00:38:53,429 --> 00:38:53,809
No quiero.

428
00:38:56,199 --> 00:38:58,139
¿Sí? Ahora,

429
00:39:00,949 --> 00:39:02,090
no está en lista.

430
00:39:02,809 --> 00:39:04,409
¿Vale? Add es

431
00:39:04,409 --> 00:39:06,250
lista, pero nosotros creamos

432
00:39:06,250 --> 00:39:08,150
ahora aquí, porque nos gusta,

433
00:39:08,750 --> 00:39:10,590
public void

434
00:39:10,590 --> 00:39:11,769
addFirst

435
00:39:11,769 --> 00:39:14,050
object

436
00:39:14,050 --> 00:39:15,530
element.

437
00:39:17,489 --> 00:39:18,130
AddFirst

438
00:39:18,130 --> 00:39:20,690
es un método especial

439
00:39:20,690 --> 00:39:22,469
de lista enlazada, no es

440
00:39:22,469 --> 00:39:24,550
de lista, o sea que si tú

441
00:39:24,550 --> 00:39:26,389
usas lista no lo puedes usar, pero

442
00:39:26,389 --> 00:39:28,329
si usas una lista enlazada sí

443
00:39:28,329 --> 00:39:30,690
¿vale? donde te está diciendo

444
00:39:30,690 --> 00:39:32,130
añádelo primero

445
00:39:32,130 --> 00:39:33,909
no lo añadas al fondo

446
00:39:33,909 --> 00:39:35,969
como es la add normal

447
00:39:35,969 --> 00:39:38,250
pero quiero que se añada como

448
00:39:38,250 --> 00:39:39,349
primero de la lista

449
00:39:39,349 --> 00:39:42,349
¿cómo añado un elemento

450
00:39:42,349 --> 00:39:44,230
primero de la lista? primero me creo

451
00:39:44,230 --> 00:39:46,110
nodo nuevo

452
00:39:46,110 --> 00:39:57,380
es igual a new nodo de elemento. Vale, he creado el nuevo nodo. Ahora, para entendernos,

453
00:39:57,380 --> 00:40:09,800
no quiero crearlo y añadirlo aquí. Lo quiero meter aquí. ¿Cómo lo hago? Aquí. Añado primero

454
00:40:09,800 --> 00:40:19,860
Entonces tengo mi nuevo nodo con dentro no sé qué, con null detrás. ¿Qué hago?

455
00:40:19,860 --> 00:40:27,380
La referencia de la cabecera.

456
00:40:27,380 --> 00:40:50,199
Cabeza, punto siguiente, es igual al nuevo, ¿os gusta?

457
00:40:50,199 --> 00:41:12,780
No estoy sobreescribiendo nada.

458
00:41:12,780 --> 00:41:24,099
Cabeza, punto siguiente, igual a nuevo. Y después tienes que, de nuevo, punto siguiente, igual a cabeza, punto siguiente, más arriba.

459
00:41:24,099 --> 00:41:29,099
La estoy mirando como un rey, creo. Yo también.

460
00:41:29,099 --> 00:41:40,940
Si yo hago esto, ¿qué he hecho? He dicho que cabeza no apunta aquí,

461
00:41:40,940 --> 00:41:41,960
Va, apunta aquí.

462
00:41:42,800 --> 00:41:43,400
Resultado.

463
00:41:44,059 --> 00:41:44,980
Me he cargado la lista.

464
00:41:48,039 --> 00:41:50,380
He perdido toda esta referencia.

465
00:41:53,559 --> 00:41:54,760
Porque van en cadena.

466
00:41:55,300 --> 00:41:56,559
Si quitas del primero,

467
00:41:56,719 --> 00:41:58,300
todo lo demás van, puede igual.

468
00:41:58,679 --> 00:42:00,880
Si ahora intento hacer cabeza aquí,

469
00:42:01,420 --> 00:42:02,820
cabeza, punto siguiente,

470
00:42:03,360 --> 00:42:05,000
cabeza, punto siguiente,

471
00:42:05,099 --> 00:42:05,440
es nulo.

472
00:42:06,840 --> 00:42:07,340
He acabado.

473
00:42:07,340 --> 00:42:09,659
Me he cargado todo el resto de la lista.

474
00:42:17,949 --> 00:42:42,219
En el cable, referenciando a N2, hago punto siguiente, es igual a, puede ser punto siguiente, punto siguiente, es igual a,

475
00:42:42,219 --> 00:43:13,989
Yo antes de hacer esto, pillo, o sea, antes de hacer esto, lo que hago es pillar y decir,

476
00:43:13,989 --> 00:43:24,309
al nodo nuevo, copio en su siguiente, nuevo punto siguiente, le copio a donde apunta cabeza,

477
00:43:24,309 --> 00:43:34,809
esto. Se lo copio aquí. Entonces ahora esto apunta aquí. Y después de haber guardado

478
00:43:34,809 --> 00:43:50,960
esta referencia, borro esto y apunto aquí. Entonces ahora sí me funciona. Y es mucho

479
00:43:50,960 --> 00:43:58,760
más sencillo que añadirla al final. No tengo que recorrer todo.

480
00:43:58,760 --> 00:44:05,559
Y el nuevo apuntaría al siguiente nodo.

481
00:44:05,559 --> 00:44:13,099
He copiado lo que antes, antes de hacer el cambio, he copiado a donde apuntaba

482
00:44:13,099 --> 00:44:18,960
cabeza, lo he copiado en su siguiente.

483
00:44:18,960 --> 00:44:25,019
Por lo tanto, se ha quedado, se ha quedado guardado este enlace de aquí, esta referencia de aquí.

484
00:44:25,539 --> 00:44:28,500
Entonces, ahora tengo N1 en posición 2.

485
00:44:29,940 --> 00:44:37,940
Y después he borrado la cabeza que apuntaba N1 y le he dicho, la cabeza ahora es este nuevo.

486
00:44:39,860 --> 00:44:44,880
Pero se ha quedado que si yo hago cabeza, punto siguiente, me estoy yendo a este.

487
00:44:45,980 --> 00:44:48,480
Punto siguiente a este, punto siguiente a este.

488
00:44:48,960 --> 00:44:56,920
Que me ha quedado toda la lista, no la he perdido, añadiendo el nuevo elemento, en vez que al final, al principio.

489
00:45:06,780 --> 00:45:07,900
Dejadme hacer así.

490
00:45:16,670 --> 00:45:18,469
Tengo una lista vacía.

491
00:45:23,469 --> 00:45:28,869
Esta lista vacía tiene una referencia a null.

492
00:45:29,429 --> 00:45:40,880
¿Estamos de acuerdo? Voy a utilizar ADD por ahora, no ADD first, ADD, el que añade al final.

493
00:45:41,980 --> 00:45:53,880
Entonces, ¿qué hago? Añado un nuevo elemento. Vale, creo un nuevo nodo, que da N1, con dentro un objeto, y aquí null.

494
00:45:53,880 --> 00:46:06,400
¿Estamos de acuerdo con esto? Y luego modifico cabecera, que no es un objeto, es un puntero,

495
00:46:06,400 --> 00:46:26,260
le quito el null de dentro y le pongo un enlace a n1. ¿Estamos de acuerdo con esto? Entonces,

496
00:46:26,260 --> 00:46:35,940
La cabecera es ésta, tiene un solo elemento. Si ahora uso otra vez add, creo un segundo

497
00:46:35,940 --> 00:46:44,480
objeto en una posición de memoria que llamaré n2, que tiene dentro su objeto no sé qué,

498
00:46:44,480 --> 00:46:55,840
que apunta null, luego pillo una referencia que se llama último, le pongo que dentro

499
00:46:55,840 --> 00:47:03,579
tiene lo que tiene ce, o sea la cabecera, la cabeza, o sea n1, y voy a n1, o sea que

500
00:47:03,579 --> 00:47:10,739
esto es un entero aquí, y voy a n1 y le pregunto, oye mira, n1 punto, perdón, que antes se

501
00:47:10,739 --> 00:47:20,730
me ha olvidado, no, ok, n1 punto siguiente es nul, sí, por lo tanto el último es n1.

502
00:47:20,730 --> 00:47:41,750
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í.

503
00:47:41,750 --> 00:47:54,719
Y he añadido como último N2. ¿Dudas? Hay un borrador. Borrar, borrar.

504
00:47:55,920 --> 00:48:06,929
Este último ya no me interesa, lo borramos, porque solo se usa cuando añado.

505
00:48:06,929 --> 00:48:14,929
¿Sí? ¿Dudas hasta aquí? Voy a añadir uno primero. Ahora voy a usar Add First.

506
00:48:14,929 --> 00:48:19,929
Entonces, ¿qué hace Add First? Sigámoslo aquí.

507
00:48:19,929 --> 00:48:31,110
Add First me dice, crea un nuevo nodo. Vale, creo un nuevo nodo.

508
00:48:31,110 --> 00:48:38,070
un nuevo nodo, lo creo aquí, por ejemplo, esa hará el nodo 3, o sea, en posición de memoria N3,

509
00:48:38,070 --> 00:48:47,610
sea lo que sea lo que quiera decir. ¿Vale? Con dentro su elemento y una referencia null.

510
00:48:47,610 --> 00:48:57,199
Vale, muy bien. Ahora, ¿qué me dice? Me dice, nuevo punto siguiente, nuevo es esto,

511
00:48:57,199 --> 00:49:16,380
Punto siguiente es este de aquí. Es igual a cabeza. Es decir, que aquí quito el null y pongo n1.

512
00:49:16,380 --> 00:49:23,780
Estoy copiando dentro de esta referencia lo que está escrito dentro de esta referencia.

513
00:49:23,780 --> 00:49:36,860
Es decir, que ahora esto es un puntero aquí. Y después digo, cabeza, punto siguiente igual nuevo.

514
00:49:36,860 --> 00:49:51,090
No. Esto es cabeza. Esto lo veo, se me ha quedado de lado. Esto es así, cabeza igual nuevo. Así. Justo.

515
00:49:51,090 --> 00:50:02,380
O sea, que digo que cabeza, ahora en vez que N1, me quitas N1 y guardas aquí.

516
00:50:11,059 --> 00:50:17,219
Y ahora aquí dentro pones, ¿cómo se llama esto? N3.

517
00:50:22,639 --> 00:50:30,719
Porque cabeza es un nodo y directamente apunta al primero de la lista.

518
00:50:33,059 --> 00:50:40,059
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?

519
00:50:40,780 --> 00:50:44,039
Cabeza lo sustituyo con el nuevo nodo que he creado.

520
00:50:48,300 --> 00:50:57,599
Entonces ahora, cabeza va a N3 y desde dentro de N3 encuentro la referencia para llegar a N1, porque la he guardado antes.

521
00:50:58,300 --> 00:51:04,800
El problema es si esto lo hago al revés, o sea, antes hago la cabeza, pues pierdo la referencia.

522
00:51:04,800 --> 00:51:12,369
Si yo hago cabeza nuevo aquí, sustituyo esto con n3 y he perdido n1.

523
00:51:12,369 --> 00:51:16,369
Ya no tengo escrito n1 por ninguna parte, entonces no lo puedo añadir aquí.

524
00:51:16,369 --> 00:51:27,059
Pero mi pregunta es, ahí la cabeza solo tiene referencia a n1.

525
00:51:27,059 --> 00:51:30,059
O sea, no tiene un contenido como tal.

526
00:51:30,059 --> 00:51:39,460
Si tú haces cabeza.contenido, estás accediendo a esto.

527
00:51:39,460 --> 00:51:47,519
en el 3 ahora si haces cabeza punto siguiente estás haciendo a esto

528
00:52:03,300 --> 00:52:10,079
entonces tú le estás pasando todo esto como referente apunta al primero

529
00:52:10,079 --> 00:52:20,519
es el nuevo objeto que has creado

530
00:52:20,519 --> 00:52:26,590
tú acabas de crear este objeto nuevo

531
00:52:26,590 --> 00:52:28,869
es lo que quieres insertar

532
00:52:28,869 --> 00:52:30,650
entonces a este objeto de aquí

533
00:52:30,650 --> 00:52:32,849
tú tendrás una variable nuevo aquí

534
00:52:32,849 --> 00:52:34,530
como antes tenías una variable

535
00:52:34,530 --> 00:52:36,769
que tiene dentro

536
00:52:36,769 --> 00:52:37,309
n3

537
00:52:37,309 --> 00:52:39,170
o sea un puntero aquí

538
00:52:39,170 --> 00:52:43,579
y entonces una vez que tienes esto

539
00:52:43,579 --> 00:52:50,599
nuevo punto siguiente sería n3 punto siguiente guardas la cabeza lo que estaba antes aquí o sea

540
00:52:50,599 --> 00:53:01,820
n1 lo guardas aquí y luego cabeza es igual al nuevo o sea el principio es n3 copias esto aquí

541
00:53:02,820 --> 00:53:14,730
y tienes tú un lado lo que a mí me confunde es que tú estás apuntando a toda la cabeza toda la

542
00:53:14,730 --> 00:53:25,030
cabeza no solo es N1, en teoría, también es contenible, entonces…

543
00:53:25,030 --> 00:53:39,369
Pero es como cuando tú tienes una casa, cuando tú creas una persona, un alumno, tú tienes

544
00:53:39,369 --> 00:53:50,369
Por un lado, y haces alumno a es igual a new alumno, con sus datos.

545
00:53:50,969 --> 00:53:59,550
Tú por un lado te creas el objeto, donde tienes el nombre, el apellido, las materias, los profesores, lo que sea.

546
00:53:59,550 --> 00:54:12,269
Pero esta cosa de aquí, que es la referencia, es una variable de tipo alumno que se llama a y que

547
00:54:12,269 --> 00:54:20,969
tiene una referencia a la zona de memoria donde están las cosas. Tú no tienes aquí dentro el

548
00:54:20,969 --> 00:54:27,489
el objeto. Tú aquí dentro tienes la referencia al objeto. O sea, dónde buscarlo dentro del

549
00:54:27,489 --> 00:54:34,250
I. Un código, que nosotros hemos llamado N1 y esto será A1, aquí dentro está escrito

550
00:54:34,250 --> 00:54:40,510
A1, que es la zona de memoria donde lo vas a encontrar. Entonces, cuando tú luego haces

551
00:54:40,510 --> 00:54:42,510
A punto nombre

552
00:54:42,510 --> 00:54:45,690
Lo que estás haciendo es

553
00:54:45,690 --> 00:54:48,429
Vete a esta zona de memoria

554
00:54:48,429 --> 00:54:49,570
Aquí

555
00:54:49,570 --> 00:54:52,750
Y desde aquí busca nombre

556
00:54:52,750 --> 00:54:53,730
Esto

557
00:54:53,730 --> 00:54:59,199
Entonces, cabecera

558
00:54:59,199 --> 00:55:02,320
No apunta al siguiente

559
00:55:02,320 --> 00:55:03,579
Apunta a un objeto

560
00:55:03,579 --> 00:55:05,780
Es el primo objeto de mi lista

561
00:55:05,780 --> 00:55:06,340
¿Cuál es?

562
00:55:06,559 --> 00:55:07,539
Todo este objeto

563
00:55:07,539 --> 00:55:10,440
Luego tú podrás preguntar

564
00:55:10,440 --> 00:55:12,039
Cabeza punto contenido

565
00:55:12,039 --> 00:55:14,500
entonces llegarás a este objeto

566
00:55:14,500 --> 00:55:16,579
e irás a la parte de contenido

567
00:55:16,579 --> 00:55:18,420
o cabeza punto siguiente

568
00:55:18,420 --> 00:55:20,460
entonces llegarás a esta cabeza

569
00:55:20,460 --> 00:55:22,219
y te irás al siguiente

570
00:55:22,219 --> 00:55:24,699
entonces alcanzarás el siguiente

571
00:55:24,699 --> 00:55:26,599
o sea, primero

572
00:55:26,599 --> 00:55:28,760
vas apuntando a la referencia

573
00:55:28,760 --> 00:55:30,699
para después apuntar al siguiente

574
00:55:30,699 --> 00:55:33,400
si quieres

575
00:55:33,400 --> 00:55:34,619
pero si tú

576
00:55:34,619 --> 00:55:37,199
apuntas solo a las referencias

577
00:55:37,199 --> 00:55:38,780
si tú apuntas solo a la cabeza

578
00:55:38,780 --> 00:55:40,599
estás llegando al objeto entero

579
00:55:40,599 --> 00:55:54,420
si quieres aquí no lo estoy haciendo aquí como esto es un nodo esto es un nodo estoy

580
00:55:54,420 --> 00:55:57,659
solo cambiando la referencia como si estoy diciendo alumno ahora es de

581
00:55:57,659 --> 00:56:02,559
estoy cambiando que a en vez de apuntar al primer alumno apunta a otro alumno

582
00:56:04,079 --> 00:56:08,440
a un alumno distinto todo el alumno apuntaba antes todo el alumno apunta ahora pero son

583
00:56:08,440 --> 00:56:14,320
dos objetos distintos. Antes cabeza apuntaba al primer objeto nodo que representaba el primero

584
00:56:14,320 --> 00:56:18,340
de la lista, ahora apunta a otro objeto nodo que se representa el primero de la lista.

585
00:56:18,340 --> 00:56:24,880
Claro, entiende que en este caso n3 apunta acá. Es decir, que hace una...

586
00:56:24,880 --> 00:56:32,880
No, es que cabeza contiene n3 que apunta al primer elemento nodo, al primer objeto nodo de la lista.

587
00:56:32,880 --> 00:56:46,760
Entonces, con esto hemos hecho el add.

588
00:56:46,760 --> 00:56:51,059
Antes de poder hacer algo, tenemos que escribir este señor.

589
00:56:51,059 --> 00:56:52,059
No sabemos cómo escribirlo.

590
00:56:52,059 --> 00:57:00,070
Entonces, lo que vamos a hacer ahora es crear el show, ¿os acordáis que teníamos show?

591
00:57:00,070 --> 00:57:02,010
así, si tenemos a

592
00:57:02,010 --> 00:57:04,130
the show, podemos empezar a hacer

593
00:57:04,130 --> 00:57:06,050
pruebas, a añadir cosas

594
00:57:06,050 --> 00:57:08,150
a la lista y luego enseñarme si efectivamente lo he

595
00:57:08,150 --> 00:57:08,469
hecho bien.

596
00:57:10,650 --> 00:57:11,889
Entonces, ¿cómo

597
00:57:11,889 --> 00:57:12,710
hacemos show?

598
00:57:14,170 --> 00:57:15,630
Pues show debería

599
00:57:15,630 --> 00:57:17,329
recorrer mi lista

600
00:57:17,329 --> 00:57:19,989
y por cada elemento de

601
00:57:19,989 --> 00:57:21,489
nodo, por cada nodo, perdón,

602
00:57:22,090 --> 00:57:23,769
enseñarme lo que contiene.

603
00:57:27,219 --> 00:57:27,820
Entonces

604
00:57:27,820 --> 00:57:29,199
empiezo por cabeza

605
00:57:29,199 --> 00:57:31,599
y imprimo el contenido de cabeza.

606
00:57:32,019 --> 00:57:40,019
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?

607
00:57:40,019 --> 00:57:47,019
Hasta null. Entonces, nodo actual es igual a cabeza.

608
00:57:47,019 --> 00:58:01,170
Empiezo por cabeza. Dile actual no sea null.

609
00:58:01,170 --> 00:58:12,480
lo que hago es actual.contenido, lo tengo que guardar por algún lado,

610
00:58:13,659 --> 00:58:19,780
entonces hacemos un string, de verdad un string, string res es igual a nada.

611
00:58:20,719 --> 00:58:30,019
Entonces, mientras actual no sea nul, res es igual a res más,

612
00:58:30,019 --> 00:58:31,480
le pego detrás

613
00:58:31,480 --> 00:58:34,340
actual.contenido.tostring

614
00:58:34,340 --> 00:58:41,260
que será la representación

615
00:58:41,260 --> 00:58:42,860
en formato string del contenido

616
00:58:42,860 --> 00:58:44,820
todos los objetos la tienen

617
00:58:44,820 --> 00:58:46,139
porque tu string es de

618
00:58:46,139 --> 00:58:49,880
¿qué clase es tu string?

619
00:58:50,440 --> 00:58:52,539
object, entonces o tiene

620
00:58:52,539 --> 00:58:54,659
el de object o tiene una

621
00:58:54,659 --> 00:58:56,719
versión mejorada para

622
00:58:56,719 --> 00:58:58,260
ese objeto, pero lo tiene

623
00:58:58,260 --> 00:58:59,800
entonces si yo te digo

624
00:58:59,800 --> 00:59:02,920
vete al actual, al nodo actual

625
00:59:02,920 --> 00:59:05,099
pilla su contenido

626
00:59:05,099 --> 00:59:07,059
y escríbemelo como un string.

627
00:59:07,539 --> 00:59:09,380
Y pégamelo al resultado.

628
00:59:10,119 --> 00:59:11,300
A lo mejor lo separo por coma.

629
00:59:17,969 --> 00:59:18,110
¿Sí?

630
00:59:18,849 --> 00:59:21,110
Y después de haber hecho esto sobre el

631
00:59:21,110 --> 00:59:23,070
nodo actual, antes de

632
00:59:23,070 --> 00:59:24,489
volver aquí, ¿qué hago?

633
00:59:30,780 --> 00:59:31,699
Paso al siguiente.

634
00:59:34,269 --> 00:59:36,670
Que podría ser null, pero si es null

635
00:59:36,670 --> 00:59:38,489
no entrará aquí. Habrá llegado

636
00:59:38,489 --> 00:59:40,090
al final. Si no es null,

637
00:59:40,489 --> 00:59:42,429
me añade el contenido del siguiente

638
00:59:42,429 --> 00:59:43,190
y pasa al siguiente.

639
00:59:44,150 --> 00:59:46,409
Si su siguiente es null, pues

640
00:59:46,409 --> 00:59:52,349
habrá acabado. Si su siguiente no es null, pues pasará al siguiente. Y así, así, así. Al final,

641
00:59:52,349 --> 01:00:08,599
return es. Entonces, esta empezará aquí, dice actual. Esta actual apunta a donde apunta cabeza,

642
01:00:08,599 --> 01:00:16,119
pues a este de aquí. Escribe su contenido. Y luego, actual es igual al actual, o sea,

643
01:00:16,119 --> 01:00:21,440
este de aquí, punto siguiente. Por lo tanto, borro esto y lo apunto al siguiente.

644
01:00:21,440 --> 01:00:29,150
Ahora añado este de aquí, borro esto y apunto a su siguiente. Entonces voy aquí,

645
01:00:29,150 --> 01:00:35,190
escribo este de aquí, borro esto y voy a su siguiente, que es null. Por lo tanto

646
01:00:35,190 --> 01:00:42,920
salgo y devuelvo rest. Ahora vamos a ver si esto funciona.

647
01:00:42,920 --> 01:01:19,380
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.

648
01:01:19,380 --> 01:01:39,039
Y ahora puedo hacer le.add y puedo hacer siso le.show. Vamos a ver si funciona.

649
01:01:40,719 --> 01:01:48,559
Está escribiendo add, que es el único elemento. Me pone un coma adelante porque siempre he puesto

650
01:01:48,559 --> 01:01:58,380
esto en forma de arco. Lo puedo poner detrás. Por ahora no da igual. Ahora ¿qué hago? Añado

651
01:01:58,380 --> 01:02:12,679
uno nuevo. lee.add perro. ¿Dónde me lo tiene que ir a juntar? Al final. Hace que no lo

652
01:02:12,679 --> 01:02:32,219
Y lo voy a escribir. Y ahora puedo hacer, oye, mira, lee.addFirst, ok. Ahora me lo tiene que

653
01:02:32,219 --> 01:02:58,969
añadir primero. Si no lo escribo, no me lo escribo. Mi lista está funcionando. Fijaos que

654
01:02:58,969 --> 01:03:14,480
si yo pillo el otro main, todavía me falta busco, pero esto es igual, le da igual, porque

655
01:03:14,480 --> 01:03:20,360
yo lo estoy utilizando como lista, fijaos que aquí puedo usar addFirst porque esto

656
01:03:20,360 --> 01:03:29,750
es una lista enlazada, pero yo podría hacer esto, porque lista enlazada es una lista,

657
01:03:29,750 --> 01:03:45,079
Lo único es que ahora esto no lo puedo usar porque dentro del contrato de lista no está AdWords.

658
01:03:45,079 --> 01:03:50,059
Podría hacer un downcasting de ley para que sea una lista enlazada, entonces sí que me

659
01:03:50,059 --> 01:03:51,420
funcionaría.

660
01:03:51,420 --> 01:03:59,059
No me funcionaría si fuera una lista de Array, ¿sí?

661
01:03:59,059 --> 01:04:07,389
Dudas hasta aquí.

662
01:04:07,389 --> 01:04:23,630
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.

663
01:04:23,630 --> 01:04:39,369
Ahora vosotros vais a implementar size.