1
00:00:02,419 --> 00:00:05,219
Bueno, pues habéis hecho este método

2
00:00:05,219 --> 00:00:10,000
Ay, que listos sois, que todos sabéis

3
00:00:10,000 --> 00:00:17,859
Vale, a ver

4
00:00:17,859 --> 00:00:21,379
¿Cuántos habéis hecho este método?

5
00:00:22,239 --> 00:00:23,379
Levantad la manita

6
00:00:23,379 --> 00:00:25,739
¿Tres solo?

7
00:00:26,600 --> 00:00:27,079
¿Cuatro?

8
00:00:28,359 --> 00:00:29,579
Vale, ¿qué habéis hecho?

9
00:00:32,420 --> 00:00:40,710
vale, esa es la clave, ¿no?

10
00:00:40,710 --> 00:00:42,890
un contador, ya está, pues eso es lo que habréis

11
00:00:42,890 --> 00:00:43,170
hecho

12
00:00:43,170 --> 00:00:46,850
un contador

13
00:00:46,850 --> 00:00:48,770
porque aquí hay que contar y cuando hay que contar

14
00:00:48,770 --> 00:00:50,329
ponemos un contador igual a cero

15
00:00:50,329 --> 00:00:52,710
y ahora nuestra variable

16
00:00:52,710 --> 00:00:53,789
aux, esto de aquí

17
00:00:53,789 --> 00:01:05,609
y ahora, la sentencia clave

18
00:01:05,609 --> 00:01:06,730
está clara, es esta

19
00:01:06,730 --> 00:01:09,549
aux igual a aux punto

20
00:01:09,549 --> 00:01:12,030
siguiente, cada vez

21
00:01:12,030 --> 00:01:13,909
Cada vez

22
00:01:13,909 --> 00:01:15,810
Que avancemos

23
00:01:15,810 --> 00:01:18,370
Cada vez que avancemos

24
00:01:18,370 --> 00:01:19,849
Incrementamos un contador

25
00:01:19,849 --> 00:01:23,010
Cada vez que avancemos

26
00:01:23,010 --> 00:01:23,689
Y ahora

27
00:01:23,689 --> 00:01:25,569
¿Cuántas veces tenemos que avanzar?

28
00:01:25,829 --> 00:01:28,650
Antes la avanzábamos tantas veces como me decía posición

29
00:01:28,650 --> 00:01:30,450
Ahora la tengo que avanzar

30
00:01:30,450 --> 00:01:31,189
Hasta el final

31
00:01:31,189 --> 00:01:33,849
Entonces ahora la tengo que avanzar

32
00:01:33,849 --> 00:01:35,269
Mientras aux

33
00:01:35,269 --> 00:01:37,849
Sea distinta de null

34
00:01:37,849 --> 00:01:40,329
Mientras no haya llegado

35
00:01:40,329 --> 00:01:41,689
Al final, avánzamela

36
00:01:41,689 --> 00:01:45,890
¿Vale? Mientras no haya llegado al final

37
00:01:45,890 --> 00:01:46,489
Avanzala

38
00:01:46,489 --> 00:01:48,430
Cuando hayas llegado al final

39
00:01:48,430 --> 00:01:50,010
Ya no hay más que avanzar

40
00:01:50,010 --> 00:01:51,790
Ya me has contado todas las posiciones

41
00:01:51,790 --> 00:01:54,450
Pues la devuelves

42
00:01:54,450 --> 00:01:59,450
¿Vale?

43
00:02:03,620 --> 00:02:04,920
Entonces ahora ya sí

44
00:02:04,920 --> 00:02:07,260
Ahora ya sí

45
00:02:07,260 --> 00:02:08,800
Podríamos recorrerlo

46
00:02:08,800 --> 00:02:10,319
Con el for

47
00:02:10,319 --> 00:02:11,780
Que es la idea

48
00:02:11,780 --> 00:02:15,159
¿Vale? Recorrerlo con el for

49
00:02:15,159 --> 00:02:17,719
Esto ya nos funcionaría

50
00:02:17,719 --> 00:02:23,539
Bueno pues

51
00:02:23,539 --> 00:02:25,699
tenemos una estructura muy

52
00:02:25,699 --> 00:02:27,740
cómoda, que uno la puede

53
00:02:27,740 --> 00:02:30,099
distribuir, la mete en un jar y la distribuye

54
00:02:30,099 --> 00:02:31,659
y ahora ya cualquiera

55
00:02:31,659 --> 00:02:33,659
la puede usar para meter cadenas de forma

56
00:02:33,659 --> 00:02:36,000
cómoda y consultar, ni array

57
00:02:36,000 --> 00:02:37,860
que se rompe y hay que hacerlo

58
00:02:37,860 --> 00:02:40,000
ni nada, me hago mi array linked list

59
00:02:40,000 --> 00:02:41,919
inserto según me vaya

60
00:02:41,919 --> 00:02:44,039
haciendo falta y recorro

61
00:02:44,039 --> 00:02:45,800
¿vale? a ver

62
00:02:45,800 --> 00:02:47,680
le faltan funcionalidades

63
00:02:47,680 --> 00:02:49,680
vamos a dejar planteada la del remove

64
00:02:49,680 --> 00:02:51,500
para que la hagáis

65
00:02:51,500 --> 00:02:53,439
la del remove

66
00:02:53,439 --> 00:03:11,680
Porque claro, yo he hecho una estructura en la cual puedo insertar en la lista, solo al principio, eso sí, podríais hacer la variante e insertar al final, solo al principio, puedo recuperar por posición y ya está, no puedo hacer más que eso, insertar y recuperar lo que hay en una posición.

67
00:03:11,680 --> 00:03:29,240
Pero bueno, me gustaría también quitar cosas. Lo que hacemos con los contenedores de cosas es meter cosas, consultar lo que hay por posición o por clave, si es un diccionario, pero si es otra historia, y sacar alguna.

68
00:03:29,240 --> 00:03:30,400
vale

69
00:03:30,400 --> 00:03:32,439
bueno pues

70
00:03:32,439 --> 00:03:34,659
como haríamos aquí un método remove

71
00:03:34,659 --> 00:03:36,180
pues tendríamos que

72
00:03:36,180 --> 00:03:39,280
incorporar algo parecido

73
00:03:39,280 --> 00:03:40,280
a esto por ejemplo

74
00:03:40,280 --> 00:03:42,620
remove

75
00:03:42,620 --> 00:03:44,500
int por posición

76
00:03:44,500 --> 00:03:52,840
y ahora

77
00:03:52,840 --> 00:03:54,300
os

78
00:03:54,300 --> 00:03:56,979
vemos aquí la pista en la pizarra

79
00:03:56,979 --> 00:03:58,919
para que lo hagáis este ya vosotros

80
00:03:58,919 --> 00:04:09,150
vale

81
00:04:09,150 --> 00:04:10,229
aquí

82
00:04:10,229 --> 00:04:21,310
si lo utilizamos esta lista

83
00:04:21,310 --> 00:04:24,810
¿cuál es la operación que tenemos que hacer

84
00:04:24,810 --> 00:04:27,529
para eliminar este de aquí, por ejemplo

85
00:04:27,529 --> 00:04:30,149
para eliminar a este pobre de aquí

86
00:04:30,149 --> 00:04:33,449
el de posición 1 en este caso

87
00:04:33,449 --> 00:04:36,689
pues la única sentencia que hay que hacer

88
00:04:36,689 --> 00:04:39,449
esto es más fácil que el array, que ya hemos visto que había que hacer otro array

89
00:04:39,449 --> 00:04:42,610
con una menos, copiar, pegar, aquí es tan fácil como

90
00:04:42,610 --> 00:04:44,230
a esta de aquí

91
00:04:44,230 --> 00:04:46,129
asignarle

92
00:04:46,129 --> 00:04:48,230
su siguiente

93
00:04:48,230 --> 00:04:50,350
y punto pelota

94
00:04:50,350 --> 00:04:52,550
¿vale? a esta

95
00:04:52,550 --> 00:04:54,329
asignarle su siguiente

96
00:04:54,329 --> 00:04:56,670
entonces he puenteado a este

97
00:04:56,670 --> 00:04:59,209
este se ha quedado sin referencia

98
00:04:59,209 --> 00:05:00,430
ha perdido la que tenía

99
00:05:00,430 --> 00:05:02,589
se ha quedado sin referencia

100
00:05:02,589 --> 00:05:04,430
y el recolector de basura en algún momento

101
00:05:04,430 --> 00:05:05,910
lo tirará a la basura

102
00:05:05,910 --> 00:05:08,730
esta es la que hay que hacer

103
00:05:08,730 --> 00:05:10,769
entonces si yo tengo

104
00:05:10,769 --> 00:05:12,569
un puntero aux, si yo tuviera un puntero aux

105
00:05:12,569 --> 00:05:13,689
que apuntara a este

106
00:05:13,689 --> 00:05:33,069
Pues el borrado sería precisamente hacer aux.siguiente, aux.siguiente, igual aux.siguiente.siguiente.

107
00:05:35,779 --> 00:05:38,600
Es decir, esta sería la sentencia de borrado.

108
00:05:40,060 --> 00:05:45,019
Siempre y cuando aux apunte al anterior al que yo quiero borrar.

109
00:05:45,019 --> 00:05:47,839
si quiero borrar este

110
00:05:47,839 --> 00:05:50,300
aux tiene que apuntar

111
00:05:50,300 --> 00:05:51,579
al anterior al que quiero borrar

112
00:05:51,579 --> 00:05:54,019
una vez que consiga

113
00:05:54,019 --> 00:05:56,199
que aux apunte al anterior

114
00:05:56,199 --> 00:05:57,319
al que quiero borrar

115
00:05:57,319 --> 00:06:00,040
hago esta sentencia, aux.siguiente

116
00:06:00,040 --> 00:06:02,180
que es este, por favor apúntame

117
00:06:02,180 --> 00:06:03,740
aux.siguiente, el punto siguiente

118
00:06:03,740 --> 00:06:04,319
que es este

119
00:06:04,319 --> 00:06:07,279
entonces lo que tengo que hacer en el remove es

120
00:06:07,279 --> 00:06:10,000
un bucle, primero hacerme mi auxiliar

121
00:06:10,000 --> 00:06:10,660
por supuesto

122
00:06:10,660 --> 00:06:13,839
un bucle que va avanzando aux

123
00:06:13,839 --> 00:06:15,379
hasta que llegue

124
00:06:15,379 --> 00:06:17,439
a una posición menos

125
00:06:17,439 --> 00:06:18,439
que el que quiero borrar.

126
00:06:19,459 --> 00:06:21,139
Un bucle, un contador

127
00:06:21,139 --> 00:06:22,120
que en lugar de posición

128
00:06:22,120 --> 00:06:23,759
se ejecute posición menos una vez.

129
00:06:25,560 --> 00:06:27,139
Y una vez que ya ha llegado

130
00:06:27,139 --> 00:06:29,139
me hace esta sentencia con aus

131
00:06:29,139 --> 00:06:30,240
y se acabó.

132
00:06:31,120 --> 00:06:32,000
Y ese sería el remove.

133
00:06:33,220 --> 00:06:34,379
Si hacemos el remove

134
00:06:34,379 --> 00:06:35,540
y luego volvéis a recorrer

135
00:06:35,540 --> 00:06:37,480
con el get y el for

136
00:06:37,480 --> 00:06:38,519
pues veréis que efectivamente

137
00:06:38,519 --> 00:06:39,300
se ha eliminado.

138
00:06:40,560 --> 00:06:40,759
¿Vale?

139
00:06:41,519 --> 00:06:43,620
Entonces, eliminar de una lista enlazada

140
00:06:43,620 --> 00:06:44,819
es

141
00:06:44,819 --> 00:06:47,180
esta línea

142
00:06:47,180 --> 00:06:49,879
eliminar un array es mucho más

143
00:06:49,879 --> 00:06:52,720
entonces computacionalmente

144
00:06:52,720 --> 00:06:54,439
es más costoso, son mucho más ciclos

145
00:06:54,439 --> 00:06:56,339
de memoria, trabajar con

146
00:06:56,339 --> 00:06:58,060
un array para eliminar e insertar que

147
00:06:58,060 --> 00:06:59,399
trabajar con una lista enlazada

148
00:06:59,399 --> 00:07:14,240
¿vale? y si quisierais

149
00:07:14,240 --> 00:07:16,120
hacer en la lista, va a haber una lista súper

150
00:07:16,120 --> 00:07:18,160
completa, añadir al

151
00:07:18,160 --> 00:07:20,019
final, el remove está claro ¿no?

152
00:07:20,339 --> 00:07:22,139
un aux, aux que

153
00:07:22,139 --> 00:07:24,060
avance hasta pararse al

154
00:07:24,060 --> 00:07:25,920
anterior a la posición que quiero

155
00:07:25,920 --> 00:07:28,220
vamos a un for que lo va avanzando

156
00:07:28,220 --> 00:07:30,300
y luego esta sentencia, se acabó

157
00:07:30,300 --> 00:07:31,439
ese sería el remove

158
00:07:31,439 --> 00:07:33,620
que queréis hacer el add

159
00:07:33,620 --> 00:07:36,399
sin más, añadir al final, no añadir al principio

160
00:07:36,399 --> 00:07:37,339
que parece raro, ¿no?

161
00:07:37,600 --> 00:07:40,160
normalmente cuando uno añade a una colección

162
00:07:40,160 --> 00:07:41,879
a una lista, añade al final

163
00:07:41,879 --> 00:07:44,120
pues si quisierais

164
00:07:44,120 --> 00:07:46,199
hacer el método, que lo vamos a dejar ahí

165
00:07:46,199 --> 00:07:48,279
escrito, para que lo hagáis

166
00:07:48,279 --> 00:07:49,319
de añadir al final

167
00:07:49,319 --> 00:07:54,050
¿qué habría que hacer en el añadir al final?

168
00:07:54,050 --> 00:07:58,610
pues tendríamos que

169
00:07:58,610 --> 00:08:01,730
crear el nuevo nodo, sí o sí, por supuesto

170
00:08:01,730 --> 00:08:03,569
crear el nuevo nodo, con el dato

171
00:08:03,569 --> 00:08:04,490
que me han dado nuevo

172
00:08:04,490 --> 00:08:07,550
inicialmente, siguiente

173
00:08:07,550 --> 00:08:09,470
anul, ahora este

174
00:08:09,470 --> 00:08:11,550
nuevo nodo, lo tengo que hacer

175
00:08:11,550 --> 00:08:12,269
colgar de aquí

176
00:08:12,269 --> 00:08:15,029
no insertar aquí

177
00:08:15,029 --> 00:08:17,410
bueno, pues no pasa nada, me hago yo

178
00:08:17,410 --> 00:08:19,470
un aux, que avance hasta el

179
00:08:19,470 --> 00:08:21,529
final, hasta

180
00:08:21,529 --> 00:08:23,509
este, y cuando ya lo tengo

181
00:08:23,509 --> 00:08:25,370
me hago, aux

182
00:08:25,370 --> 00:08:27,810
punto siguiente igual al nodo nuevo

183
00:08:27,810 --> 00:08:29,670
al nodo nuevo que acabo de hacer

184
00:08:29,670 --> 00:08:31,269
con lo cual este siguiente

185
00:08:31,269 --> 00:08:33,169
empezará a apuntar al nodo nuevo

186
00:08:33,169 --> 00:08:35,129
¿vale?

187
00:08:36,730 --> 00:08:37,710
entonces repito

188
00:08:37,710 --> 00:08:39,809
¿qué habremos tenido que hacer para añadir al final?

189
00:08:40,690 --> 00:08:41,610
una variable

190
00:08:41,610 --> 00:08:43,490
aux que va avanzando con la

191
00:08:43,490 --> 00:08:45,850
sentencia de avance, aux igual aux punto siguiente

192
00:08:45,850 --> 00:08:47,590
va avanzando hasta que

193
00:08:47,590 --> 00:08:49,129
se quede apuntando al último

194
00:08:49,129 --> 00:08:51,769
no hasta que se quede apuntando

195
00:08:51,769 --> 00:08:52,950
al último, sino al último

196
00:08:52,950 --> 00:08:53,450
al último

197
00:08:53,450 --> 00:08:56,710
una vez que está apuntando al último

198
00:08:56,710 --> 00:08:58,909
aux.siguiente

199
00:08:58,909 --> 00:09:00,950
igual al nodo nuevo, y ya está

200
00:09:00,950 --> 00:09:03,110
con lo cual aux.siguiente

201
00:09:03,110 --> 00:09:04,710
se quedará apuntando al nodo nuevo

202
00:09:04,710 --> 00:09:06,990
con eso podría hacer

203
00:09:06,990 --> 00:09:07,809
añadir al final

204
00:09:07,809 --> 00:09:12,639
¿y el parámetro que pasa por la posición o el dato?

205
00:09:14,379 --> 00:09:15,519
el parámetro o el dato

206
00:09:15,519 --> 00:09:18,159
el dato, el dato, ¿vale?

207
00:09:18,240 --> 00:09:20,879
entonces, la cabecera del este

208
00:09:20,879 --> 00:09:21,419
sería

209
00:09:21,419 --> 00:09:37,480
entonces este método

210
00:09:37,480 --> 00:09:38,419
pues se queda ahí

211
00:09:38,419 --> 00:09:40,820
para que lo hagáis

212
00:09:40,820 --> 00:09:43,480
¿cuáles dos más

213
00:09:43,480 --> 00:09:44,919
hemos mencionado?

214
00:09:45,799 --> 00:09:47,659
bueno, hemos mencionado uno más, el de añadir

215
00:09:47,659 --> 00:09:51,850
al final, pues public

216
00:09:51,850 --> 00:09:53,710
void add

217
00:09:53,710 --> 00:09:55,330
add sin más

218
00:09:55,330 --> 00:09:57,269
un dato

219
00:09:57,269 --> 00:10:04,519
add last, añádeme

220
00:10:04,519 --> 00:10:05,559
add first, perdón

221
00:10:05,559 --> 00:10:08,460
este sería el añadir por defecto cuando tú ya

222
00:10:08,460 --> 00:10:09,639
es una lista, añades al final.

223
00:10:10,259 --> 00:10:11,679
Hemos hecho añade al principio.

224
00:10:12,440 --> 00:10:13,960
Ahora queremos añadir al final.

225
00:10:16,940 --> 00:10:17,620
Pues venga.

226
00:10:20,080 --> 00:10:21,299
Una cosa es añadir al principio.

227
00:10:21,820 --> 00:10:23,899
A ver, en una lista las cosas tienen orden.

228
00:10:24,299 --> 00:10:25,700
Luego no es igual estar aquí que estar aquí.

229
00:10:26,120 --> 00:10:26,879
Ya tienen posición.

230
00:10:27,220 --> 00:10:28,639
En esta lista no da igual el orden, ¿no?

231
00:10:29,360 --> 00:10:30,960
Yo he dicho que da igual el orden.

232
00:10:31,340 --> 00:10:33,200
Yo he dicho que si me hago mi método addFirst,

233
00:10:33,639 --> 00:10:35,399
tal y como lo he hecho, que es una versión sencilla,

234
00:10:35,559 --> 00:10:36,600
me lo mete al principio.

235
00:10:36,600 --> 00:10:41,340
entonces tú puedes

236
00:10:41,340 --> 00:10:43,100
querer añadir en la lista

237
00:10:43,100 --> 00:10:45,259
puedes querer colocar al final o puedes

238
00:10:45,259 --> 00:10:47,159
querer insertar por el principio, te da

239
00:10:47,159 --> 00:10:49,120
las dos opciones, tú colocas

240
00:10:49,120 --> 00:10:52,480
como quieras, venga pues ahora

241
00:10:52,480 --> 00:10:53,899
que tenéis el cerebro caliente

242
00:10:53,899 --> 00:10:56,419
y el corazón frío