1
00:00:00,180 --> 00:00:03,040
cuando queramos ya una lista concreta

2
00:00:03,040 --> 00:00:04,900
para guardar datos, instanciaremos

3
00:00:04,900 --> 00:00:07,280
un objeto de estos, una lista enlazada

4
00:00:07,280 --> 00:00:08,500
lo que instanciaremos

5
00:00:08,500 --> 00:00:11,300
igual que cuando queríamos guardar datos en un array

6
00:00:11,300 --> 00:00:13,179
instanciamos un array

7
00:00:13,179 --> 00:00:15,339
pues aquí instanciaremos

8
00:00:15,339 --> 00:00:17,260
un objeto de estos para guardar datos

9
00:00:17,260 --> 00:00:19,219
vale, este objeto ya hemos

10
00:00:19,219 --> 00:00:21,359
dicho antes, ¿por qué se va a caracterizar

11
00:00:21,359 --> 00:00:23,239
este objeto? se caracteriza

12
00:00:23,239 --> 00:00:25,160
única y exclusivamente por la dirección

13
00:00:25,160 --> 00:00:27,140
del primer elemento, nada más, por la dirección del

14
00:00:27,140 --> 00:00:27,440
primero

15
00:00:27,440 --> 00:00:31,539
esto es una lista enlazada, se caracteriza por la dirección

16
00:00:31,539 --> 00:00:34,500
del primero, vale, pues la dirección del primero

17
00:00:34,500 --> 00:00:39,500
¿de qué tipo es? pues de esta clase

18
00:00:39,500 --> 00:00:41,820
que tendremos que programar

19
00:00:41,820 --> 00:00:45,340
vale, entonces en principio esto es una propiedad

20
00:00:45,340 --> 00:00:46,579
interna

21
00:00:46,579 --> 00:00:49,960
privada del objeto lista

22
00:00:49,960 --> 00:00:53,420
una propiedad privada que nadie tiene por qué conocer

23
00:00:53,420 --> 00:00:56,899
la dirección inicial de la lista nadie tiene por qué conocerla

24
00:00:56,899 --> 00:01:00,530
vale

25
00:01:00,530 --> 00:01:02,390
pues nada

26
00:01:02,390 --> 00:01:04,769
lo que pasa es que claro

27
00:01:04,769 --> 00:01:06,829
tendremos que crear la clase

28
00:01:06,829 --> 00:01:08,950
nodo para que cuanto antes nos quite

29
00:01:08,950 --> 00:01:09,969
este error de compilación

30
00:01:09,969 --> 00:01:17,040
bueno pues entonces esta lista enlazada

31
00:01:17,040 --> 00:01:18,620
tenemos que decidir

32
00:01:18,620 --> 00:01:21,519
que tipo de datos va a guardar

33
00:01:21,519 --> 00:01:23,400
va a guardar números, va a guardar

34
00:01:23,400 --> 00:01:24,560
cadenas, que va a guardar

35
00:01:24,560 --> 00:01:27,120
bueno vamos a hacer un ejemplo de lista enlazada

36
00:01:27,120 --> 00:01:29,019
para guardar cadenas

37
00:01:29,019 --> 00:01:31,140
que es el que hemos dicho en la pizarra y ya está

38
00:01:31,140 --> 00:01:33,480
luego tendremos que ver como generalizarlo

39
00:01:33,480 --> 00:01:35,400
claro, pero para guardar cadenas hay que elegir

40
00:01:35,400 --> 00:01:36,840
qué tipo de dato quieres que guarde

41
00:01:36,840 --> 00:01:39,299
pues venga, cadenas, igual que cuando

42
00:01:39,299 --> 00:01:41,359
instanciamos un array, elegimos

43
00:01:41,359 --> 00:01:46,280
qué tipo de dato queremos que guarde

44
00:01:46,280 --> 00:01:47,319
vale, pues la clase

45
00:01:47,319 --> 00:01:50,019
esta será la clase a la que pertenecen

46
00:01:50,019 --> 00:01:51,379
cada uno de los objetos

47
00:01:51,379 --> 00:01:53,420
que están dados de la mano en mi lista

48
00:01:53,420 --> 00:01:56,159
cada uno de ellos, y ya hemos dicho

49
00:01:56,159 --> 00:01:57,859
que tendrán dos campos

50
00:01:57,859 --> 00:01:59,280
el dato en sí

51
00:01:59,280 --> 00:02:01,620
y la dirección del siguiente

52
00:02:01,620 --> 00:02:04,019
que la tiene que llevar ahí

53
00:02:04,019 --> 00:02:06,079
acoplada de la mano la dirección del siguiente

54
00:02:06,079 --> 00:02:09,979
¿Vale?

55
00:02:12,120 --> 00:02:12,560
Entonces

56
00:02:12,560 --> 00:02:15,400
Para que no se complique mucho el código

57
00:02:15,400 --> 00:02:17,080
Como las dos van juntitas

58
00:02:17,080 --> 00:02:18,020
En el mismo paquete

59
00:02:18,020 --> 00:02:20,979
Y se van a estar usando la una a la otra

60
00:02:20,979 --> 00:02:23,460
Pues no voy a poner privado

61
00:02:23,460 --> 00:02:25,300
Para que lista enlazada

62
00:02:25,300 --> 00:02:27,439
Pueda usar los atributos

63
00:02:27,439 --> 00:02:28,740
De nodo sin get y set

64
00:02:28,740 --> 00:02:31,280
¿Vale? Los dos como en pack hacen una estructura

65
00:02:31,280 --> 00:02:32,960
Esto no es que sea una entidad

66
00:02:32,960 --> 00:02:34,400
No estoy haciendo yo una aplicación

67
00:02:34,400 --> 00:02:36,500
Entonces así más común

68
00:02:36,500 --> 00:02:40,060
lo que sí que vamos a hacer va a ser un constructor con parámetros

69
00:02:40,060 --> 00:02:43,199
que eso sí que siempre es muy cómodo para instanciar

70
00:02:43,199 --> 00:02:44,620
un nodo, vale

71
00:02:44,620 --> 00:03:03,120
entonces, punto dato

72
00:03:03,120 --> 00:03:05,819
igual a dato

73
00:03:05,819 --> 00:03:11,050
punto siguiente, igual a

74
00:03:11,050 --> 00:03:18,800
vale, tiene el constructor y repito, no le pongo get y set

75
00:03:18,800 --> 00:03:22,080
porque no le he puesto el privado para que lista enlazada pueda acceder

76
00:03:22,080 --> 00:03:24,680
directamente y puedan trabajar los dos en pack

77
00:03:24,680 --> 00:03:25,699
más cómodamente

78
00:03:25,699 --> 00:03:27,699
bueno, pues el nodo es esto

79
00:03:27,699 --> 00:03:30,479
la clase nodo es esta, la clase nodo es la que

80
00:03:30,479 --> 00:03:32,680
pertenece a cada uno de los nodos que tienen

81
00:03:32,680 --> 00:03:34,680
sus dos partes, dato y siguiente

82
00:03:34,680 --> 00:03:36,139
y ya está, con su constructor

83
00:03:36,139 --> 00:03:38,599
cuando hago un constructor con parámetros

84
00:03:38,599 --> 00:03:40,259
inhabilito

85
00:03:40,259 --> 00:03:41,900
el vacío sin parámetros

86
00:03:41,900 --> 00:03:44,400
entonces eso puede hacer

87
00:03:44,400 --> 00:03:48,280
limita un poco la funcionalidad

88
00:03:48,280 --> 00:03:50,340
porque si yo quiero usar alguna vez el sin parámetros

89
00:03:50,340 --> 00:03:52,360
si he creado

90
00:03:52,360 --> 00:03:53,919
este, ya sabéis que este entonces

91
00:03:53,919 --> 00:03:56,360
o lo pongo específicamente o ya no existe

92
00:03:56,360 --> 00:03:58,139
bueno, lo ponemos específicamente

93
00:03:58,139 --> 00:03:59,639
para poder usarlo si es que queremos

94
00:03:59,639 --> 00:04:00,620
es de lista enlazada

95
00:04:00,620 --> 00:04:03,199
vale, y ahora

96
00:04:03,199 --> 00:04:05,900
cuando nosotros tengamos un main

97
00:04:05,900 --> 00:04:08,000
a ver, yo voy a hacer

98
00:04:08,000 --> 00:04:09,719
un paquete aparte con un main para ver

99
00:04:09,719 --> 00:04:11,479
qué es lo que esperamos de estos objetos

100
00:04:11,479 --> 00:04:12,460
qué es lo que esperamos

101
00:04:12,460 --> 00:04:14,719
esperamos que guarden datos, claro

102
00:04:14,719 --> 00:04:18,160
entonces me voy a hacer yo el paquete main

103
00:04:18,160 --> 00:04:25,339
con una clase

104
00:04:25,339 --> 00:04:27,120
main

105
00:04:27,120 --> 00:04:34,350
vale

106
00:04:34,350 --> 00:04:37,509
pues para que hemos hecho estas dos clases

107
00:04:37,509 --> 00:04:38,790
que es lo que esperamos de ellas

108
00:04:38,790 --> 00:04:40,970
pues esperamos instanciar

109
00:04:40,970 --> 00:04:42,709
un objeto lista enlazada

110
00:04:42,709 --> 00:04:45,149
esperamos

111
00:04:45,149 --> 00:04:46,730
instanciarlo

112
00:04:46,730 --> 00:04:57,670
lo que queremos es simular este comportamiento

113
00:04:58,209 --> 00:05:00,769
que yo me hago

114
00:05:00,769 --> 00:05:02,730
mi objeto lista enlazada

115
00:05:02,730 --> 00:05:04,670
como si me hiciera una array

116
00:05:04,670 --> 00:05:12,709
lista, ah es que he puesto enlazado

117
00:05:12,709 --> 00:05:14,290
vale, enlazada

118
00:05:14,290 --> 00:05:17,240
ahí

119
00:05:17,240 --> 00:05:19,279
yo lo que espero

120
00:05:19,279 --> 00:05:20,740
de esto que estoy haciendo es

121
00:05:20,740 --> 00:05:22,899
crearme un objeto de estos

122
00:05:22,899 --> 00:05:24,100
como me creaba un array

123
00:05:24,100 --> 00:05:26,740
y ahora con este objeto

124
00:05:26,740 --> 00:05:29,360
lo que a mi me gustaría es poder usarlo para

125
00:05:29,360 --> 00:05:31,279
meter string

126
00:05:31,279 --> 00:05:32,819
dentro de ellos, por ejemplo así

127
00:05:32,819 --> 00:05:36,589
esto, me gustaría poder hacer esto

128
00:05:36,589 --> 00:05:38,610
que ahora quiero meter otra cadena

129
00:05:38,610 --> 00:05:39,529
más en mi lista

130
00:05:39,529 --> 00:05:42,610
pues mira, me gustaría poder

131
00:05:42,610 --> 00:05:44,470
hacer esto y ahora ponerle otra cadena

132
00:05:44,470 --> 00:05:48,250
que ahora quiero recuperar

133
00:05:48,250 --> 00:05:50,949
elemento que está en la posición 0

134
00:05:50,949 --> 00:05:52,470
de esta lista, por ejemplo

135
00:05:52,470 --> 00:05:55,069
pues me encantaría poder hacer esto

136
00:05:55,069 --> 00:05:57,889
lista.get y pasarle yo la posición

137
00:05:57,889 --> 00:06:01,009
por ejemplo, un método get

138
00:06:01,009 --> 00:06:03,589
que me recupera el elemento de posición 0

139
00:06:03,589 --> 00:06:06,610
también me encantaría poder hacer esto

140
00:06:06,610 --> 00:06:07,810
si yo tengo la lista

141
00:06:07,810 --> 00:06:09,430
poder borrar

142
00:06:09,430 --> 00:06:11,930
el elemento que está en la posición 1

143
00:06:11,930 --> 00:06:14,129
por ejemplo, me encantaría poder hacer esto

144
00:06:14,129 --> 00:06:16,129
decirle, oye, bórrame el que está en la posición 1

145
00:06:16,129 --> 00:06:17,769
estaría estupendo

146
00:06:17,769 --> 00:06:21,529
esto es lo que nosotros pretendemos

147
00:06:21,529 --> 00:06:22,769
cuando hacemos esta clase

148
00:06:22,769 --> 00:06:25,230
pretendemos tener ahí un objeto

149
00:06:25,230 --> 00:06:27,529
que yo pueda usar para guardar

150
00:06:27,529 --> 00:06:29,790
cosas en él, para recuperarlas

151
00:06:29,790 --> 00:06:30,389
por posición

152
00:06:30,389 --> 00:06:32,829
para eliminarlas por posición

153
00:06:32,829 --> 00:06:35,569
y muchas otras que se me puedan ocurrir

154
00:06:35,569 --> 00:06:37,490
aquí he puesto tres básicas

155
00:06:37,490 --> 00:06:40,170
insertar dato

156
00:06:40,170 --> 00:06:42,149
recuperar por posición

157
00:06:42,149 --> 00:06:43,089
borrar por posición

158
00:06:43,089 --> 00:06:46,069
y si yo tuviera esto, esto es mucho más cómodo

159
00:06:46,069 --> 00:06:46,509
que un array

160
00:06:46,509 --> 00:06:49,350
esto sería mucho más cómodo que un array

161
00:06:49,350 --> 00:06:51,430
si quisiéramos

162
00:06:51,430 --> 00:06:53,410
estas cadenas en un array y quisiéramos

163
00:06:53,410 --> 00:06:55,829
recuperar del array y eliminar

164
00:06:55,829 --> 00:06:57,430
pues meter en el array

165
00:06:57,430 --> 00:06:59,589
ya hemos visto que no es tan fácil, meter en el array

166
00:06:59,589 --> 00:07:00,870
cada vez que hemos tenido que meter

167
00:07:00,870 --> 00:07:03,490
hemos tenido que hacer una adicional, copiar

168
00:07:03,490 --> 00:07:05,350
pegar, etcétera, si yo pudiera

169
00:07:05,350 --> 00:07:06,550
hacer esto, mira que fácil

170
00:07:06,550 --> 00:07:09,490
añado y ya está y que la lista vaya creciendo

171
00:07:09,490 --> 00:07:11,370
en el caso de

172
00:07:11,370 --> 00:07:13,930
recuperar por posición, el array eso sí que era sencillo

173
00:07:13,930 --> 00:07:15,470
el array poníamos corchetes 0

174
00:07:15,470 --> 00:07:17,670
y se acabó, eso sí, ahí no vamos a ganar nada

175
00:07:17,670 --> 00:07:19,709
eliminar

176
00:07:19,709 --> 00:07:21,410
pues mira que estupendo, si yo tuviera

177
00:07:21,410 --> 00:07:23,810
un método que le doy la posición y me lo quita de la lista

178
00:07:23,810 --> 00:07:24,709
genial

179
00:07:24,709 --> 00:07:27,189
en el array teníamos que hacer un montón de cosas

180
00:07:27,189 --> 00:07:29,449
para eliminar, pues esto es lo que queremos

181
00:07:29,449 --> 00:07:31,250
simular, un objeto

182
00:07:31,250 --> 00:07:33,370
de esta clase que yo me estoy haciendo

183
00:07:33,370 --> 00:07:35,290
al que puedo meter datos

184
00:07:35,290 --> 00:07:37,629
puedo consultarlos

185
00:07:37,629 --> 00:07:39,670
por posición, recuperarlos, borrarlos

186
00:07:39,670 --> 00:07:41,110
lo que quiera, eso es lo que queremos simular

187
00:07:41,110 --> 00:07:43,509
bueno, pues que es lo que tendremos que hacer

188
00:07:43,509 --> 00:07:45,550
entonces? Pues meter estos

189
00:07:45,550 --> 00:07:47,730
métodos, add, get, remove

190
00:07:47,730 --> 00:07:48,990
estos métodos, meterlos aquí

191
00:07:48,990 --> 00:07:51,050
programarlos yo

192
00:07:51,050 --> 00:07:52,470
programarlos y ya está

193
00:07:52,470 --> 00:07:54,850
la estructura ya la tenemos

194
00:07:54,850 --> 00:07:57,389
cada objeto de la lista va a tener

195
00:07:57,389 --> 00:07:58,769
estos campos

196
00:07:58,769 --> 00:08:01,490
y la lista se caracteriza por

197
00:08:01,490 --> 00:08:03,430
su inicio y por nada más, no le hace

198
00:08:03,430 --> 00:08:05,509
falta nada más para caracterizarse su inicio

199
00:08:05,509 --> 00:08:07,069
¿ahora qué nos falta?

200
00:08:07,589 --> 00:08:09,569
pues hacer los métodos, vamos a hacer los métodos

201
00:08:09,569 --> 00:08:11,230
que me han dicho, pues venga

202
00:08:11,230 --> 00:08:13,449
¿cuál me gustaría hacer? el de añadir

203
00:08:13,449 --> 00:08:17,439
pues venga, vamos a hacer un método de añadir

204
00:08:17,439 --> 00:08:20,410
aquí

205
00:08:20,410 --> 00:08:22,670
si yo lo quiero usar desde fuera

206
00:08:22,670 --> 00:08:25,029
de la clase

207
00:08:25,029 --> 00:08:26,750
que querré, porque esta es una

208
00:08:26,750 --> 00:08:28,649
estructura que yo estoy haciendo para usar luego

209
00:08:28,649 --> 00:08:29,990
para guardar datos de donde quiera

210
00:08:29,990 --> 00:08:32,070
pues hombre, este método debería ser público

211
00:08:32,070 --> 00:08:34,750
vale, y este

212
00:08:34,750 --> 00:08:36,169
método de añadir

213
00:08:36,169 --> 00:08:37,970
¿qué le tengo que pasar yo?

214
00:08:38,850 --> 00:08:40,309
pues un dato del tipo

215
00:08:40,309 --> 00:08:42,769
de los que tú vas a guardar en tu lista

216
00:08:42,769 --> 00:08:44,929
pues en nuestro caso, como estamos trabajando

217
00:08:44,929 --> 00:08:45,669
con string

218
00:08:45,669 --> 00:08:49,509
pues este es el método que queremos programar

219
00:08:49,509 --> 00:08:52,820
vale

220
00:08:52,820 --> 00:08:54,779
pues entonces

221
00:08:54,779 --> 00:08:56,500
ahí que tenemos que hacer

222
00:08:56,500 --> 00:08:58,919
pues lo que tenemos que hacer aquí

223
00:08:58,919 --> 00:09:00,320
es

224
00:09:00,320 --> 00:09:07,690
tenemos nuestra lista

225
00:09:07,690 --> 00:09:10,649
en principio nuestra lista es esto

226
00:09:10,649 --> 00:09:12,870
tenemos aquí el inicio

227
00:09:12,870 --> 00:09:13,230
este

228
00:09:13,230 --> 00:09:19,320
el inicio, bueno, no se ve mucho

229
00:09:19,320 --> 00:09:19,960
pero da igual

230
00:09:19,960 --> 00:09:23,480
inicio, apunta

231
00:09:23,480 --> 00:09:26,440
En el caso genérico

232
00:09:26,440 --> 00:09:27,480
Pues aquí tenemos

233
00:09:27,480 --> 00:09:29,200
Esto

234
00:09:29,200 --> 00:09:31,940
Este a su vez

235
00:09:31,940 --> 00:09:34,559
Apunta

236
00:09:34,559 --> 00:09:37,899
A este

237
00:09:37,899 --> 00:09:42,759
Y este a su vez

238
00:09:42,759 --> 00:09:48,220
Este ya apunta

239
00:09:48,220 --> 00:09:57,350
A nulo

240
00:09:57,350 --> 00:09:58,309
Vale

241
00:09:58,309 --> 00:10:05,840
Esta es la lista genérica

242
00:10:05,840 --> 00:10:07,940
Vale, ¿qué queremos hacer?

243
00:10:08,360 --> 00:10:09,600
Cuando añadimos

244
00:10:09,600 --> 00:10:11,159
Pues lo que vamos a tener que hacer va a ser

245
00:10:11,159 --> 00:10:14,480
crear un nodo nuevo, es obligatorio

246
00:10:14,480 --> 00:10:15,779
habrá que crear un nodo nuevo

247
00:10:15,779 --> 00:10:20,009
donde en el

248
00:10:20,009 --> 00:10:21,830
dato le pondremos

249
00:10:21,830 --> 00:10:23,870
lo que me han pasado, esto es lo primero que habrá

250
00:10:23,870 --> 00:10:25,370
que hacer, crear un nodo nuevo sí o sí

251
00:10:25,370 --> 00:10:27,350
es lo primero que habrá que hacer en el añadir

252
00:10:27,350 --> 00:10:29,809
pues venga, vamos a hacer eso primero, sí o sí

253
00:10:29,809 --> 00:10:31,649
vamos a crear el nodo nuevo

254
00:10:31,649 --> 00:10:33,230
este es el nodo nuevo

255
00:10:33,230 --> 00:10:38,350
ala, eso es lo primero

256
00:10:38,350 --> 00:10:40,230
que ya hemos hecho, crear mi

257
00:10:40,230 --> 00:10:42,070
nodo nuevo que tengo que meter en la lista

258
00:10:42,070 --> 00:10:44,029
tengo que meterla, vale

259
00:10:44,029 --> 00:10:45,169
crear mi nodo nuevo

260
00:10:45,169 --> 00:10:46,429
vale

261
00:10:46,429 --> 00:10:49,929
ahora, a ese nodo

262
00:10:49,929 --> 00:10:52,509
le vamos a poner como dato

263
00:10:52,509 --> 00:10:56,779
esto que me han pasado aquí

264
00:10:56,779 --> 00:10:58,200
eso está claro, ¿no?

265
00:11:02,340 --> 00:11:03,500
silencio los de atrás

266
00:11:03,500 --> 00:11:05,639
este nodo nuevo

267
00:11:05,639 --> 00:11:07,799
tendré que pasarle yo en su campo

268
00:11:07,799 --> 00:11:09,740
dato, en su campo dato

269
00:11:09,740 --> 00:11:11,779
que es este de arriba, porque cada

270
00:11:11,779 --> 00:11:13,820
cada nodo

271
00:11:13,820 --> 00:11:15,480
recordad que tiene dos campos

272
00:11:15,480 --> 00:11:17,120
el campo dato

273
00:11:17,120 --> 00:11:20,450
Y el campo

274
00:11:20,450 --> 00:11:26,850
Siguiente

275
00:11:26,850 --> 00:11:28,950
¿Vale? Tiene los dos

276
00:11:28,950 --> 00:11:30,970
El campo dato y siguiente

277
00:11:30,970 --> 00:11:32,570
Pues al campo dato

278
00:11:32,570 --> 00:11:33,950
Y este nodo se llama

279
00:11:33,950 --> 00:11:35,409
Esto que hemos hecho aquí

280
00:11:35,409 --> 00:11:39,259
Este es el

281
00:11:39,259 --> 00:11:42,720
El nodo que acabo de hacer

282
00:11:42,720 --> 00:11:44,940
El objeto nodo que acabo de hacer

283
00:11:44,940 --> 00:11:46,820
¿Vale? Este

284
00:11:46,820 --> 00:11:48,840
Moisés

285
00:11:48,840 --> 00:11:50,240
¿Te callas o te corto la cabeza?

286
00:11:51,899 --> 00:11:52,379
Bueno

287
00:11:52,379 --> 00:11:54,340
No sé si es lo que más

288
00:11:54,340 --> 00:11:56,860
lo que más te costaría prescindir

289
00:11:56,860 --> 00:11:58,799
a ver

290
00:11:58,799 --> 00:12:02,779
este es el objeto

291
00:12:02,779 --> 00:12:03,659
que acabamos de crear

292
00:12:03,659 --> 00:12:04,220
¿vale?

293
00:12:06,799 --> 00:12:07,399
que es este

294
00:12:07,399 --> 00:12:09,039
el objeto que acabamos de crear

295
00:12:09,039 --> 00:12:09,759
este

296
00:12:09,759 --> 00:12:14,190
a su campo dato

297
00:12:14,190 --> 00:12:15,549
le estamos poniendo

298
00:12:15,549 --> 00:12:17,169
el dato que me pasan

299
00:12:17,169 --> 00:12:18,269
está claro ¿no?

300
00:12:18,669 --> 00:12:20,409
y ahora viene lo complicado

301
00:12:20,409 --> 00:12:21,389
decir vale

302
00:12:21,389 --> 00:12:22,730
y ahora

303
00:12:22,730 --> 00:12:24,929
¿cómo hago yo con estos enlaces?

304
00:12:25,070 --> 00:12:26,529
¿cómo hago yo con estas flechitas?

305
00:12:26,529 --> 00:12:29,149
para que se dé de la mano con los otros

306
00:12:29,149 --> 00:12:32,570
y forme parte de la lista.

307
00:12:32,669 --> 00:12:33,110
¿Cómo hago?

308
00:12:34,909 --> 00:12:36,169
A ver, hay dos opciones.

309
00:12:36,889 --> 00:12:40,070
Podríamos meterlo al principio o meterlo al final.

310
00:12:41,710 --> 00:12:43,649
La lista enlazada que ya está hecha en Java

311
00:12:43,649 --> 00:12:44,990
me da las dos posibilidades.

312
00:12:45,850 --> 00:12:47,529
Una es más fácil de programar que la otra.

313
00:12:48,269 --> 00:12:50,649
Vamos a programarla fácil ahora mismo, la facilita.

314
00:12:51,409 --> 00:12:53,309
Porque tampoco vamos a perder tiempo

315
00:12:53,309 --> 00:12:55,070
programando todas las funcionalidades

316
00:12:55,070 --> 00:12:55,809
si ya están hechas.

317
00:12:56,529 --> 00:12:57,710
Vamos a programarla facilita.

318
00:12:58,330 --> 00:13:00,509
Bueno, vamos a pensar, ¿cómo podría yo meter este aquí?

319
00:13:01,750 --> 00:13:06,110
Hombre, pues mira, con dos únicas sentencias ya lo inserto.

320
00:13:07,889 --> 00:13:12,710
Es decir, si yo copio en el campo siguiente lo que hay en inicio.

321
00:13:13,289 --> 00:13:14,730
Imaginaos que hago esta asignación.

322
00:13:15,710 --> 00:13:16,769
Imaginaos que hacéis esta.

323
00:13:17,409 --> 00:13:23,769
Nodo punto siguiente igual a inicio.

324
00:13:24,509 --> 00:13:25,909
Mirad esta asignación de aquí.

325
00:13:25,909 --> 00:13:27,669
Nodo siguiente igual a inicio

326
00:13:27,669 --> 00:13:30,149
¿Qué estamos haciendo con esta asignación?

327
00:13:30,970 --> 00:13:32,450
Con esta asignación lo que estamos haciendo es

328
00:13:32,450 --> 00:13:34,470
Que este pase a apuntar

329
00:13:34,470 --> 00:13:35,309
A donde apunta este

330
00:13:35,309 --> 00:13:39,029
Luego lo que estamos haciendo es que este empiece a apuntar

331
00:13:39,029 --> 00:13:40,190
No, esto no quiero

332
00:13:40,190 --> 00:13:42,649
Que este

333
00:13:42,649 --> 00:13:43,850
Empiece a apuntar

334
00:13:43,850 --> 00:13:48,450
Ahí, ¿verdad?

335
00:13:49,230 --> 00:13:50,450
Eso es lo que estamos haciendo

336
00:13:50,450 --> 00:14:03,769
Eso es lo que hemos hecho con esta única sentencia

337
00:14:03,769 --> 00:14:06,169
¿verdad? con esta única sentencia

338
00:14:06,169 --> 00:14:07,809
hola

339
00:14:07,809 --> 00:14:08,730
pasa

340
00:14:08,730 --> 00:14:12,090
con esta única sentencia

341
00:14:12,090 --> 00:14:13,389
lo que hemos hecho es que

342
00:14:13,389 --> 00:14:16,110
este pase a apuntar

343
00:14:16,110 --> 00:14:18,029
aquí ¿está claro?

344
00:14:19,509 --> 00:14:20,250
modo siguiente

345
00:14:20,250 --> 00:14:21,009
igual a inicio

346
00:14:21,009 --> 00:14:22,710
implica esto

347
00:14:22,710 --> 00:14:24,309
¿si o no?

348
00:14:25,529 --> 00:14:28,169
¿si? vale, entonces ya se ha dado

349
00:14:28,169 --> 00:14:30,009
de la mano, pero hombre esto sigue

350
00:14:30,009 --> 00:14:32,250
estando mal porque ahora inicio tendría que apuntar a esta

351
00:14:32,250 --> 00:14:50,990
Y entonces lo habríamos acogido al principio, ¿verdad? Lo habríamos acogido al principio. Vale, pues ¿cómo hacemos que inicio ahora ya deje de apuntar a este enlace fuera y empiece a apuntar a esta y entonces ya la lista ya está otra vez construida?

352
00:14:50,990 --> 00:14:53,769
este se ha cogido dentro y ya la lista

353
00:14:53,769 --> 00:14:55,850
es una lista enlazadita

354
00:14:55,850 --> 00:14:57,389
donde hemos metido a este al principio

355
00:14:57,389 --> 00:14:59,730
pues que sentencia tendríamos que hacer

356
00:14:59,730 --> 00:15:01,669
para que inicio ahora a apuntar

357
00:15:01,669 --> 00:15:02,370
a este nodo

358
00:15:02,370 --> 00:15:05,129
que sentencia escribiríais

359
00:15:05,129 --> 00:15:09,909
alguien me la dictaría

360
00:15:09,909 --> 00:15:12,149
para conseguir

361
00:15:12,149 --> 00:15:13,710
que inicio ahora en lugar

362
00:15:13,710 --> 00:15:15,710
de llevarme aquí, me lleve al

363
00:15:15,710 --> 00:15:17,110
nodo que yo acabo de crear

364
00:15:17,110 --> 00:15:20,210
al que yo acabo de crear, a este, que se llama nodo

365
00:15:20,210 --> 00:15:21,009
Que se llama nodo.

366
00:15:21,950 --> 00:15:23,129
¿Qué sentencia pondríais aquí?

367
00:15:28,730 --> 00:15:31,250
Para que esta que es inicio

368
00:15:31,250 --> 00:15:51,169
empiece a apuntar

369
00:15:51,169 --> 00:15:53,330
a esta variable que se llama

370
00:15:53,330 --> 00:15:55,110
nodo, cuya referencia es nodo.

371
00:15:56,649 --> 00:15:57,970
¿Qué sentencia pondríais?

372
00:15:58,009 --> 00:15:58,769
¿Nadie me la dicta?

373
00:16:01,970 --> 00:16:02,570
Piensa lo mejor.

374
00:16:03,370 --> 00:16:04,190
Al revés.

375
00:16:05,529 --> 00:16:06,269
Inicio igual a nodo.

376
00:16:06,429 --> 00:16:07,289
Ya está, ya hemos acabado.

377
00:16:07,929 --> 00:16:08,690
Se acabó el método.

378
00:16:09,769 --> 00:16:10,070
Ya está.

379
00:16:10,909 --> 00:16:12,230
Joder, ¿qué he escrito aquí?

380
00:16:13,769 --> 00:16:14,330
Inicio.

381
00:16:15,850 --> 00:16:16,850
Ya lo tenemos.

382
00:16:17,970 --> 00:16:18,990
Luego son tres partes.

383
00:16:19,210 --> 00:16:22,549
Primero, creamos el nodo y le damos el dato.

384
00:16:22,850 --> 00:16:23,129
Ya está.

385
00:16:23,769 --> 00:16:28,750
Ahora, hacemos que su campo siguiente apunte al principio de la lista.

386
00:16:29,750 --> 00:16:33,529
Y luego cambiamos el principio de la lista para que apunte a este nodo.

387
00:16:34,490 --> 00:16:34,850
Ya está.

388
00:16:35,570 --> 00:16:39,809
Ya hemos agrandado la lista metiéndole dentro un nodo nuevo.

389
00:16:39,809 --> 00:16:41,289
al principio en vez de al final

390
00:16:41,289 --> 00:16:43,730
pero estos son

391
00:16:43,730 --> 00:16:46,330
líneas de código

392
00:16:46,330 --> 00:16:48,190
que no le cuesta nada a la máquina virtual

393
00:16:48,190 --> 00:16:48,970
hacer, nada

394
00:16:48,970 --> 00:16:51,769
y sin embargo lo del array lo rompo

395
00:16:51,769 --> 00:16:53,929
lo parto, copio todo, lo recorro

396
00:16:53,929 --> 00:16:55,870
para copiar, imaginaos que son 20.000

397
00:16:55,870 --> 00:16:57,970
pues es una locura, sin embargo aquí

398
00:16:57,970 --> 00:16:59,649
insertar ha sido sencillísimo

399
00:16:59,649 --> 00:17:02,940
¿vale?

400
00:17:06,549 --> 00:17:07,869
tenemos el método add

401
00:17:07,869 --> 00:17:11,640
ahora ya desde mi main

402
00:17:11,640 --> 00:17:14,539
que yo le meto un hola

403
00:17:14,539 --> 00:17:16,400
pues ese hola

404
00:17:16,440 --> 00:17:19,140
se quedará en la lista

405
00:17:19,140 --> 00:17:21,259
que yo le meto luego un adiós

406
00:17:21,259 --> 00:17:23,279
pues aparecerá otro nodo con ese adiós

407
00:17:23,279 --> 00:17:24,420
y así todos los que yo quiera

408
00:17:24,420 --> 00:17:26,539
vale

409
00:17:26,539 --> 00:17:29,519
o sea, para comprobarlo vamos a hacernos el get

410
00:17:29,519 --> 00:17:32,819
bueno, a ver

411
00:17:32,819 --> 00:17:35,019
lo que pasa es que el get no es tan sencillo

412
00:17:35,019 --> 00:17:36,019
vamos a

413
00:17:36,019 --> 00:17:40,900
primero comprobar que no hay errores de ejecución

414
00:17:40,900 --> 00:17:43,160
no vamos a poder ver nada porque no tenemos la consulta

415
00:17:43,160 --> 00:17:46,380
pero vamos a hacer esta primera ejecución del main

416
00:17:46,380 --> 00:17:47,480
yo me hago mi objeto lista

417
00:17:47,480 --> 00:17:49,799
y le meto cadenas, hola Dios

418
00:17:49,799 --> 00:17:51,559
vamos a ver

419
00:17:51,559 --> 00:17:53,160
que no nos dé error de ejecución al menos

420
00:17:53,160 --> 00:17:55,160
para ver que no hemos programado

421
00:17:55,160 --> 00:17:56,859
algún null pointer exception o algo mal

422
00:17:56,859 --> 00:17:59,819
bueno

423
00:17:59,819 --> 00:18:03,319
al menos no hay errores de ejecución

424
00:18:03,319 --> 00:18:05,220
no se nos ha escapado ninguna burrada

425
00:18:05,220 --> 00:18:07,259
pero hombre, vamos a ver si realmente

426
00:18:07,259 --> 00:18:09,119
vamos a hacer el método get, al menos

427
00:18:09,119 --> 00:18:10,519
vamos a hacer al menos el método get

428
00:18:10,519 --> 00:18:13,039
para poder recuperar los datos por posición

429
00:18:13,039 --> 00:18:16,039
vamos a hacerle el get

430
00:18:16,039 --> 00:18:17,740
este de aquí

431
00:18:17,740 --> 00:18:20,339
para tener ya una estructura de datos operativa

432
00:18:20,339 --> 00:18:22,059
mucho más útil que el array

433
00:18:22,059 --> 00:18:23,339
esto es mucho más útil que un array

434
00:18:23,339 --> 00:18:27,349
vale, pues el get

435
00:18:27,349 --> 00:18:29,349
aquí

436
00:18:29,349 --> 00:18:31,690
el get que me tiene que devolver

437
00:18:31,690 --> 00:18:33,890
el contenido de uno de los nodos

438
00:18:33,890 --> 00:18:34,710
que es de tipo string

439
00:18:34,710 --> 00:18:37,890
y que recibe una posición

440
00:18:37,890 --> 00:18:45,319
vale, este será el get

441
00:18:45,319 --> 00:18:54,410
vale, pues el get no es tan sencillo

442
00:18:56,410 --> 00:18:57,970
porque el get ahora ya implica

443
00:18:57,970 --> 00:19:00,430
la operación de ir avanzando en la lista

444
00:19:00,430 --> 00:19:02,450
de ir avanzando

445
00:19:02,450 --> 00:19:04,650
porque yo tengo la dirección del primero

446
00:19:04,650 --> 00:19:06,049
pero solo tengo la del primero

447
00:19:06,049 --> 00:19:07,549
que está aquí en inicio

448
00:19:07,549 --> 00:19:10,130
está aquí arriba, solo tengo esta

449
00:19:10,130 --> 00:19:11,710
con lo cual

450
00:19:11,710 --> 00:19:14,430
el primer dato lo tengo facilísimo

451
00:19:14,430 --> 00:19:16,230
porque tengo la dirección del primero

452
00:19:16,230 --> 00:19:16,869
que es inicio

453
00:19:16,869 --> 00:19:20,349
entonces si la posición que me dicen es la del primero

454
00:19:20,349 --> 00:19:21,930
es muy sencillo

455
00:19:21,930 --> 00:19:23,450
pero claro, me pueden decir cualquiera

456
00:19:23,450 --> 00:19:25,910
entonces tenemos que saber

457
00:19:25,910 --> 00:19:27,950
avanzar a través del inicio

458
00:19:27,970 --> 00:19:32,970
ir avanzando por la lista hasta pararnos en la que toque.

459
00:19:34,630 --> 00:19:37,049
Bueno, pues esto, el avance en la lista, ¿cómo se hace?

460
00:19:38,410 --> 00:19:41,869
Pues lo que se nos ocurriría es hacer un puntero,

461
00:19:41,869 --> 00:19:44,529
una referencia, perdón, una referencia auxiliar.

462
00:19:45,890 --> 00:19:49,650
Que inicialmente, la inicializamos inicialmente con la del primero.

463
00:19:50,390 --> 00:20:06,630
Vamos a llamarle aux, ¿vale?

464
00:20:06,650 --> 00:20:09,450
Vamos a llamarle aux y la inicializamos.

465
00:20:11,349 --> 00:20:12,329
A ver qué suena.

466
00:20:12,329 --> 00:20:14,809
¿alguien tiene un péndulo por ahí dando la brasa?

467
00:20:17,569 --> 00:20:18,369
a ver, venga

468
00:20:18,369 --> 00:20:23,539
bueno, la del primero ahora mismo es esta

469
00:20:23,539 --> 00:20:24,259
ahí

470
00:20:24,259 --> 00:20:28,490
vale, cogemos una variable auxiliar

471
00:20:28,490 --> 00:20:30,509
y le inicializamos a la del primero

472
00:20:30,509 --> 00:20:33,410
y ahora, le hacemos que esa variable auxiliar

473
00:20:33,410 --> 00:20:34,950
vaya avanzando, vaya avanzando

474
00:20:34,950 --> 00:20:36,950
tantas veces como me diga

475
00:20:36,950 --> 00:20:38,890
posición, tantas veces como me diga

476
00:20:38,890 --> 00:20:40,789
eso será un contador

477
00:20:40,789 --> 00:20:43,210
un contador que cuando ha llegado a posición

478
00:20:43,210 --> 00:20:44,130
nos paramos

479
00:20:44,130 --> 00:20:47,210
y cuando este puntero ya ha ido avanzando

480
00:20:47,210 --> 00:20:49,029
tantas veces como me diga posición

481
00:20:49,029 --> 00:20:50,289
recupero

482
00:20:50,289 --> 00:20:52,589
su campo dato

483
00:20:52,589 --> 00:20:53,549
y ya está

484
00:20:53,549 --> 00:20:57,230
entonces, coger una

485
00:20:57,230 --> 00:20:59,630
referencia auxiliar a nodo e inicializarla

486
00:20:59,630 --> 00:21:00,109
a la primera

487
00:21:00,109 --> 00:21:01,930
eso lo tenemos fácil

488
00:21:01,930 --> 00:21:04,329
me cojo yo

489
00:21:04,329 --> 00:21:07,450
una referencia a nodo auxiliar

490
00:21:07,450 --> 00:21:09,849
y la inicializo

491
00:21:09,849 --> 00:21:11,190
a esto, a inicio

492
00:21:11,190 --> 00:21:13,430
ya tengo la primera parte

493
00:21:13,430 --> 00:21:15,369
tengo esta referencia

494
00:21:15,369 --> 00:21:17,250
anodo auxiliar que está

495
00:21:17,250 --> 00:21:18,809
apuntando al primero de todos

496
00:21:18,809 --> 00:21:21,490
que está apuntando al primero

497
00:21:21,490 --> 00:21:24,269
¿vale?

498
00:21:24,690 --> 00:21:26,710
está apuntando al primero, a este primero

499
00:21:26,710 --> 00:21:28,390
y ahora

500
00:21:28,390 --> 00:21:31,069
antes de meterlo del contador y eso

501
00:21:31,069 --> 00:21:33,470
la sentencia

502
00:21:33,470 --> 00:21:35,150
de avanzarlo para que

503
00:21:35,150 --> 00:21:36,309
apunte al siguiente

504
00:21:36,309 --> 00:21:39,009
¿cuál se os ocurre que podría hacer?

505
00:21:39,750 --> 00:21:40,609
es decir

506
00:21:40,609 --> 00:21:42,930
¿qué sentencia habría que poner aquí

507
00:21:42,930 --> 00:21:44,549
para hacer que aux apunte

508
00:21:44,549 --> 00:21:46,589
al siguiente?

509
00:21:47,069 --> 00:21:49,029
al que está apuntando en ese momento.

510
00:21:50,109 --> 00:21:51,170
aux igual a

511
00:21:51,170 --> 00:21:53,430
¿qué pondríais ahí

512
00:21:53,430 --> 00:21:55,369
para que aux pasara

513
00:21:55,369 --> 00:21:57,349
de apuntar a un nodo al que

514
00:21:57,349 --> 00:21:59,309
esté para apuntar al otro, al que

515
00:21:59,309 --> 00:22:00,130
está consecutivo?

516
00:22:01,430 --> 00:22:02,569
¿qué pondríais ahí?

517
00:22:03,150 --> 00:22:04,009
aux igual a qué?

518
00:22:05,730 --> 00:22:05,930
¿a?

519
00:22:08,150 --> 00:22:10,170
nodo no, aquí no hay nada que se llame nodo.

520
00:22:10,950 --> 00:22:12,670
aux igual a va por ahí pero no

521
00:22:12,670 --> 00:22:14,470
aux igual a qué?

522
00:22:19,470 --> 00:22:20,869
no, a ver, aux

523
00:22:20,869 --> 00:22:22,849
es la dirección de este

524
00:22:22,849 --> 00:22:24,970
que tiene dentro dato y siguiente

525
00:22:24,970 --> 00:22:27,730
aux tiene dentro dato y aux tiene dentro siguiente

526
00:22:27,730 --> 00:22:29,809
que a su vez es la del siguiente

527
00:22:29,809 --> 00:22:33,450
pues para que aux que tiene dentro dato

528
00:22:33,450 --> 00:22:34,630
y tiene dentro siguiente

529
00:22:34,630 --> 00:22:36,009
apunte a su siguiente

530
00:22:36,009 --> 00:22:41,150
sí pero ese t no puede ir suelto

531
00:22:41,150 --> 00:22:42,210
porque es un campo de alguien

532
00:22:42,210 --> 00:22:45,609
tiene que apuntar al siguiente de alguien

533
00:22:45,609 --> 00:22:46,730
sí pero al siguiente de quién

534
00:22:46,730 --> 00:22:48,410
de sí mismo

535
00:22:48,410 --> 00:22:50,930
tiene que apuntar al siguiente de sí mismo

536
00:22:50,930 --> 00:22:53,210
y el siguiente de sí mismo, ¿quién es este?

537
00:22:54,589 --> 00:22:55,849
esta es la sentencia

538
00:22:55,849 --> 00:22:57,630
con la que aux avanza

539
00:22:57,630 --> 00:22:58,309
una posición

540
00:22:58,309 --> 00:23:10,759
con esta sentencia

541
00:23:10,759 --> 00:23:12,339
aux avanza una posición

542
00:23:12,339 --> 00:23:14,440
porque aux.siguiente

543
00:23:14,440 --> 00:23:15,720
es la dirección de su siguiente

544
00:23:15,720 --> 00:23:18,539
pues yo la cojo y le sobrescribo a él

545
00:23:18,539 --> 00:23:19,480
con la de su siguiente

546
00:23:19,480 --> 00:23:21,579
le sobrescribo a él con la de su siguiente

547
00:23:21,579 --> 00:23:24,720
luego con esta, aux avanza en una posición

548
00:23:24,720 --> 00:23:27,019
le sobrescribo a él con la de su siguiente

549
00:23:27,019 --> 00:23:29,319
y ahora ¿cuántas veces hay que hacer eso?

550
00:23:30,000 --> 00:23:31,559
tantas como me indique posición

551
00:23:31,559 --> 00:23:34,279
tengo que hacerlas tantas veces como posición

552
00:23:34,279 --> 00:23:37,019
y cuando ya lo haya avanzado

553
00:23:37,019 --> 00:23:38,460
tantas veces como me diga posición

554
00:23:38,460 --> 00:23:40,940
pues recupero su campo dato

555
00:23:40,940 --> 00:23:42,480
recupero su campo dato

556
00:23:42,480 --> 00:23:44,740
¿vale? entonces esto ya sí que será un bucle

557
00:23:44,740 --> 00:23:47,279
un bucle que podríamos plantearnos así

558
00:23:47,279 --> 00:23:49,380
pues while posición

559
00:23:49,380 --> 00:23:51,900
sea mayor o igual que 0

560
00:23:51,900 --> 00:23:53,920
esto es lo primero que se os ocurriría

561
00:23:53,920 --> 00:23:55,559
ya de programación que lo hemos hecho mil veces

562
00:23:55,559 --> 00:23:57,940
Pues aux igual

563
00:23:57,940 --> 00:23:59,039
Aux, esto

564
00:23:59,039 --> 00:24:01,519
Lo quito de aquí, claro

565
00:24:01,519 --> 00:24:03,400
Aux igual a aux punto

566
00:24:03,400 --> 00:24:05,059
Siguiente

567
00:24:05,059 --> 00:24:07,160
¿Vale?

568
00:24:07,279 --> 00:24:08,140
Y posición

569
00:24:08,140 --> 00:24:10,460
Menos menos

570
00:24:10,460 --> 00:24:12,339
Por ejemplo

571
00:24:12,339 --> 00:24:16,329
Me ahorro contador y me ahorro todo

572
00:24:16,329 --> 00:24:18,890
Esto ya es de programación de toda la vida

573
00:24:18,890 --> 00:24:21,130
Voy decrementando posición

574
00:24:21,130 --> 00:24:24,029
Y mientras no haya llegado a cero

575
00:24:24,029 --> 00:24:26,130
Voy avanzando el puntero

576
00:24:27,130 --> 00:24:30,890
entonces cuando hayamos salido del while

577
00:24:30,890 --> 00:24:32,809
aux ha avanzado

578
00:24:32,809 --> 00:24:34,349
una cantidad de veces

579
00:24:34,349 --> 00:24:35,170
igual a posición

580
00:24:35,170 --> 00:24:37,349
¿si o no?

581
00:24:38,869 --> 00:24:40,710
si ¿no? es un bucle con contador

582
00:24:40,710 --> 00:24:42,869
el papel del contador lo está haciendo aquí posición

583
00:24:42,869 --> 00:24:44,789
lo voy decrementando

584
00:24:44,789 --> 00:24:45,930
y cuando llega a cero

585
00:24:45,930 --> 00:24:48,329
pues ya ha avanzado tantas veces

586
00:24:48,329 --> 00:24:49,750
entonces

587
00:24:49,750 --> 00:24:53,029
cuando ya estoy

588
00:24:53,029 --> 00:24:54,890
con aux

589
00:24:54,890 --> 00:24:56,630
aux ha ido avanzando

590
00:24:56,630 --> 00:24:59,069
avanzado, primero apuntaba a este

591
00:24:59,069 --> 00:25:00,730
luego a este, luego a este

592
00:25:00,730 --> 00:25:02,730
cuando ha avanzado tantas veces

593
00:25:02,730 --> 00:25:04,809
como me dice

594
00:25:04,809 --> 00:25:07,049
posición, ya se queda apuntando

595
00:25:07,049 --> 00:25:08,369
al nodo que yo quiero

596
00:25:08,369 --> 00:25:10,890
y cuando ya está apuntando al nodo

597
00:25:10,890 --> 00:25:12,849
que queremos, lo único que

598
00:25:12,849 --> 00:25:14,809
toca hacer es devolver el

599
00:25:14,809 --> 00:25:21,900
dato, aux.dato

600
00:25:21,900 --> 00:25:23,079
ya está

601
00:25:23,079 --> 00:25:25,700
luego, hacemos un auxiliar

602
00:25:25,700 --> 00:25:26,680
que apunte al primero

603
00:25:26,680 --> 00:25:29,660
lo avanzamos tantas veces como me diga

604
00:25:29,660 --> 00:25:30,099
posición

605
00:25:30,099 --> 00:25:33,240
y cuando ya lo he avanzado

606
00:25:33,240 --> 00:25:34,619
hasta el nodo objetivo

607
00:25:34,619 --> 00:25:37,279
cuando ya ha llegado al nodo objetivo

608
00:25:37,279 --> 00:25:39,180
devuelvo el dato que está

609
00:25:39,180 --> 00:25:40,000
en ese nodo objetivo

610
00:25:40,000 --> 00:25:43,079
y ya está

611
00:25:43,079 --> 00:25:46,339
ya tendría mi get hecho

612
00:25:46,339 --> 00:26:01,740
vale, porque me da

613
00:26:01,740 --> 00:26:03,160
por el public, no le he puesto public

614
00:26:03,160 --> 00:26:05,460
es por eso por lo que me da, ah si, pero no le he puesto public

615
00:26:05,460 --> 00:26:06,420
por eso me da en

616
00:26:06,420 --> 00:26:12,069
vale, pues ya tendría mi primera versión del get

617
00:26:12,069 --> 00:26:22,980
vale, no estamos

618
00:26:22,980 --> 00:26:25,240
verificando si hay casos que no hemos

619
00:26:25,240 --> 00:26:27,480
comprobado errores, lo que sea, no lo estamos

620
00:26:27,480 --> 00:26:29,140
pero vamos a hacer una primera prueba

621
00:26:29,140 --> 00:26:30,839
a ver si me devuelve

622
00:26:30,839 --> 00:26:32,960
¿qué me tendrá que devolver? este

623
00:26:32,960 --> 00:26:35,259
cuando yo ejecute este programa, ¿qué me tendrá

624
00:26:35,259 --> 00:26:36,119
que devolver de cero?

625
00:26:38,480 --> 00:26:43,700
¿hola o adiós? no, adiós

626
00:26:43,700 --> 00:26:44,859
porque mirad que el add

627
00:26:44,859 --> 00:26:47,140
lo hemos hecho en la versión sencilla que

628
00:26:47,140 --> 00:26:49,039
los va insertando al principio

629
00:26:49,039 --> 00:26:51,000
entonces el último que llegó

630
00:26:51,000 --> 00:26:53,619
se ha metido al principio, está haciendo como

631
00:26:53,619 --> 00:26:55,619
una pila, está simulando una pila

632
00:26:55,619 --> 00:26:56,859
¿vale? entonces

633
00:26:56,859 --> 00:26:58,119
el hola

634
00:26:58,119 --> 00:27:01,359
primero será el primero que meterá el hola

635
00:27:01,359 --> 00:27:02,680
luego cuando llegue el adiós

636
00:27:02,680 --> 00:27:05,039
el adiós se colará delante del hola

637
00:27:05,039 --> 00:27:05,819
y así todos

638
00:27:05,819 --> 00:27:08,799
entonces la posición 0 será la del último que se ha metido

639
00:27:08,799 --> 00:27:09,900
la del último

640
00:27:09,900 --> 00:27:12,359
en realidad estamos haciendo una pila

641
00:27:12,359 --> 00:27:14,259
que es un caso concreto de listag

642
00:27:14,259 --> 00:27:15,539
enlazada genérica

643
00:27:15,539 --> 00:27:18,299
pero porque es más fácil de programar que

644
00:27:18,299 --> 00:27:19,480
meterlo al final

645
00:27:19,480 --> 00:27:23,849
vale, vamos a probarlo

646
00:27:23,849 --> 00:27:24,789
a ver si

647
00:27:24,789 --> 00:27:27,210
hacemos nuestro main

648
00:27:27,210 --> 00:27:34,910
vale

649
00:27:34,910 --> 00:27:38,400
Anda, ¿por qué no saca Lola?

650
00:27:44,000 --> 00:27:45,039
Ah, por el mayor o igual

651
00:27:45,039 --> 00:27:45,599
¿Vale?

652
00:27:46,460 --> 00:27:50,039
Pero vamos a meterle más nodos

653
00:27:50,039 --> 00:27:51,000
Para ver mejor

654
00:27:51,000 --> 00:27:55,220
A ver, vamos a poner

655
00:27:55,220 --> 00:27:59,039
Cadena 1

656
00:27:59,039 --> 00:28:00,460
Para ver mejor lo que está haciendo

657
00:28:00,460 --> 00:28:01,960
Solo con estos dos

658
00:28:01,960 --> 00:28:05,799
Control C

659
00:28:05,799 --> 00:28:12,579
Vamos a meterle 4

660
00:28:12,579 --> 00:28:15,000
Cadena 1, cadena 2

661
00:28:15,000 --> 00:28:17,759
Cadena 3, cadena 4

662
00:28:18,319 --> 00:28:19,680
¿Vale?

663
00:28:19,680 --> 00:28:22,160
Entonces él irá emitiendo cadena 4

664
00:28:22,160 --> 00:28:23,740
Luego cadena 3 se colará delante

665
00:28:23,740 --> 00:28:25,880
Luego cadena 2 se colará delante

666
00:28:25,880 --> 00:28:27,599
Y luego cadena 1 se colará delante

667
00:28:27,599 --> 00:28:30,460
¿Vale? O sea, ya sabemos que en nuestra lista

668
00:28:30,460 --> 00:28:31,640
Tal y como hemos hecho el app

669
00:28:31,640 --> 00:28:34,079
Ya sabemos que en nuestra lista está la cadena 1

670
00:28:34,079 --> 00:28:35,859
Cadena 2, cadena 3, cadena 4

671
00:28:35,859 --> 00:28:37,359
Porque el app nos va colando delante

672
00:28:37,359 --> 00:28:39,779
Vale, ahora vamos a probar nuestro get

673
00:28:39,779 --> 00:28:41,799
Con 4 datos que vamos a ver mejor

674
00:28:41,799 --> 00:28:44,400
Lo que está haciendo

675
00:28:44,400 --> 00:28:46,359
Lo probamos

676
00:28:46,359 --> 00:28:48,240
Vale

677
00:28:48,240 --> 00:28:51,640
vale, me está sacando

678
00:28:51,640 --> 00:28:54,000
no me está sacando el primero de todos

679
00:28:54,000 --> 00:28:55,819
vale, me está sacando

680
00:28:55,819 --> 00:28:56,519
cadena 3

681
00:28:56,519 --> 00:29:02,029
entonces, vale

682
00:29:02,029 --> 00:29:03,210
aquí

683
00:29:03,210 --> 00:29:07,329
tendremos que revisar entonces que el

684
00:29:07,329 --> 00:29:08,230
número de avances

685
00:29:08,230 --> 00:29:11,410
no es el correcto

686
00:29:12,150 --> 00:29:13,650
el número de avances no es el correcto

687
00:29:13,650 --> 00:29:15,589
¿qué modificaríais

688
00:29:15,589 --> 00:29:20,250
aquí? es decir, si me

689
00:29:20,250 --> 00:29:23,559
saca el 0, por lo pronto

690
00:29:23,559 --> 00:29:25,539
quitaríamos el igual, porque está avanzando uno de más

691
00:29:25,539 --> 00:29:27,759
entonces vamos a ponernos en el caso extremo

692
00:29:27,759 --> 00:29:28,599
si yo le doy el 0

693
00:29:28,599 --> 00:29:31,640
no tiene que avanzar ni una sola vez

694
00:29:31,640 --> 00:29:33,539
no tiene que avanzar ninguna, ni una sola

695
00:29:33,539 --> 00:29:35,519
¿vale? si yo le doy el 0 no tiene que avanzar ninguna

696
00:29:35,519 --> 00:29:38,119
porque si yo le doy el 0, la posición 0

697
00:29:38,119 --> 00:29:39,920
aux ya está apuntando a la primera

698
00:29:39,920 --> 00:29:41,980
de todas, aux ya está apuntando

699
00:29:41,980 --> 00:29:43,359
a la primera, no tiene que avanzar ninguna

700
00:29:43,359 --> 00:29:45,980
entonces igual se quita, lo que pasa es que

701
00:29:45,980 --> 00:29:47,900
yo esperaba que me hubiera sacado cadena 2

702
00:29:47,900 --> 00:29:49,880
no cadena 3, no sé por qué me ha sacado cadena 3

703
00:29:49,880 --> 00:29:51,859
porque este mayor

704
00:29:51,859 --> 00:29:54,019
igual sí que estaba a propósito

705
00:29:54,019 --> 00:29:55,359
pero no sé por qué me ha sacado cadena 3

706
00:29:55,359 --> 00:29:57,440
vamos a volverlo a probar

707
00:29:57,440 --> 00:29:58,259
ahora, vale

708
00:29:58,259 --> 00:30:01,720
avanzamos y decrementamos

709
00:30:01,720 --> 00:30:05,410
aux.dato

710
00:30:05,410 --> 00:30:06,690
vamos a ver

711
00:30:06,690 --> 00:30:09,289
le meto cadena 1, cadena

712
00:30:09,289 --> 00:30:10,970
2, cadena 3, cadena 4

713
00:30:10,970 --> 00:30:13,170
aminista enlazada y le saco la posición

714
00:30:13,170 --> 00:30:13,750
0

715
00:30:13,750 --> 00:30:16,190
vale

716
00:30:16,190 --> 00:30:20,349
ahora sí, ah claro, sí, es que estoy al revés

717
00:30:20,349 --> 00:30:22,069
me lo había saco correctamente, perdón, perdón

718
00:30:22,069 --> 00:30:24,150
vale, sí, sí, me tenía que sacar el último

719
00:30:24,150 --> 00:30:26,450
me había hecho yo un lío

720
00:30:26,450 --> 00:30:28,450
antes me sacaba este por el mayor o igual

721
00:30:28,450 --> 00:30:30,869
al haber quitado el igual

722
00:30:30,869 --> 00:30:32,410
ya me saca el 0 que es este

723
00:30:32,410 --> 00:30:33,950
recordad que esta es la posición 0

724
00:30:33,950 --> 00:30:36,829
esta es la 1, esta es la 2 y esta es la 3

725
00:30:36,829 --> 00:30:40,500
porque la última que se mete

726
00:30:40,500 --> 00:30:41,359
se cuela la primera

727
00:30:41,359 --> 00:30:43,559
entonces nuestro get funciona

728
00:30:43,559 --> 00:30:45,460
funciona correctamente

729
00:30:45,460 --> 00:30:48,140
lo único es que

730
00:30:48,140 --> 00:30:49,859
el haber hecho esta versión sencilla

731
00:30:49,859 --> 00:30:51,839
pues hombre, me los está metiendo

732
00:30:51,839 --> 00:30:53,819
de forma antiintuitiva

733
00:30:53,819 --> 00:30:55,519
en lugar de ponérmelos al final

734
00:30:55,519 --> 00:30:57,700
es como si los insertara al principio

735
00:30:57,700 --> 00:30:59,960
pero la estructura de datos me está funcionando

736
00:30:59,960 --> 00:31:02,420
me vale para meter, consultar

737
00:31:02,420 --> 00:31:04,140
borrar cuando hagamos

738
00:31:04,140 --> 00:31:04,819
el método, etc.

739
00:31:06,220 --> 00:31:08,400
Aquí claro, esto se hace muy poco operativo

740
00:31:08,400 --> 00:31:10,279
esto querríamos usarlo como si fuera

741
00:31:10,279 --> 00:31:12,440
un array, que es, oye yo quiero recorrerlo con un for

742
00:31:12,440 --> 00:31:14,339
querríamos poder hacer esto

743
00:31:14,339 --> 00:31:16,099
querríamos poder hacer

744
00:31:16,099 --> 00:31:17,339
un recorrido de este estilo

745
00:31:17,339 --> 00:31:19,519
desde i sea igual a 0

746
00:31:19,519 --> 00:31:22,059
mientras i

747
00:31:22,059 --> 00:31:22,819
sea menor

748
00:31:22,819 --> 00:31:24,640
que

749
00:31:24,640 --> 00:31:27,579
el tamaño de la lista

750
00:31:27,579 --> 00:31:45,359
¿Qué mi lista cómo se llama? Lista. Entonces, hombre, estaría bien tener un método, ojalá tuviéramos un método que me dijera cuántos datos tiene la lista, que me los dijera. Porque si lo tuviéramos, yo podría hacer un recorrido igual que hago con los arrays, ¿verdad?

751
00:31:45,359 --> 00:31:58,920
vale, o sea, si tuviéramos un método

752
00:31:58,920 --> 00:32:01,039
como la propiedad

753
00:32:01,039 --> 00:32:03,000
punto length de los arrays, pues igualito

754
00:32:03,000 --> 00:32:04,079
un método

755
00:32:04,079 --> 00:32:07,059
que me devolviera el tamaño de la lista

756
00:32:07,059 --> 00:32:09,000
podría usarlo exactamente igual

757
00:32:09,000 --> 00:32:10,900
que un array, recorrerlo con

758
00:32:10,900 --> 00:32:11,539
un índice

759
00:32:11,539 --> 00:32:14,119
y consultar cada posición

760
00:32:14,119 --> 00:32:16,480
pero claro, me falta el método

761
00:32:16,480 --> 00:32:18,579
porque yo aquí cuando he hecho la lista

762
00:32:18,579 --> 00:32:19,859
hombre, yo sé que tengo cuatro

763
00:32:19,859 --> 00:32:22,519
pero porque los he metido yo, pero esa lista

764
00:32:22,519 --> 00:32:25,059
puede llegar de otro sitio, puede llegar de otro lado

765
00:32:25,059 --> 00:32:27,740
entonces este método lo necesitamos para poder hacer recorrido

766
00:32:27,740 --> 00:32:29,880
bueno, pues no pasa nada, vamos a programarlo

767
00:32:29,880 --> 00:32:31,960
vamos a programar

768
00:32:31,960 --> 00:32:35,190
un método que nos

769
00:32:35,190 --> 00:32:36,910
da el

770
00:32:36,910 --> 00:32:39,430
tamaño de la lista

771
00:32:39,430 --> 00:32:44,079
vale, pues ¿cómo

772
00:32:44,079 --> 00:32:45,940
programaríais este método? ¿cómo se os ocurre?

773
00:32:50,089 --> 00:32:51,430
lo primero, ¿qué operación

774
00:32:51,430 --> 00:32:56,680
hay que hacer? o sea, que hay

775
00:32:56,680 --> 00:32:58,960
la lista que nos

776
00:32:58,960 --> 00:32:59,599
tiene que devolver

777
00:32:59,599 --> 00:33:02,460
¿cuántos nodos hay? ¿no?

778
00:33:03,819 --> 00:33:04,680
luego, para saber

779
00:33:04,680 --> 00:33:06,319
cuántos hay de algo que hay que hacer?

780
00:33:08,240 --> 00:33:08,720
Contar.

781
00:33:09,400 --> 00:33:10,599
Pues tenemos que contar.

782
00:33:10,960 --> 00:33:11,920
Eso es lo primero de todo.

783
00:33:12,660 --> 00:33:14,880
Pues si tenemos que contar, no hay tutía.

784
00:33:16,019 --> 00:33:17,200
Tendremos que hacer un contador.

785
00:33:17,440 --> 00:33:18,599
Porque lo que tenemos es que contar.

786
00:33:19,500 --> 00:33:19,759
Vale.

787
00:33:20,299 --> 00:33:21,400
¿Y ahora qué tendremos que hacer?

788
00:33:23,400 --> 00:33:23,920
Contar

789
00:33:23,920 --> 00:33:26,359
cuántos avances

790
00:33:26,359 --> 00:33:28,480
necesito

791
00:33:28,480 --> 00:33:30,400
hasta llegar a dónde.

792
00:33:33,460 --> 00:33:33,740
¿Ah?

793
00:33:35,259 --> 00:33:35,740
Bueno,

794
00:33:35,740 --> 00:33:37,680
contar, bueno

795
00:33:37,680 --> 00:33:40,299
los avances salen desde el principio

796
00:33:40,299 --> 00:33:41,559
entonces a dónde llegas al final

797
00:33:41,559 --> 00:33:44,599
entonces ¿cuántos avances hay hasta llegar a

798
00:33:44,599 --> 00:33:47,519
el final de la lista? ¿cuál es?

799
00:33:47,900 --> 00:33:50,400
nul, vale, bueno pues lo mismo

800
00:33:50,400 --> 00:33:52,380
un puntero auxiliar que se

801
00:33:52,380 --> 00:33:53,920
inicializa aquí y lo vamos avanzando

802
00:33:53,920 --> 00:33:56,759
lo vamos avanzando y vamos contando

803
00:33:56,759 --> 00:33:58,140
mientras no haya llegado a nul

804
00:33:58,140 --> 00:33:59,619
mientras no haya llegado a nul

805
00:33:59,619 --> 00:34:02,619
cuando haya llegado a nul, ya ha terminado

806
00:34:02,619 --> 00:34:05,339
entonces

807
00:34:05,339 --> 00:34:07,400
aquí ya simplemente

808
00:34:07,400 --> 00:34:09,820
nos hacemos nuestro nodo auxiliar

809
00:34:09,820 --> 00:34:13,510
que lo inicializamos al principio

810
00:34:13,510 --> 00:34:15,010
y ahora

811
00:34:15,010 --> 00:34:17,690
mientras aux

812
00:34:17,690 --> 00:34:19,170
sea

813
00:34:19,170 --> 00:34:21,190
diferente de null

814
00:34:21,190 --> 00:34:23,590
mientras sea diferente de null

815
00:34:23,590 --> 00:34:24,389
¿qué hacemos?

816
00:34:24,389 --> 00:34:25,809
lo avanzamos

817
00:34:25,809 --> 00:34:27,190
y contamos

818
00:34:27,190 --> 00:34:30,579
aux

819
00:34:30,579 --> 00:34:34,500
igual a aux

820
00:34:34,500 --> 00:34:36,400
punto siguiente

821
00:34:36,400 --> 00:34:36,940
siguiente

822
00:34:36,940 --> 00:34:39,940
¿vale? uy, ¿qué hago yo?

823
00:34:41,360 --> 00:34:42,260
esta es la sentencia

824
00:34:42,260 --> 00:34:44,739
y incrementamos

825
00:34:44,739 --> 00:34:45,420
la cuenta, claro

826
00:34:45,420 --> 00:34:49,150
¿vale? entonces

827
00:34:49,150 --> 00:34:52,050
si aux es null ya desde el principio

828
00:34:52,050 --> 00:34:54,570
si aux es null desde el principio es porque la lista está vacía

829
00:34:54,570 --> 00:34:56,449
¿verdad? la lista está vacía, inicia punta null

830
00:34:56,449 --> 00:34:58,510
está vacía, en ese caso

831
00:34:58,510 --> 00:35:00,349
no entrará en el while nunca

832
00:35:00,349 --> 00:35:01,389
porque aux ya es null

833
00:35:01,389 --> 00:35:04,210
y en ese caso el método también funcionará

834
00:35:04,210 --> 00:35:06,349
porque entonces me devolverá cont que es 0

835
00:35:06,349 --> 00:35:10,550
¿vale? que aux

836
00:35:10,550 --> 00:35:12,750
no es null, significa que al menos

837
00:35:12,750 --> 00:35:14,690
hay un nodo, pues ahí empezamos

838
00:35:14,690 --> 00:35:16,630
a avanzar, y ya mi

839
00:35:16,630 --> 00:35:18,610
bucle va avanzando, mientras

840
00:35:18,610 --> 00:35:19,809
aux sea diferente de null

841
00:35:19,809 --> 00:35:22,130
avánzalo y cuenta

842
00:35:22,130 --> 00:35:24,929
sigue siendo aux diferente de null

843
00:35:24,929 --> 00:35:26,789
avánzalo y cuenta

844
00:35:26,789 --> 00:35:28,650
y así

845
00:35:28,650 --> 00:35:29,250
todo el rato

846
00:35:29,250 --> 00:35:32,469
vale, bueno, parece que esto tiene sentido

847
00:35:32,469 --> 00:35:34,949
vamos a probarlo, porque aquí nos pueden haber fallado los extremos

848
00:35:34,949 --> 00:35:36,570
uy, cuidado que es una más, una menos

849
00:35:36,570 --> 00:35:38,929
lo más cómodo aquí es

850
00:35:38,929 --> 00:35:41,510
probarlo, vamos a, ah, yo lo he llamado

851
00:35:41,510 --> 00:35:43,809
de nuevo no le he puesto el public

852
00:35:43,809 --> 00:35:45,849
y además

853
00:35:45,849 --> 00:35:47,130
lo he llamado lista en vez de size

854
00:35:47,130 --> 00:35:52,739
ahora sí

855
00:35:52,739 --> 00:35:55,340
¿vale? este método, ahora el tamaño

856
00:35:55,340 --> 00:35:58,780
¿vale? pues

857
00:35:58,780 --> 00:36:02,530
ahora ya sí

858
00:36:02,530 --> 00:36:06,809
tengo mi método size, aparentemente bien

859
00:36:06,809 --> 00:36:08,849
hecho, y ya puedo recorrer

860
00:36:08,849 --> 00:36:10,730
con mi bucle for, como recorro

861
00:36:10,730 --> 00:36:12,389
la raíz, exactamente igual con mi bucle for

862
00:36:12,389 --> 00:36:14,730
desde cero, mientras sea menor que

863
00:36:14,730 --> 00:36:16,389
el total de elementos de la lista

864
00:36:16,389 --> 00:36:18,670
incrementando uno, muéstrame

865
00:36:18,670 --> 00:36:20,889
el contenido uno por uno, que lo sacas con getE.

866
00:36:22,230 --> 00:36:22,969
Vamos a ver

867
00:36:22,969 --> 00:36:24,489
si nos saca, nos tendrá que sacar

868
00:36:24,489 --> 00:36:27,110
cadena 4, cadena 3, cadena 2, cadena 1.

869
00:36:27,389 --> 00:36:28,610
Si es que lo hemos hecho bien todo.

870
00:36:30,289 --> 00:36:30,929
Vamos a ver.

871
00:36:34,150 --> 00:36:35,050
Vale, pues ahí los tenemos.

872
00:36:37,570 --> 00:36:38,809
Vale, entonces esto funciona

873
00:36:38,809 --> 00:36:39,489
como un array.

874
00:36:41,409 --> 00:36:42,449
Pero mucho más

875
00:36:42,449 --> 00:36:44,670
computacionalmente, infinitamente

876
00:36:44,670 --> 00:36:45,349
más eficiente.

877
00:36:46,989 --> 00:36:48,530
Aquí no estamos usando arrays por

878
00:36:48,530 --> 00:36:50,690
ningún lado, no los estamos usando

879
00:36:50,690 --> 00:36:52,329
y

880
00:36:52,329 --> 00:36:54,429
el efecto es

881
00:36:54,429 --> 00:36:56,590
estar usando efectivamente una estructura

882
00:36:56,590 --> 00:36:58,309
en la que yo meto, saco o no

883
00:36:58,309 --> 00:37:00,349
porque no le hemos programado el método de sacar, que es un poquito

884
00:37:00,349 --> 00:37:02,829
más complicado, recupero

885
00:37:02,829 --> 00:37:09,489
por posición, etcétera

886
00:37:09,489 --> 00:37:10,769
vale, entonces aquí claro, para

887
00:37:10,769 --> 00:37:12,869
uno hacerse ya su estructura estupenda

888
00:37:12,869 --> 00:37:15,150
pues hombre, habría cosas

889
00:37:15,150 --> 00:37:18,570
que, pues podría hacer

890
00:37:18,570 --> 00:37:19,590
un remove por posición

891
00:37:19,590 --> 00:37:22,710
pues un remove por posición

892
00:37:22,710 --> 00:37:24,949
que tú le das una posición

893
00:37:24,949 --> 00:37:28,210
y te devuelve

894
00:37:28,210 --> 00:37:31,510
o sea, te lo elimina

895
00:37:31,510 --> 00:37:32,130
de la lista

896
00:37:32,130 --> 00:37:36,519
podríamos eliminar por contenido

897
00:37:36,519 --> 00:37:42,239
también, donde tú le

898
00:37:42,239 --> 00:37:45,800
pasas un dato

899
00:37:45,800 --> 00:37:47,920
y te elimina

900
00:37:47,920 --> 00:37:49,900
el nodo o todos los nodos

901
00:37:49,900 --> 00:37:51,679
depende de la versión que tú quieras hacer

902
00:37:51,679 --> 00:37:53,539
que contienen este dato

903
00:37:53,539 --> 00:37:55,739
es una versión de remove distinta a la de arriba

904
00:37:55,739 --> 00:37:57,780
aquí estaríamos haciendo un remove

905
00:37:57,780 --> 00:37:59,380
sobrecargado, ¿vale?

906
00:37:59,380 --> 00:38:01,579
recordad que lo que era la sobrecarga

907
00:38:01,579 --> 00:38:03,519
de métodos, que eran métodos

908
00:38:03,519 --> 00:38:05,340
que se llaman igual pero son

909
00:38:05,340 --> 00:38:07,400
perfectamente distinguibles porque sus parámetros

910
00:38:07,400 --> 00:38:08,039
son distintos

911
00:38:08,039 --> 00:38:11,639
aquí este remove no se puede

912
00:38:11,639 --> 00:38:13,079
confundir con este otro

913
00:38:13,079 --> 00:38:15,559
porque a ese se le pasa un int y a ese se le pasa un string

914
00:38:15,559 --> 00:38:17,699
pues podríamos hacer esto

915
00:38:17,699 --> 00:38:20,809
¿vale? podríamos hacer

916
00:38:20,809 --> 00:38:22,230
este en realidad

917
00:38:22,230 --> 00:38:24,769
add, si lo hubiéramos

918
00:38:24,769 --> 00:38:26,730
llamado bien, lo tendríamos

919
00:38:26,730 --> 00:38:28,630
que haber llamado addFirst porque es añádelo

920
00:38:28,630 --> 00:38:30,510
pero al principio, añádelo al principio

921
00:38:30,510 --> 00:38:33,269
con lo cual esto que estamos haciendo aquí

922
00:38:33,269 --> 00:38:35,190
sería este

923
00:38:35,190 --> 00:38:39,920
sería este un nombre

924
00:38:39,920 --> 00:38:40,739
un poco más claro

925
00:38:40,739 --> 00:38:50,269
vale, bueno pues además

926
00:38:50,269 --> 00:38:51,469
del añade al principio

927
00:38:51,469 --> 00:38:54,489
esto se quedaría, esta estructura ya de datos

928
00:38:54,489 --> 00:38:56,650
se quedaría estupenda si le añadimos un método

929
00:38:56,650 --> 00:39:00,420
que sea añadir al final

930
00:39:00,420 --> 00:39:02,300
el otro

931
00:39:02,300 --> 00:39:03,239
añadir al final

932
00:39:03,239 --> 00:39:13,619
public void

933
00:39:13,619 --> 00:39:16,119
y ya si que se quedaría

934
00:39:16,119 --> 00:39:18,139
completísima y divina

935
00:39:18,139 --> 00:39:20,139
si le añadimos un

936
00:39:20,139 --> 00:39:22,800
método que sea añadir

937
00:39:22,800 --> 00:39:24,639
en la posición que yo te diga

938
00:39:24,639 --> 00:39:27,420
no al principio y al final, sino añadir en la que yo te diga

939
00:39:27,420 --> 00:39:28,880
eso ya sí que

940
00:39:28,880 --> 00:39:29,840
sería estupendo

941
00:39:29,840 --> 00:39:33,139
una versión de app que tú le pasas el dato

942
00:39:33,139 --> 00:39:40,619
tú le pasas el dato

943
00:39:40,619 --> 00:39:42,619
y le pasas una posición

944
00:39:42,619 --> 00:39:47,019
y te lo añade

945
00:39:47,019 --> 00:39:49,119
insertado en la posición

946
00:39:49,119 --> 00:39:50,500
que tú le digas, por ejemplo

947
00:39:50,500 --> 00:39:52,820
vale, así

948
00:39:52,820 --> 00:39:54,840
aquí podríamos programar esto

949
00:39:54,840 --> 00:39:55,780
ya más completito

950
00:39:55,780 --> 00:39:57,440
y ya con mi main

951
00:39:57,440 --> 00:40:00,219
yo uso esta lista

952
00:40:00,219 --> 00:40:02,039
y no tengo ni idea de cómo está hecha por dentro

953
00:40:02,039 --> 00:40:04,539
ni me importa, yo llamo a sus métodos

954
00:40:04,539 --> 00:40:06,360
llamo a los métodos de añadir

955
00:40:06,360 --> 00:40:08,659
al principio, recorrer con el

956
00:40:08,659 --> 00:40:10,519
índice, recuperar

957
00:40:10,519 --> 00:40:12,219
por posición, ahora quiero añadir al final

958
00:40:12,219 --> 00:40:14,139
pues atlas, ahora quiero borrar

959
00:40:14,139 --> 00:40:15,940
pues quiero borrar el

960
00:40:15,940 --> 00:40:18,579
de posición, lo que sea

961
00:40:18,579 --> 00:40:20,199
pues llamo a

962
00:40:20,199 --> 00:40:21,079
venga, ya está

963
00:40:21,079 --> 00:40:24,460
a borrar el de posición 1, por ejemplo

964
00:40:24,460 --> 00:40:26,900
lo que yo quiera, ahora mismo no me haría nada

965
00:40:26,900 --> 00:40:27,860
porque el método está vacío

966
00:40:27,860 --> 00:40:29,619
claro, el método está vacío y no me haría nada

967
00:40:29,619 --> 00:40:32,739
pero yo podría completar toda esta funcionalidad

968
00:40:32,739 --> 00:40:36,059
y con lo que hemos visto

969
00:40:36,059 --> 00:40:38,119
lo podéis hacer perfectamente

970
00:40:38,119 --> 00:40:40,579
porque es lo mismo que yo he hecho

971
00:40:40,579 --> 00:40:42,920
parecido, se basa en combinar

972
00:40:42,920 --> 00:40:45,360
la sentencia de avanzar con punteros auxiliares

973
00:40:45,360 --> 00:40:46,599
y ya está

974
00:40:46,599 --> 00:40:49,599
borrar por posición

975
00:40:49,599 --> 00:40:51,039
¿cómo sería?

976
00:40:51,519 --> 00:40:53,179
pues borrar por posición es un poco más complicado

977
00:40:53,179 --> 00:40:55,260
porque de nuevo es un puntero auxiliar

978
00:40:55,260 --> 00:40:57,219
que tienes que avanzar hasta la posición

979
00:40:57,219 --> 00:40:58,940
y cuando ya has llegado

980
00:40:58,940 --> 00:41:01,880
tienes que sobre, si este es el que

981
00:41:01,880 --> 00:41:03,059
hay que eliminar

982
00:41:03,059 --> 00:41:05,360
pues eliminar será puentearle

983
00:41:05,360 --> 00:41:06,760
al anterior

984
00:41:06,760 --> 00:41:09,639
asignarle la dirección de este

985
00:41:09,639 --> 00:41:12,059
así, y lo puenteas

986
00:41:12,059 --> 00:41:13,639
al apuenteado, eso será eliminar

987
00:41:13,639 --> 00:41:16,159
con un auxiliar llegar hasta el que quieras borrar

988
00:41:16,159 --> 00:41:17,860
y

989
00:41:17,860 --> 00:41:19,880
luego a este puntero

990
00:41:19,880 --> 00:41:20,860
darle su siguiente

991
00:41:20,860 --> 00:41:22,940
darle su siguiente, asignárselo

992
00:41:22,940 --> 00:41:24,079
pues lo ha esponteado

993
00:41:24,079 --> 00:41:26,000
entonces no es

994
00:41:26,000 --> 00:41:28,820
difícil de programar, lo podéis hacer

995
00:41:28,820 --> 00:41:30,360
el de añadir al final

996
00:41:30,360 --> 00:41:33,019
añadir al final, habrá que hacer de nuevo

997
00:41:33,019 --> 00:41:33,960
un puntero auxiliar

998
00:41:33,960 --> 00:41:37,059
o sea, la parte de añadir, habrá que crear un nodo

999
00:41:37,059 --> 00:41:38,579
eso está claro, un nodo como aquí

1000
00:41:38,579 --> 00:41:41,239
en el añadir al principio, un nodo y darle el dato

1001
00:41:41,239 --> 00:41:43,099
pero luego ya

1002
00:41:43,099 --> 00:41:44,320
habrá que con un auxiliar

1003
00:41:44,320 --> 00:41:45,940
navegar hasta el final

1004
00:41:45,940 --> 00:41:48,460
y cuando ya ha llegado al final, a este

1005
00:41:48,460 --> 00:41:52,320
a este ya darle la dirección

1006
00:41:52,320 --> 00:41:52,760
del nuevo.

1007
00:41:53,980 --> 00:41:55,719
Una sentencia de asignación, nada más.

1008
00:41:56,500 --> 00:41:56,940
Nada más.

1009
00:41:58,400 --> 00:42:00,199
Bueno, pues yo querría que hicierais

1010
00:42:00,199 --> 00:42:01,500
estos métodos que faltan.

1011
00:42:02,800 --> 00:42:04,340
¿Vale? Queréis estos métodos

1012
00:42:04,340 --> 00:42:11,179
que faltan. Bueno, pues esta

1013
00:42:11,179 --> 00:42:13,199
estructura de datos ya existe, ya está hecha.

1014
00:42:13,719 --> 00:42:15,059
Y está hecha como la hemos hecho

1015
00:42:15,059 --> 00:42:16,699
nosotros. Punto pelota.

1016
00:42:17,360 --> 00:42:19,099
¿Vale? Se llama de otra manera, pero

1017
00:42:19,099 --> 00:42:19,639
ya está hecha.

1018
00:42:20,820 --> 00:42:22,920
Esta en particular se llama Linked List

1019
00:42:22,920 --> 00:42:24,960
o en lista enlazada en inglés, nos da lo mismo

1020
00:42:24,960 --> 00:42:26,179
vale

1021
00:42:26,179 --> 00:42:29,349
bueno, a ver

1022
00:42:29,349 --> 00:42:31,610
enteraos todo el mundo

1023
00:42:31,610 --> 00:42:35,619
¿lo pilláis? ¿cogido?

1024
00:42:37,579 --> 00:42:38,699
bueno, cuando

1025
00:42:38,699 --> 00:42:41,420
al menos tratad de hacer

1026
00:42:41,420 --> 00:42:45,699
alguno de los cuatro

1027
00:42:45,699 --> 00:42:47,579
con que alguno de los cuatro

1028
00:42:47,579 --> 00:42:48,300
los hagáis

1029
00:42:48,300 --> 00:42:50,559
vosotros ya

1030
00:42:50,559 --> 00:42:52,860
os va a ser suficiente

1031
00:42:52,860 --> 00:42:55,159
para entender del todo lo que hemos hecho arriba

1032
00:42:55,159 --> 00:42:57,920
con que alguno de los 4 ya lo hagáis votos de 0

1033
00:42:57,920 --> 00:43:00,920
este get por ejemplo

1034
00:43:00,920 --> 00:43:03,619
se ha quedado

1035
00:43:03,619 --> 00:43:06,119
no le he verificado errores

1036
00:43:06,119 --> 00:43:07,980
imagínate que le damos una posición

1037
00:43:07,980 --> 00:43:09,099
mayor

1038
00:43:09,099 --> 00:43:10,699
que la que existe

1039
00:43:10,699 --> 00:43:13,239
por ejemplo imaginaos que en este main de aquí

1040
00:43:13,239 --> 00:43:15,340
en este main

1041
00:43:15,340 --> 00:43:16,500
yo digo

1042
00:43:16,500 --> 00:43:19,059
yo tengo solo 4 y de repente digo

1043
00:43:19,059 --> 00:43:20,179
recupérame las 7

1044
00:43:20,179 --> 00:43:22,719
que creéis que va a salir aquí abajo

1045
00:43:22,719 --> 00:43:25,619
justo

1046
00:43:25,619 --> 00:43:27,900
efectivamente me va a salir

1047
00:43:27,900 --> 00:43:30,039
un null pointer exception, ¿por qué?

1048
00:43:30,900 --> 00:43:31,300
porque

1049
00:43:31,300 --> 00:43:36,980
este va a estar avanzando, va a estar avanzando

1050
00:43:36,980 --> 00:43:38,239
la lista se va a acabar

1051
00:43:38,239 --> 00:43:40,219
y esto va a ser null

1052
00:43:40,219 --> 00:43:43,320
y va a tratar de hacer un siguiente de algo que ya es null

1053
00:43:43,320 --> 00:43:45,539
porque ya ha terminado

1054
00:43:45,539 --> 00:43:45,980
la lista

1055
00:43:45,980 --> 00:43:48,659
y entonces aquí cuando trate de hacer

1056
00:43:48,659 --> 00:43:51,400
un acceso a siguiente de algo que es null

1057
00:43:51,400 --> 00:43:52,559
va a decir null pointer exception

1058
00:43:52,559 --> 00:43:54,300
entonces hombre, este método get

1059
00:43:54,300 --> 00:43:56,420
se quedaría mucho mejor si decimos

1060
00:43:56,420 --> 00:44:06,900
Oye, si la posición que me pasas es mayor que el tamaño, retún, retún nul, devuélveme nul porque no tienes nada. No, o sea, esto, si yo le pongo aquí esto, sería mucho mejor.

1061
00:44:06,900 --> 00:44:09,539
si la posición que me pasas

1062
00:44:09,539 --> 00:44:11,840
resulta que es mayor

1063
00:44:11,840 --> 00:44:13,139
que

1064
00:44:13,139 --> 00:44:15,739
el tamaño de la lista

1065
00:44:15,739 --> 00:44:17,900
y afortunadamente tengo el método

1066
00:44:17,900 --> 00:44:18,860
size que me lo dice

1067
00:44:18,860 --> 00:44:20,659
en ese caso

1068
00:44:20,659 --> 00:44:23,860
si la posición

1069
00:44:23,860 --> 00:44:26,199
es mayor que el tamaño de la lista

1070
00:44:26,199 --> 00:44:27,400
pues en ese caso mira

1071
00:44:27,400 --> 00:44:29,179
fuera

1072
00:44:29,179 --> 00:44:31,460
return null

1073
00:44:31,460 --> 00:44:33,860
devuélveme el contenido

1074
00:44:33,860 --> 00:44:34,980
string que sea null

1075
00:44:34,980 --> 00:44:38,940
entonces esto mayor o mayor que menos 1

1076
00:44:38,940 --> 00:44:39,320
porque

1077
00:44:39,320 --> 00:44:42,500
10.6 y la lista tiene

1078
00:44:42,500 --> 00:44:43,739
4

1079
00:44:43,739 --> 00:44:45,639
10.6 es 4

1080
00:44:45,639 --> 00:44:48,380
y posición solamente tiene que ser

1081
00:44:48,380 --> 00:44:50,820
0, 1, 2 o 3, con lo cual esto sería mayor o igual

1082
00:44:50,820 --> 00:44:51,059
¿verdad?

1083
00:44:51,860 --> 00:44:53,719
si posición es mayor o igual que 6

1084
00:44:53,719 --> 00:44:56,019
entonces esa posición no existe

1085
00:44:56,019 --> 00:44:58,500
porque solo existen desde 0 hasta 6 menos 1

1086
00:44:58,500 --> 00:45:01,320
solo existen desde 0 hasta 6 menos 1

1087
00:45:01,320 --> 00:45:03,260
entonces si es mayor o igual

1088
00:45:03,260 --> 00:45:04,460
lo siento

1089
00:45:04,460 --> 00:45:07,199
Entonces ahora ya

1090
00:45:07,199 --> 00:45:09,059
Si ejecutamos este main

1091
00:45:09,059 --> 00:45:12,139
Aquí no voy a dar null pointer exceptio

1092
00:45:12,139 --> 00:45:14,199
Me va a mostrar null porque ese valor tiene null

1093
00:45:14,199 --> 00:45:16,199
Claro, pero no me va a dar null pointer exceptio

1094
00:45:16,199 --> 00:45:17,340
Me va a decir, hay null

1095
00:45:17,340 --> 00:45:19,800
En la posición 7 hay null, no hay nada

1096
00:45:19,800 --> 00:45:21,280
Vale

1097
00:45:21,280 --> 00:45:30,449
Bueno

1098
00:45:30,449 --> 00:45:33,909
Vamos a parar aquí un segundin

1099
00:45:33,909 --> 00:45:35,449
¿Vale?

1100
00:45:37,449 --> 00:45:38,230
Venga, pues