1
00:00:00,000 --> 00:00:12,350
>> [REPRODUCCIÓN DE MÚSICA]

2
00:00:12,350 --> 00:00:13,050
>> ROB BOWDEN: Hi.

3
00:00:13,050 --> 00:00:13,640
Soy Rob.

4
00:00:13,640 --> 00:00:16,210
Y vamos a salir de esta solución.

5
00:00:16,210 --> 00:00:20,070
Así que aquí vamos a poner en práctica
una tabla general.

6
00:00:20,070 --> 00:00:24,090
Vemos que el nodo de estructura de nuestra
tabla va a tener este aspecto.

7
00:00:24,090 --> 00:00:28,710
Así que va a tener una palabra caracteres
matriz de tamaño LONGITUD + 1.

8
00:00:28,710 --> 00:00:32,259
No se olvide el + 1, ya que la máxima
palabra en el diccionario es 45

9
00:00:32,259 --> 00:00:33,130
personajes.

10
00:00:33,130 --> 00:00:37,070
Y luego vamos a necesitar una extra
carácter para el cero barra invertida.

11
00:00:37,070 --> 00:00:40,870
>> Y entonces nuestra tabla hash en cada
cubo se va a almacenar un

12
00:00:40,870 --> 00:00:42,320
lista enlazada de nodos.

13
00:00:42,320 --> 00:00:44,420
No estamos haciendo el sondeo lineal aquí.

14
00:00:44,420 --> 00:00:48,430
Y así, con el fin de vincular a la siguiente
elemento en el cubo, necesitamos un

15
00:00:48,430 --> 00:00:50,390
struct nodo * siguiente.

16
00:00:50,390 --> 00:00:51,110
Aceptar.

17
00:00:51,110 --> 00:00:53,090
Así que eso es lo que un nodo se parece.

18
00:00:53,090 --> 00:00:56,180
>> Ahora aquí es la declaración
de nuestra tabla hash.

19
00:00:56,180 --> 00:00:59,640
Va a tener 16.834 baldes.

20
00:00:59,640 --> 00:01:01,910
Pero ese número en realidad no importa.

21
00:01:01,910 --> 00:01:05,450
Y, por último, vamos a tener la
El tamaño de la tabla hash variable global, que

22
00:01:05,450 --> 00:01:07,000
va a empezar como cero.

23
00:01:07,000 --> 00:01:10,760
Y se va a realizar un seguimiento de cómo
muchas palabras están en el diccionario.

24
00:01:10,760 --> 00:01:13,710
>> Así que echemos un vistazo a la carga.

25
00:01:13,710 --> 00:01:16,390
Tenga en cuenta que la carga, devuelve un bool.

26
00:01:16,390 --> 00:01:20,530
Se vuelve verdad si fue con éxito
cargado, y false en caso contrario.

27
00:01:20,530 --> 00:01:23,990
Y toma un char * const diccionario,
que es el diccionario

28
00:01:23,990 --> 00:01:25,280
que queremos abrir.

29
00:01:25,280 --> 00:01:27,170
Así que eso es lo primero
que vamos a hacer.

30
00:01:27,170 --> 00:01:29,500
>> Vamos a fopen la
diccionario para leer.

31
00:01:29,500 --> 00:01:31,680
Y vamos a tener que hacer
seguro de que sucedió.

32
00:01:31,680 --> 00:01:35,920
Así que si es devuelto NULL, entonces nosotros no lo hicimos
abrir correctamente el diccionario.

33
00:01:35,920 --> 00:01:37,440
Y tenemos que devolver false.

34
00:01:37,440 --> 00:01:41,580
Pero suponiendo que lo hizo con éxito
abierto, entonces queremos leer la

35
00:01:41,580 --> 00:01:42,400
diccionario.

36
00:01:42,400 --> 00:01:46,450
Así seguirá sonando hasta que encontremos alguna
razón para salir de este bucle,

37
00:01:46,450 --> 00:01:47,570
que ya veremos.

38
00:01:47,570 --> 00:01:48,920
Así seguirá sonando.

39
00:01:48,920 --> 00:01:51,780
>> Y ahora vamos a
malloc un solo nodo.

40
00:01:51,780 --> 00:01:54,020
Y por supuesto que necesitamos
ventilar puedes volver a intentarlo.

41
00:01:54,020 --> 00:01:58,680
Así que si mallocing no tuvo éxito, a continuación,
queremos descargar cualquier nodo que

42
00:01:58,680 --> 00:02:02,590
pasó a malloc antes, cierre la
diccionario y devolver false.

43
00:02:02,590 --> 00:02:06,830
Pero haciendo caso omiso de eso, suponiendo
tenido éxito, entonces queremos usar fscanf

44
00:02:06,830 --> 00:02:12,400
para leer una sola palabra de nuestro
diccionario de a nuestro nodo.

45
00:02:12,400 --> 00:02:17,940
Así que recuerde que la entrada> palabra es el carbón de leña
búfer palabra de tamaño lenghth + 1

46
00:02:17,940 --> 00:02:20,300
que vamos a guardar la palabra pulg

47
00:02:20,300 --> 00:02:25,070
>> Así fscanf va a regresar 1, siempre y
ya que fue capaz de éxito

48
00:02:25,070 --> 00:02:26,750
leer una palabra del archivo.

49
00:02:26,750 --> 00:02:30,460
Si sucede, ya sea un error, o que
llegar al final del archivo, se

50
00:02:30,460 --> 00:02:31,950
no devolverá 1.

51
00:02:31,950 --> 00:02:35,180
En cuyo caso no devuelve 1,
finalmente vamos a salir de

52
00:02:35,180 --> 00:02:37,280
este bucle while.

53
00:02:37,280 --> 00:02:42,770
Así que vemos que una vez que tengamos éxito
leer una palabra en

54
00:02:42,770 --> 00:02:48,270
entrada> palabra, entonces vamos a la
palabra utilizando nuestra función hash.

55
00:02:48,270 --> 00:02:49,580
>> Echemos un vistazo a
la función hash.

56
00:02:49,580 --> 00:02:52,430

57
00:02:52,430 --> 00:02:55,610
Así que usted realmente no necesita
para entender esto.

58
00:02:55,610 --> 00:02:59,460
Y en realidad nos detuvimos este hash
funcionar desde internet.

59
00:02:59,460 --> 00:03:04,010
La única cosa que hay que reconocer es
que esto toma un char * palabra const.

60
00:03:04,010 --> 00:03:08,960
Así que ha de tomar una cadena como entrada, y
devolver un int sin signo como salida.

61
00:03:08,960 --> 00:03:12,360
Así que eso es todo, una función hash es, ¿es
toma en una entrada y le da una

62
00:03:12,360 --> 00:03:14,490
índice en la tabla hash.

63
00:03:14,490 --> 00:03:18,530
>> Nótese que estamos moding por NUM_BUCKETS,
de manera que el valor devuelto

64
00:03:18,530 --> 00:03:21,730
en realidad es un índice en la tabla hash
y no indexa más allá de la

65
00:03:21,730 --> 00:03:24,320
límites de la matriz.

66
00:03:24,320 --> 00:03:28,060
Así que teniendo en cuenta que la función, vamos
para discutir la palabra que leemos la

67
00:03:28,060 --> 00:03:29,390
diccionario.

68
00:03:29,390 --> 00:03:31,700
Y luego vamos a usar
el hash para insertar el

69
00:03:31,700 --> 00:03:33,750
entrada en la tabla hash.

70
00:03:33,750 --> 00:03:38,520
>> Picadillo Ahora hashtable es la corriente
lista vinculada en la tabla.

71
00:03:38,520 --> 00:03:41,410
Y es muy posible
que es sólo NULL.

72
00:03:41,410 --> 00:03:44,960
Queremos insertar nuestra entrada en el
a partir de esta lista enlazada.

73
00:03:44,960 --> 00:03:48,600
Así que vamos a tener nuestra actual
punto de entrada a lo que la tabla hash

74
00:03:48,600 --> 00:03:50,380
Actualmente señala.

75
00:03:50,380 --> 00:03:53,310
Y luego vamos a almacenar,
en la tabla hash en el

76
00:03:53,310 --> 00:03:55,350
hash, la entrada actual.

77
00:03:55,350 --> 00:03:59,320
Así pues, estas dos líneas se insertan con éxito
la entrada al principio de la

78
00:03:59,320 --> 00:04:02,260
lista enlazada en ese índice
en la tabla hash.

79
00:04:02,260 --> 00:04:04,900
>> Una vez que hemos terminado con eso, sabemos
que encontramos otra palabra en el

80
00:04:04,900 --> 00:04:07,790
diccionario, y incrementamos de nuevo.

81
00:04:07,790 --> 00:04:13,960
Así que seguimos haciendo eso hasta fscanf
finalmente regresó algo no 1 en

82
00:04:13,960 --> 00:04:16,950
cuyo punto recordar que
tenemos que liberar a la entrada.

83
00:04:16,950 --> 00:04:19,459
Así que aquí tenemos malloced una entrada.

84
00:04:19,459 --> 00:04:21,329
Y tratamos de leer algo
del diccionario.

85
00:04:21,329 --> 00:04:23,910
Y no nos leemos con éxito
algo del diccionario, en

86
00:04:23,910 --> 00:04:26,650
cuyo caso tenemos que liberar la entrada
que en realidad nunca ponemos en el

87
00:04:26,650 --> 00:04:29,140
tabla hash, y finalmente romper.

88
00:04:29,140 --> 00:04:32,750
>> Una vez que rompemos tenemos que ver, bueno,
qué nos separamos porque hay

89
00:04:32,750 --> 00:04:34,360
estaba leyendo un error desde el archivo?

90
00:04:34,360 --> 00:04:37,120
¿O qué nos separamos porque nos
alcanzado el final del archivo?

91
00:04:37,120 --> 00:04:39,480
Si hubo un error, a continuación,
queremos devolver false.

92
00:04:39,480 --> 00:04:40,930
Debido a que la carga no tuvo éxito.

93
00:04:40,930 --> 00:04:43,890
Y en el proceso que queremos descargar
todas las palabras que leemos en, y

94
00:04:43,890 --> 00:04:45,670
cerrar el archivo de diccionario.

95
00:04:45,670 --> 00:04:48,740
>> Asumiendo que tuvimos éxito, entonces sólo
todavía tienen que cerrar el diccionario

96
00:04:48,740 --> 00:04:53,040
presentar, y finalmente de vuelta verdad ya que
cargó correctamente el diccionario.

97
00:04:53,040 --> 00:04:54,420
Y eso es todo por la carga.

98
00:04:54,420 --> 00:04:59,020
Así que ahora comprobar, dada una tabla hash cargado,
que va a tener este aspecto.

99
00:04:59,020 --> 00:05:03,140
A fin de comprobar, devuelve un bool, que es
va a indicar si la pasar

100
00:05:03,140 --> 00:05:07,530
en char * palabra, si el pasado
en la cadena está en el diccionario.

101
00:05:07,530 --> 00:05:09,890
Así que si está en el diccionario,
si está en nuestra tabla hash,

102
00:05:09,890 --> 00:05:11,170
vamos a volver realidad.

103
00:05:11,170 --> 00:05:13,380
Y si no es así, vamos a devolver false.

104
00:05:13,380 --> 00:05:17,740
>> Teniendo en cuenta esto pasó en la palabra, estamos
ir para discutir la palabra.

105
00:05:17,740 --> 00:05:22,110
Ahora una cosa importante a reconocer es
que en la carga que sabíamos que toda la

106
00:05:22,110 --> 00:05:23,820
palabras que vamos a estar en minúsculas.

107
00:05:23,820 --> 00:05:25,820
Pero aquí no estamos tan seguros.

108
00:05:25,820 --> 00:05:29,510
Si echamos un vistazo a nuestra función hash,
nuestra función hash realidad

109
00:05:29,510 --> 00:05:32,700
es la caja inferior de cada personaje
de la palabra.

110
00:05:32,700 --> 00:05:37,940
Así que, independientemente de la capitalización de
palabra, nuestra función hash es el retorno

111
00:05:37,940 --> 00:05:42,270
el mismo índice para lo que el
capitalización es, ya que tendría

112
00:05:42,270 --> 00:05:45,280
regresado para una completamente en minúsculas
versión de la palabra.

113
00:05:45,280 --> 00:05:46,600
De acuerdo.

114
00:05:46,600 --> 00:05:49,790
Ese es nuestro índice está en el
tabla hash para esta palabra.

115
00:05:49,790 --> 00:05:52,940
>> Ahora bien, este bucle se va a
iterar sobre la lista enlazada

116
00:05:52,940 --> 00:05:55,000
que era en ese índice.

117
00:05:55,000 --> 00:05:59,610
Así notamos que estamos inicializando entrada
para señalar a ese índice.

118
00:05:59,610 --> 00:06:02,750
Vamos a continuar
cuando! entrada = NULL.

119
00:06:02,750 --> 00:06:07,770
Y recuerda que la actualización del puntero
en nuestra lista de inscritos vinculados = entrada> siguiente.

120
00:06:07,770 --> 00:06:14,400
Así que tenemos nuestro punto de entrada actual para
el siguiente elemento de la lista enlazada.

121
00:06:14,400 --> 00:06:19,250
>> Así que para cada entrada de la lista enlazada,
vamos a utilizar strcasecmp.

122
00:06:19,250 --> 00:06:20,330
No es StrComp.

123
00:06:20,330 --> 00:06:23,780
Porque, una vez más, queremos
hacer si las cosas minúsculas.

124
00:06:23,780 --> 00:06:27,870
Así que usamos strcasecmp comparar la
palabra que se ha pasado a través de este

125
00:06:27,870 --> 00:06:31,860
función en contra de la palabra
lo que hay en esta entrada.

126
00:06:31,860 --> 00:06:35,570
Si devuelve cero, que significa que hubo
un partido, en el que caso de que queramos

127
00:06:35,570 --> 00:06:36,630
return true.

128
00:06:36,630 --> 00:06:39,590
Nos encontramos con éxito el
palabra en nuestra tabla hash.

129
00:06:39,590 --> 00:06:43,040
>> Si no había un partido, entonces estamos
ir a la vuelta de nuevo y mirar el

130
00:06:43,040 --> 00:06:43,990
siguiente entrada.

131
00:06:43,990 --> 00:06:47,640
Y continuaremos bucle mientras que hay
son entradas de esta lista enlazada.

132
00:06:47,640 --> 00:06:50,160
¿Qué sucede si rompemos
fuera de este bucle?

133
00:06:50,160 --> 00:06:55,110
Eso significa que no encontramos una entrada que
emparejado esta palabra, en cuyo caso

134
00:06:55,110 --> 00:07:00,220
volvemos false para indicar que nuestra
tabla hash no contiene esta palabra.

135
00:07:00,220 --> 00:07:02,540
Y eso es un cheque.

136
00:07:02,540 --> 00:07:04,790
>> Así que echemos un vistazo a tamaño.

137
00:07:04,790 --> 00:07:06,970
Ahora el tamaño va a ser bastante simple.

138
00:07:06,970 --> 00:07:11,080
Dado que recordar en la carga, para cada palabra
encontramos, hemos incrementado un mundial

139
00:07:11,080 --> 00:07:12,880
El tamaño de la tabla hash variable.

140
00:07:12,880 --> 00:07:16,480
Así que la función de tamaño es sólo va
volver variable global.

141
00:07:16,480 --> 00:07:18,150
Y eso es todo.

142
00:07:18,150 --> 00:07:22,300
>> Ahora, por fin, tenemos que descargar el
diccionario una vez que todo está hecho.

143
00:07:22,300 --> 00:07:25,340
Entonces, ¿cómo vamos a hacer eso?

144
00:07:25,340 --> 00:07:30,440
Aquí estamos bucle sobre
todos los cubos de nuestra mesa.

145
00:07:30,440 --> 00:07:33,240
Así que hay NUM_BUCKETS cubos.

146
00:07:33,240 --> 00:07:37,410
Y para cada lista enlazada en nuestra
tabla hash, que vamos a reproducir indefinidamente

147
00:07:37,410 --> 00:07:41,070
la totalidad de la lista enlazada,
la liberación de cada elemento.

148
00:07:41,070 --> 00:07:42,900
>> Ahora tenemos que tener cuidado.

149
00:07:42,900 --> 00:07:47,910
Así que aquí tenemos una variable temporal
eso es almacenar el puntero a la siguiente

150
00:07:47,910 --> 00:07:49,730
elemento de la lista enlazada.

151
00:07:49,730 --> 00:07:52,140
Y luego vamos a la libre
el elemento actual.

152
00:07:52,140 --> 00:07:55,990
Tenemos que estar seguros de que hacemos esto desde que
no puede simplemente liberar el elemento actual

153
00:07:55,990 --> 00:07:59,180
y luego tratar de acceder a la siguiente puntero,
ya que una vez que nos hemos liberado él,

154
00:07:59,180 --> 00:08:00,870
la memoria no es válida.

155
00:08:00,870 --> 00:08:04,990
>> Así que tenemos que mantener en torno a un puntero a
el siguiente elemento, entonces podemos liberar el

156
00:08:04,990 --> 00:08:08,360
elemento actual, y entonces podemos actualizar
nuestra elemento actual para apuntar a

157
00:08:08,360 --> 00:08:09,550
el siguiente elemento.

158
00:08:09,550 --> 00:08:12,800
Vamos bucle while hay elementos
en esta lista enlazada.

159
00:08:12,800 --> 00:08:15,620
Haremos eso para todos ellos vinculados
listas en la tabla hash.

160
00:08:15,620 --> 00:08:19,460
Y una vez que hayamos terminado con eso, hemos
completamente descargada la tabla hash, y

161
00:08:19,460 --> 00:08:20,190
hemos terminado.

162
00:08:20,190 --> 00:08:23,200
Así que es imposible para descarga
para volver jamás falsa.

163
00:08:23,200 --> 00:08:26,470
Y cuando terminemos, nos
simplemente devuelva true.

164
00:08:26,470 --> 00:08:29,000
>> Vamos a dar a esta solución una oportunidad.

165
00:08:29,000 --> 00:08:33,070
Así que echemos un vistazo a lo nuestro
struct nodo se verá así.

166
00:08:33,070 --> 00:08:36,220
Aquí vemos que vamos a tener un bool
palabra y un nodo de estructura * niños

167
00:08:36,220 --> 00:08:37,470
ALFABETO soporte.

168
00:08:37,470 --> 00:08:38,929

169
00:08:38,929 --> 00:08:42,020
Así que la primera cosa que usted puede ser
preguntándose, ¿por qué es ALFABETO

170
00:08:42,020 --> 00:08:44,660
ed define como 27?

171
00:08:44,660 --> 00:08:47,900
Bueno, recuerde que nosotros vamos a necesitar
estar manejando el apóstrofe.

172
00:08:47,900 --> 00:08:51,910
Así que va a ser algo así como un
caso especial lo largo de este programa.

173
00:08:51,910 --> 00:08:54,710
>> Ahora recuerda cómo un trie
en realidad funciona.

174
00:08:54,710 --> 00:08:59,380
Digamos que estamos indexando la palabra
"gatos". Luego, desde la raíz del trie,

175
00:08:59,380 --> 00:09:02,610
vamos a mirar a los niños
matriz, y vamos a mirar el

176
00:09:02,610 --> 00:09:08,090
índice que corresponde a la letra
C. Así que será indexada 2.

177
00:09:08,090 --> 00:09:11,530
Así que teniendo en cuenta que, que la voluntad
darnos un nuevo nodo.

178
00:09:11,530 --> 00:09:13,820
Y luego vamos a trabajar a partir de ese nodo.

179
00:09:13,820 --> 00:09:17,770
>> Así que teniendo en cuenta que el nodo, estamos una vez más
va a mirar la matriz niños.

180
00:09:17,770 --> 00:09:22,110
Y vamos a buscar en el índice cero
para corresponder a la A en el gato.

181
00:09:22,110 --> 00:09:27,170
Así que vamos a ir a ese nodo,
y dado que el nodo que vamos

182
00:09:27,170 --> 00:09:31,090
para mirar la final es una corresponde
T. Y de pasar a ese nodo,

183
00:09:31,090 --> 00:09:35,530
por último, nos hemos mirado por completo
a través de nuestra palabra "gato". Y ahora bool

184
00:09:35,530 --> 00:09:40,960
palabra se supone que indica si
esta palabra dada es en realidad una palabra.

185
00:09:40,960 --> 00:09:43,470
>> Entonces, ¿por qué necesitamos ese caso especial?

186
00:09:43,470 --> 00:09:47,700
Pues lo de la palabra "catástrofe"
es en el diccionario, pero el

187
00:09:47,700 --> 00:09:50,150
palabra "gato" no lo es?

188
00:09:50,150 --> 00:09:54,580
Así y mirando para ver si la palabra "gato"
está en el diccionario, estamos

189
00:09:54,580 --> 00:09:59,970
va a parecer con éxito a través
los índices de C-A-T en nodo región.

190
00:09:59,970 --> 00:10:04,290
Pero eso es sólo porque la catástrofe
sucedido para crear nodos en el camino

191
00:10:04,290 --> 00:10:07,190
a partir de C-A-T, todo el camino a
el final de la palabra.

192
00:10:07,190 --> 00:10:12,020
Así bool palabra se utiliza para indicar si
este lugar en particular

193
00:10:12,020 --> 00:10:14,310
indica, en realidad una palabra.

194
00:10:14,310 --> 00:10:15,140
>> Está bien.

195
00:10:15,140 --> 00:10:19,310
Así que ahora que sabemos lo que es trie
va a parecer, echemos un vistazo a la

196
00:10:19,310 --> 00:10:20,730
función de la carga.

197
00:10:20,730 --> 00:10:24,610
Así que la carga va a devolver un bool
Porque si estamos con éxito o

198
00:10:24,610 --> 00:10:26,720
sin éxito cargado el diccionario.

199
00:10:26,720 --> 00:10:30,460
Y esto va a ser el diccionario
que queremos cargar.

200
00:10:30,460 --> 00:10:33,930
>> Así que lo primero que tenemos que hacer es abrir
hasta ese diccionario para leer.

201
00:10:33,930 --> 00:10:36,160
Y tenemos que asegurarnos
nosotros no fallamos.

202
00:10:36,160 --> 00:10:39,580
Así que si el diccionario no era
abierto con éxito, devolverá

203
00:10:39,580 --> 00:10:42,400
nulo, en cuyo caso estamos
va a devolver false.

204
00:10:42,400 --> 00:10:47,230
Pero suponiendo que éxito
abierto, entonces podemos realmente leer

205
00:10:47,230 --> 00:10:48,220
a través del diccionario.

206
00:10:48,220 --> 00:10:50,880
>> Así que lo primero que vamos a
queremos hacer es que tenemos esta

207
00:10:50,880 --> 00:10:52,500
raíz variable global.

208
00:10:52,500 --> 00:10:56,190
Ahora raíz va a ser un nodo *.

209
00:10:56,190 --> 00:10:59,760
Es la cima de nuestra trie que estamos
va a recorrer en iteración.

210
00:10:59,760 --> 00:11:02,660
Así que lo primero que vamos
a querer hacer es asignar

211
00:11:02,660 --> 00:11:04,140
memoria para nuestra raíz.

212
00:11:04,140 --> 00:11:07,980
Nótese que estamos usando la calloc
función, que es básicamente la misma

213
00:11:07,980 --> 00:11:11,500
como la función malloc, excepto que es
garantizado para devolver algo que es

214
00:11:11,500 --> 00:11:13,180
completamente llevado a cero.

215
00:11:13,180 --> 00:11:17,290
Así que si usamos malloc, necesitaríamos
pasar por todos los punteros en nuestra

216
00:11:17,290 --> 00:11:20,160
nodo, y asegúrese de que
son todos nulos.

217
00:11:20,160 --> 00:11:22,710
Así calloc lo hará por nosotros.

218
00:11:22,710 --> 00:11:26,330
>> Ahora como malloc, tenemos que hacer
Asegúrese de que la asignación fue en realidad

219
00:11:26,330 --> 00:11:27,520
exitosa.

220
00:11:27,520 --> 00:11:29,990
Si esto devuelve null, entonces
tenga que cerrar o diccionario

221
00:11:29,990 --> 00:11:32,100
presentar y devolver false.

222
00:11:32,100 --> 00:11:36,835
Así que asumiendo que la asignación se
éxito, vamos a utilizar un nodo *

223
00:11:36,835 --> 00:11:40,270
cursor para recorrer nuestra trie.

224
00:11:40,270 --> 00:11:43,890
Así que nuestras raíces nunca va a cambiar,
pero vamos a usar el cursor para

225
00:11:43,890 --> 00:11:47,875
en realidad ir de un nodo a otro.

226
00:11:47,875 --> 00:11:50,940
>> Así que en este bucle que estamos leyendo
a través del archivo de diccionario.

227
00:11:50,940 --> 00:11:53,670
Y estamos usando fgetc.

228
00:11:53,670 --> 00:11:56,290
Fgetc va a agarrar un solo
carácter del archivo.

229
00:11:56,290 --> 00:11:59,370
Vamos a continuar con el acaparamiento
caracteres, mientras que no llegan hasta la

230
00:11:59,370 --> 00:12:01,570
final del archivo.

231
00:12:01,570 --> 00:12:03,480
>> Hay dos casos que tenemos que manejar.

232
00:12:03,480 --> 00:12:06,610
El primero, si el carácter
no era una nueva línea.

233
00:12:06,610 --> 00:12:10,450
Así que sabemos que si era una nueva línea, a continuación,
estamos a punto de pasar a una nueva palabra.

234
00:12:10,450 --> 00:12:15,240
Pero suponiendo que no era una nueva línea, a continuación,
aquí queremos averiguar el

235
00:12:15,240 --> 00:12:18,380
Índice vamos a índice en
en la matriz de los niños que

236
00:12:18,380 --> 00:12:19,810
mirábamos antes.

237
00:12:19,810 --> 00:12:23,880
>> Así que, como he dicho antes, tenemos que
caso especial el apóstrofe.

238
00:12:23,880 --> 00:12:26,220
Nótese que estamos usando el ternario
operador de aquí.

239
00:12:26,220 --> 00:12:29,580
Así que vamos a leer esto, ya que si
el carácter se lee en una era

240
00:12:29,580 --> 00:12:35,330
apóstrofe, a continuación, vamos a establecer
index = "alfabeto" -1, que se

241
00:12:35,330 --> 00:12:37,680
ser el índice 26.

242
00:12:37,680 --> 00:12:41,130
>> Si no, si no fuera un apóstrofe, no
vamos a establecer el índice

243
00:12:41,130 --> 00:12:43,760
igual a c - a.

244
00:12:43,760 --> 00:12:49,030
Así que recuerde volver de previamente p-series,
c - a que nos va a dar la

245
00:12:49,030 --> 00:12:53,410
posición alfabética de C. Así que si
C es la letra A, esto se

246
00:12:53,410 --> 00:12:54,700
darnos el índice cero.

247
00:12:54,700 --> 00:12:58,120
Porque la letra B, se le dará
nos el índice 1, y así sucesivamente.

248
00:12:58,120 --> 00:13:03,010
>> Así que esto nos da el índice en la
hijos matriz que queremos.

249
00:13:03,010 --> 00:13:08,890
Ahora bien, si este índice es actualmente nula en
los niños, que significa que un nodo

250
00:13:08,890 --> 00:13:11,830
no existe en la actualidad
de ese camino.

251
00:13:11,830 --> 00:13:15,160
Así que tenemos que asignar
un nodo para ese camino.

252
00:13:15,160 --> 00:13:16,550
Eso es lo que vamos a hacer aquí.

253
00:13:16,550 --> 00:13:20,690
>> Así que vamos a utilizar de nuevo el calloc
función, por lo que no tiene que

254
00:13:20,690 --> 00:13:22,880
cero todos los punteros.

255
00:13:22,880 --> 00:13:27,240
Y de nuevo tenemos que comprobar
que calloc no falló.

256
00:13:27,240 --> 00:13:30,700
Si calloc dejó, entonces necesitamos
para descargar todo, cerrar nuestra

257
00:13:30,700 --> 00:13:32,820
diccionario, y devolver false.

258
00:13:32,820 --> 00:13:40,050
Así que suponiendo que no falló, entonces
esto creará un nuevo hijo para nosotros.

259
00:13:40,050 --> 00:13:41,930
Y luego vamos a ir a ese niño.

260
00:13:41,930 --> 00:13:44,960
Nuestro cursor iterará
a ese niño.

261
00:13:44,960 --> 00:13:49,330
>> Ahora bien, si esto no era nulo, para empezar,
a continuación, el cursor sólo se puede repetir

262
00:13:49,330 --> 00:13:52,590
a ese niño sin llegar a
tener que asignar nada.

263
00:13:52,590 --> 00:13:56,730
Este es el caso en el que primero pasó
asignar la palabra "gato". Y

264
00:13:56,730 --> 00:14:00,330
eso significa que cuando vamos a asignar
"Catástrofe", que no es necesario para crear

265
00:14:00,330 --> 00:14:01,680
nodos para C-A-T de nuevo.

266
00:14:01,680 --> 00:14:04,830
Ya existen.

267
00:14:04,830 --> 00:14:06,080
>> ¿Qué es este sitio?

268
00:14:06,080 --> 00:14:10,480
Esta es la condición en la que C era
barra invertida n, donde c es una nueva línea.

269
00:14:10,480 --> 00:14:13,710
Esto significa que tenemos éxito
completado una palabra.

270
00:14:13,710 --> 00:14:16,860
Ahora, ¿qué es lo que queremos hacer cuando
completado con éxito una palabra?

271
00:14:16,860 --> 00:14:21,100
Vamos a utilizar este campo la palabra
dentro de nuestro nodo estructura.

272
00:14:21,100 --> 00:14:23,390
Queremos establecer que en true.

273
00:14:23,390 --> 00:14:27,150
Así que indica que este nodo
indica un éxito

274
00:14:27,150 --> 00:14:29,250
palabra, una palabra real.

275
00:14:29,250 --> 00:14:30,940
>> Ahora establezca que en true.

276
00:14:30,940 --> 00:14:35,150
Queremos restablecer nuestra cursor hasta el punto
al comienzo del trie de nuevo.

277
00:14:35,150 --> 00:14:40,160
Y, por último, incrementar nuestro diccionario
tamaño, ya que nos encontramos otra obra.

278
00:14:40,160 --> 00:14:43,230
Así que vamos a seguir haciendo eso,
lectura de carácter por carácter,

279
00:14:43,230 --> 00:14:49,150
la construcción de nuevos nodos en nuestro trie y
para cada palabra en el diccionario, hasta

280
00:14:49,150 --> 00:14:54,020
finalmente alcanzamos C! = EOF, en el que
caso salimos de el archivo.

281
00:14:54,020 --> 00:14:57,050
>> Ahora hay dos casos bajo
que podríamos haber golpeado EOF.

282
00:14:57,050 --> 00:15:00,980
La primera es si hubo un error
leer el archivo.

283
00:15:00,980 --> 00:15:03,470
Así que si hubo un error,
deberá hacer lo típico.

284
00:15:03,470 --> 00:15:06,460
Descargue todo, cerca
archivo, vuelve falsa.

285
00:15:06,460 --> 00:15:09,810
Suponiendo que no era un error, que
simplemente significa que realmente golpeó el final de

286
00:15:09,810 --> 00:15:13,750
el archivo, en cuyo caso, se cierra el
presentar y devolver true ya que

287
00:15:13,750 --> 00:15:17,330
diccionario cargado correctamente
en nuestra trie.

288
00:15:17,330 --> 00:15:20,170
>> Así que ahora vamos a ver cheque.

289
00:15:20,170 --> 00:15:25,156
En cuanto a la función de comprobación, vemos
El registro de entrada se va a devolver un bool.

290
00:15:25,156 --> 00:15:29,680
Devuelve true si esta palabra que es
que se pasa es en nuestra trie.

291
00:15:29,680 --> 00:15:32,110
Devuelve false en caso contrario.

292
00:15:32,110 --> 00:15:36,050
Entonces, ¿cómo determinar si
esta palabra es en nuestra trie?

293
00:15:36,050 --> 00:15:40,190
>> Vemos aquí que, al igual que antes,
vamos a usar el cursor para iterar

294
00:15:40,190 --> 00:15:41,970
a través de nuestro trie.

295
00:15:41,970 --> 00:15:46,600
Ahora aquí vamos a repetir
lo largo de toda nuestra palabra.

296
00:15:46,600 --> 00:15:50,620
Así iteración en la palabra que estamos pasado,
vamos a determinar la

297
00:15:50,620 --> 00:15:56,400
índice en la matriz los niños que
corresponde a la palabra soporte I. Así que este

298
00:15:56,400 --> 00:15:59,670
va a ser exactamente como
de carga, en la que si la palabra [i]

299
00:15:59,670 --> 00:16:03,310
es un apóstrofe, entonces queremos
utilizar el índice "alfabeto" - 1.

300
00:16:03,310 --> 00:16:05,350
Debido a que se determinó que esa
es donde vamos a almacenar

301
00:16:05,350 --> 00:16:07,100
apóstrofes.

302
00:16:07,100 --> 00:16:11,780
>> Else vamos a utilizar dos palabras más baja
soporte I. Así que recuerda esa palabra puede

303
00:16:11,780 --> 00:16:13,920
tener la capitalización arbitraria.

304
00:16:13,920 --> 00:16:17,540
Y por lo que queremos asegurarnos de que estamos
usando una versión en minúsculas de las cosas.

305
00:16:17,540 --> 00:16:21,920
Y luego restar de que 'a' a la vez
de nuevo nos da la alfabético

306
00:16:21,920 --> 00:16:23,880
posición de ese carácter.

307
00:16:23,880 --> 00:16:27,680
Así que va a ser nuestro índice
en la matriz de los niños.

308
00:16:27,680 --> 00:16:32,420
>> Y ahora si ese índice en los niños
matriz es nulo, eso significa que

309
00:16:32,420 --> 00:16:34,990
ya no puede continuar la iteración
bajar la trie.

310
00:16:34,990 --> 00:16:38,870
Si ese es el caso, esta palabra no puede
posiblemente estar en nuestra Trie.

311
00:16:38,870 --> 00:16:42,340
Dado que si lo fuera, que lo haría
significa no habría un camino

312
00:16:42,340 --> 00:16:43,510
a esa palabra.

313
00:16:43,510 --> 00:16:45,290
Y nunca se encontraría nulo.

314
00:16:45,290 --> 00:16:47,850
Así que encontrar nulo, volvemos falsa.

315
00:16:47,850 --> 00:16:49,840
La palabra no está en el diccionario.

316
00:16:49,840 --> 00:16:53,660
Si no fuera nulo, entonces estamos
va a continuar la iteración.

317
00:16:53,660 --> 00:16:57,220
>> Así que vamos por ahí cursor
para apuntar a esa particular

318
00:16:57,220 --> 00:16:59,760
nodo en ese índice.

319
00:16:59,760 --> 00:17:03,150
Nosotros seguimos haciendo que a lo largo
la palabra completa, suponiendo

320
00:17:03,150 --> 00:17:03,950
nunca golpeamos nulo.

321
00:17:03,950 --> 00:17:07,220
Eso significa que hemos sido capaces de obtener a través de
toda la palabra y encontrar

322
00:17:07,220 --> 00:17:08,920
un nodo en nuestro intento.

323
00:17:08,920 --> 00:17:10,770
Pero no hemos terminado todavía.

324
00:17:10,770 --> 00:17:12,290
>> No queremos simplemente devolver true.

325
00:17:12,290 --> 00:17:14,770
Queremos volver cursor> palabra.

326
00:17:14,770 --> 00:17:18,980
Dado que recordar una vez más, es "gato" no es
en el diccionario, y "catástrofe"

327
00:17:18,980 --> 00:17:22,935
¿Es, entonces tendremos éxito que obtenemos
a través de la palabra "gato". Pero cursor

328
00:17:22,935 --> 00:17:25,760
palabra será falsa y no es cierto.

329
00:17:25,760 --> 00:17:30,930
Así que volvemos cursor palabra para indicar
si este nodo es en realidad una palabra.

330
00:17:30,930 --> 00:17:32,470
Y eso es todo por cheque.

331
00:17:32,470 --> 00:17:34,250
>> Así que vamos a ver el tamaño.

332
00:17:34,250 --> 00:17:37,350
Así que el tamaño va a ser bastante fácil
ya que, recuerda en la carga, estamos

333
00:17:37,350 --> 00:17:41,430
incrementando el tamaño del diccionario para
cada palabra que nos encontramos.

334
00:17:41,430 --> 00:17:45,350
Así que el tamaño es sólo va a
devolver el tamaño del diccionario.

335
00:17:45,350 --> 00:17:47,390
Y eso es todo.

336
00:17:47,390 --> 00:17:50,590
>> Así, por último, hemos descargar.

337
00:17:50,590 --> 00:17:55,100
Así que descarga, vamos a utilizar una
función recursiva para hacer realidad todos

338
00:17:55,100 --> 00:17:56,530
parte del trabajo por nosotros.

339
00:17:56,530 --> 00:17:59,340
Así que nuestra función va a
ser llamados descargador.

340
00:17:59,340 --> 00:18:01,650
¿Qué está descargador vamos a hacer?

341
00:18:01,650 --> 00:18:06,580
Vemos aquí que descargador va a
iterar sobre todos los niños en

342
00:18:06,580 --> 00:18:08,410
este nodo particular.

343
00:18:08,410 --> 00:18:11,750
Y si el nodo hijo no es
null, entonces vamos a

344
00:18:11,750 --> 00:18:13,730
descargar el nodo secundario.

345
00:18:13,730 --> 00:18:18,010
>> Así que éste es tu caso de forma recursiva descargue
todos nuestros niños.

346
00:18:18,010 --> 00:18:21,080
Una vez que estemos seguros de que todos nuestros niños
se han descargado, entonces

347
00:18:21,080 --> 00:18:25,210
puede liberar a nosotros mismos, así
descargar nosotros mismos.

348
00:18:25,210 --> 00:18:29,460
Esto funciona de forma recursiva
descargar todo el trie.

349
00:18:29,460 --> 00:18:32,850
Y una vez hecho esto,
sólo podemos devolver true.

350
00:18:32,850 --> 00:18:34,210
Unload no puede fallar.

351
00:18:34,210 --> 00:18:35,710
Sólo estamos liberando cosas.

352
00:18:35,710 --> 00:18:38,870
Así que una vez que hayamos terminado liberando
todo, devolver true.

353
00:18:38,870 --> 00:18:40,320
Y eso es todo.

354
00:18:40,320 --> 00:18:41,080
Mi nombre es Rob.

355
00:18:41,080 --> 00:18:42,426
Y esto fue corrector ortográfico.

356
00:18:42,426 --> 00:18:47,830
>> [REPRODUCCIÓN DE MÚSICA]