1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [Artículo 6] [más cómodo]

2
00:00:01,000 --> 00:00:04,000
[Rob Bowden] [Harvard University]

3
00:00:04,000 --> 00:00:09,000
[Esta es CS50.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> Nos puede dirigirse a nuestra sección de preguntas.

5
00:00:11,000 --> 00:00:17,000
Envié a la dirección del espacio antes.

6
00:00:17,000 --> 00:00:22,000
El principio de la sección de las preguntas-decir

7
00:00:22,000 --> 00:00:26,000
al parecer, no estoy del todo unsick-Es una pregunta muy fácil

8
00:00:26,000 --> 00:00:28,000
de lo que se acaba de valgrind?

9
00:00:28,000 --> 00:00:30,000
¿Qué valgrind hacer?

10
00:00:30,000 --> 00:00:34,000
¿Alguien quiere decir lo valgrind hace?

11
00:00:34,000 --> 00:00:36,000
[Estudiante] comprueba la memoria de fugas.

12
00:00:36,000 --> 00:00:41,000
Sí, valgrind es un corrector de memoria general.

13
00:00:41,000 --> 00:00:44,000
Es, en definitiva, le dice si tiene alguna pérdida de memoria,

14
00:00:44,000 --> 00:00:49,000
que es sobre todo lo que se está usando para porque si quieres

15
00:00:49,000 --> 00:00:54,000
bien en el conjunto de problemas o si desea

16
00:00:54,000 --> 00:00:59,000
conseguir en el gran tablero, es necesario no tener pérdidas de memoria en absoluto,

17
00:00:59,000 --> 00:01:01,000
y en caso de tener una pérdida de memoria que no se puede encontrar,

18
00:01:01,000 --> 00:01:04,000
También tenga en cuenta que cada vez que abra un archivo

19
00:01:04,000 --> 00:01:07,000
y si no lo cierra, eso es una pérdida de memoria.

20
00:01:07,000 --> 00:01:10,000
>> Mucha gente está buscando algún nodo que no están liberando

21
00:01:10,000 --> 00:01:15,000
cuando en realidad, no cerrar el diccionario en el primer paso.

22
00:01:15,000 --> 00:01:19,000
También le indica si usted tiene cualquiera inválido lee o escribe,

23
00:01:19,000 --> 00:01:22,000
lo que significa que si usted trata de establecer un valor

24
00:01:22,000 --> 00:01:26,000
que está más allá del final de la pila y no pasa a la culpa seg

25
00:01:26,000 --> 00:01:30,000
pero valgrind lo coge, ya que en realidad no debería estar escribiendo allí,

26
00:01:30,000 --> 00:01:33,000
y por lo que definitivamente no debería tener ninguno de esos tampoco.

27
00:01:33,000 --> 00:01:38,000
¿Cómo se utiliza Valgrind?

28
00:01:38,000 --> 00:01:42,000
¿Cómo se utiliza Valgrind?

29
00:01:42,000 --> 00:01:45,000
>> Es un problema general de

30
00:01:45,000 --> 00:01:49,000
tipo de ejecutarlo y ver el resultado.

31
00:01:49,000 --> 00:01:51,000
La salida está abrumando un montón de veces.

32
00:01:51,000 --> 00:01:54,000
También hay errores de diversión donde si tienen alguna cosa mal, muy mal

33
00:01:54,000 --> 00:01:59,000
ocurre en un bucle, a continuación, con el tiempo se dice: "Demasiados errores.

34
00:01:59,000 --> 00:02:03,000
Voy a dejar de contar ahora ".

35
00:02:03,000 --> 00:02:08,000
Se trata básicamente de una salida de texto que hay que analizar.

36
00:02:08,000 --> 00:02:13,000
Al final, le dirá cualquier fuga de memoria que tiene,

37
00:02:13,000 --> 00:02:16,000
cuántos bloques, que puede ser útil porque

38
00:02:16,000 --> 00:02:20,000
si se trata de un unfreed bloque, entonces por lo general es más fácil de encontrar

39
00:02:20,000 --> 00:02:23,000
de 1.000 bloques unfreed.

40
00:02:23,000 --> 00:02:26,000
1.000 bloques unfreed probablemente significa que no estás liberando

41
00:02:26,000 --> 00:02:30,000
sus listas enlazadas adecuadamente o algo así.

42
00:02:30,000 --> 00:02:32,000
Eso valgrind.

43
00:02:32,000 --> 00:02:35,000
>> Ahora tenemos nuestra sección de preguntas,

44
00:02:35,000 --> 00:02:38,000
que no es necesario para descargar.

45
00:02:38,000 --> 00:02:41,000
Puede hacer clic en mi nombre y tire hacia arriba en el espacio.

46
00:02:41,000 --> 00:02:44,000
Ahora haga clic en mí.

47
00:02:44,000 --> 00:02:46,000
Revisión 1 será pila, lo que estamos haciendo en primer lugar.

48
00:02:46,000 --> 00:02:55,000
Revisión 2 será cola y Revisión 3 será la lista ligada sencilla.

49
00:02:55,000 --> 00:02:58,000
Partiendo de nuestra pila.

50
00:02:58,000 --> 00:03:02,000
Como se dice aquí, una pila es uno de los más básicos,

51
00:03:02,000 --> 00:03:07,000
estructuras de datos fundamentales de la informática.

52
00:03:07,000 --> 00:03:11,000
El ejemplo prototípico es muy

53
00:03:11,000 --> 00:03:13,000
la pila de bandejas en el comedor.

54
00:03:13,000 --> 00:03:16,000
Es, básicamente, cada vez que se introducen a una pila,

55
00:03:16,000 --> 00:03:20,000
alguien va a decir: "Oh, como una pila de bandejas".

56
00:03:20,000 --> 00:03:22,000
Usted apilar las bandejas de arriba.

57
00:03:22,000 --> 00:03:24,000
Entonces, cuando usted va a tirar una bandeja,

58
00:03:24,000 --> 00:03:31,000
la primera bandeja que está dejándonos arrastrar es el último que se puso en la pila.

59
00:03:31,000 --> 00:03:34,000
La pila también-como dice aquí-

60
00:03:34,000 --> 00:03:37,000
tenemos el segmento de memoria llamada pila.

61
00:03:37,000 --> 00:03:40,000
¿Y por qué se llama la pila?

62
00:03:40,000 --> 00:03:42,000
>> Porque al igual que una estructura de datos pila,

63
00:03:42,000 --> 00:03:46,000
lo empuja y hace estallar los marcos de pila a la pila,

64
00:03:46,000 --> 00:03:53,000
donde los marcos de pila es como una llamada de una función.

65
00:03:53,000 --> 00:03:57,000
Y al igual que una pila, siempre tendrá que volver

66
00:03:57,000 --> 00:04:03,000
a partir de una llamada a la función antes de que pueda ponerse en marcos de pila baja de nuevo.

67
00:04:03,000 --> 00:04:08,000
No se puede tener llamada principal bar llamado foo bar y volver a directamente principal.

68
00:04:08,000 --> 00:04:14,000
Siempre tiene que seguir la pila correcta empujando y haciendo estallar.

69
00:04:14,000 --> 00:04:18,000
Las dos operaciones, como he dicho, son push y pop.

70
00:04:18,000 --> 00:04:20,000
Esos son términos universales.

71
00:04:20,000 --> 00:04:26,000
Usted debe saber push y pop en términos de pilas sin importar lo que pase.

72
00:04:26,000 --> 00:04:28,000
Vamos a ver las colas son un poco diferentes.

73
00:04:28,000 --> 00:04:32,000
En realidad no tienen un término universal, pero push y pop son universales para pilas.

74
00:04:32,000 --> 00:04:34,000
Inserción se acaba de poner en la pila.

75
00:04:34,000 --> 00:04:37,000
Pop es quitar la pila.

76
00:04:37,000 --> 00:04:43,000
Y vemos aquí tenemos nuestra pila struct typedef,

77
00:04:43,000 --> 00:04:46,000
así que tenemos carbón cuerdas **.

78
00:04:46,000 --> 00:04:51,000
No te asustes por cualquier **.

79
00:04:51,000 --> 00:04:54,000
Esto va a terminar siendo una matriz de cadenas

80
00:04:54,000 --> 00:04:58,000
o una matriz de punteros a caracteres, donde

81
00:04:58,000 --> 00:05:00,000
punteros a caracteres tienden a ser cadenas.

82
00:05:00,000 --> 00:05:05,000
No tiene por qué ser cadenas, pero aquí, que van a ser cadenas.

83
00:05:05,000 --> 00:05:08,000
>> Tenemos una matriz de cadenas.

84
00:05:08,000 --> 00:05:14,000
Tenemos un tamaño, que representa cuántos elementos hay actualmente en la pila,

85
00:05:14,000 --> 00:05:19,000
y entonces tenemos la capacidad, que es cómo los elementos que pueden estar en la pila.

86
00:05:19,000 --> 00:05:22,000
La capacidad debe comenzar como algo mayor que 1,

87
00:05:22,000 --> 00:05:27,000
pero el tamaño que va a empezar a 0.

88
00:05:27,000 --> 00:05:36,000
Ahora, hay básicamente tres maneras diferentes que usted puede pensar en una pila.

89
00:05:36,000 --> 00:05:39,000
Bueno, probablemente hay más, pero son las dos formas principales

90
00:05:39,000 --> 00:05:43,000
se puede implementar utilizando una matriz, o se puede implementar utilizando una lista enlazada.

91
00:05:43,000 --> 00:05:48,000
Las listas enlazadas son una especie de trivial de hacer montones de.

92
00:05:48,000 --> 00:05:51,000
Es muy fácil hacer una pila con listas enlazadas,

93
00:05:51,000 --> 00:05:55,000
Así que aquí, vamos a hacer una pila con matrices,

94
00:05:55,000 --> 00:05:59,000
y luego usando arrays, también hay dos maneras de pensar en ello.

95
00:05:59,000 --> 00:06:01,000
Antes, cuando me dijo que tenemos una capacidad de la pila,

96
00:06:01,000 --> 00:06:04,000
por lo que puede encajar un elemento en la pila.

97
00:06:04,000 --> 00:06:09,000
>> La única manera que podría suceder es tan pronto como se golpeó 10 elementos, entonces ya está.

98
00:06:09,000 --> 00:06:13,000
Usted puede saber que hay un límite superior de 10 cosas en el mundo

99
00:06:13,000 --> 00:06:16,000
que nunca tendrá más de 10 cosas en su pila,

100
00:06:16,000 --> 00:06:20,000
en cuyo caso puede tener un límite superior en el tamaño de su stack.

101
00:06:20,000 --> 00:06:23,000
O usted podría tener su stack ser ilimitada,

102
00:06:23,000 --> 00:06:27,000
pero si usted está haciendo un arreglo, lo que significa que cada vez que conectó 10 elementos,

103
00:06:27,000 --> 00:06:29,000
entonces usted va a tener que crecer a 20 elementos, y cuando llegue a 20 elementos,

104
00:06:29,000 --> 00:06:33,000
usted va a tener que hacer crecer su matriz a 30 elementos o elementos 40.

105
00:06:33,000 --> 00:06:37,000
Vas a tener que aumentar la capacidad, que es lo que vamos a hacer aquí.

106
00:06:37,000 --> 00:06:40,000
Cada vez que alcance el tamaño máximo de nuestro stack,

107
00:06:40,000 --> 00:06:46,000
cuando empujamos algo más adelante, vamos a tener que aumentar la capacidad.

108
00:06:46,000 --> 00:06:50,000
Aquí, hemos declarado como empuje empuje bool (char * str).

109
00:06:50,000 --> 00:06:54,000
* Char str es la cadena que estamos impulsando en la pila,

110
00:06:54,000 --> 00:06:58,000
bool y sólo dice si hemos tenido éxito o ha fracasado.

111
00:06:58,000 --> 00:07:00,000
>> ¿Cómo no?

112
00:07:00,000 --> 00:07:04,000
¿Cuál es la única circunstancia que se pueda imaginar

113
00:07:04,000 --> 00:07:07,000
donde nos teníamos que volver falsa?

114
00:07:07,000 --> 00:07:09,000
Si.

115
00:07:09,000 --> 00:07:12,000
[Estudiante] Si es completo y estamos usando una aplicación limitada.

116
00:07:12,000 --> 00:07:17,000
Sí, así que ¿cómo podemos definir-respondió

117
00:07:17,000 --> 00:07:23,000
si está lleno y estamos usando una aplicación limitada.

118
00:07:23,000 --> 00:07:26,000
Entonces sin duda volveremos falsa.

119
00:07:26,000 --> 00:07:31,000
Tan pronto como llegamos a las 10 cosas de la matriz, no podemos encajar 11, por lo que devuelve falso.

120
00:07:31,000 --> 00:07:32,000
¿Y si no tiene límites? Si.

121
00:07:32,000 --> 00:07:38,000
Si no se puede expandir la matriz por alguna razón.

122
00:07:38,000 --> 00:07:43,000
Sí, así que la memoria es un recurso limitado,

123
00:07:43,000 --> 00:07:51,000
y, finalmente, si guardamos las cosas que empujan en la pila una y otra vez,

124
00:07:51,000 --> 00:07:54,000
vamos a tratar de asignar una matriz más grande para encajar

125
00:07:54,000 --> 00:07:59,000
el de mayor capacidad, y malloc o lo que sea que estamos usando se va a devolver false.

126
00:07:59,000 --> 00:08:02,000
Bueno, malloc devolverá null.

127
00:08:02,000 --> 00:08:05,000
>> Recuerde, cada vez que vuelvas a llamar malloc, usted debe comprobar para ver si

128
00:08:05,000 --> 00:08:12,000
devuelve un valor nulo o de lo que es una deducción correcta.

129
00:08:12,000 --> 00:08:17,000
Como queremos tener una pila sin límites,

130
00:08:17,000 --> 00:08:21,000
el único caso que vamos a devolver false si es que tratamos de

131
00:08:21,000 --> 00:08:26,000
aumentar la capacidad y malloc o lo devuelve false.

132
00:08:26,000 --> 00:08:30,000
Luego pop no tiene argumentos,

133
00:08:30,000 --> 00:08:37,000
y devuelve la cadena que está en la parte superior de la pila.

134
00:08:37,000 --> 00:08:41,000
Lo más reciente fue en la pila pop es lo que va a regresar,

135
00:08:41,000 --> 00:08:44,000
y también se elimina de la pila.

136
00:08:44,000 --> 00:08:50,000
Y note que devuelve null si no hay nada en la pila.

137
00:08:50,000 --> 00:08:53,000
Siempre es posible que la pila está vacía.

138
00:08:53,000 --> 00:08:55,000
En Java, si estás acostumbrado a eso, o en otros idiomas,

139
00:08:55,000 --> 00:09:01,000
tratando de hacer estallar de una pila vacía puede provocar una excepción o algo así.

140
00:09:01,000 --> 00:09:09,000
>> Pero en C, null es algo que muchos de los casos, cómo manejar estos problemas.

141
00:09:09,000 --> 00:09:13,000
Volviendo nula es cómo vamos a indicar que la pila estaba vacío.

142
00:09:13,000 --> 00:09:16,000
Hemos proporcionado el código que pondrá a prueba la funcionalidad de su pila, el

143
00:09:16,000 --> 00:09:19,000
implementar push y pop.

144
00:09:19,000 --> 00:09:23,000
Esto no va a haber un montón de código.

145
00:09:23,000 --> 00:09:40,000
Lo haré-en realidad, antes de hacer eso, pista, pista-

146
00:09:40,000 --> 00:09:44,000
si usted no lo ha visto, malloc no es la única función

147
00:09:44,000 --> 00:09:47,000
que asigna memoria en el montón para usted.

148
00:09:47,000 --> 00:09:51,000
Hay una familia de funciones Alloc.

149
00:09:51,000 --> 00:09:53,000
La primera es malloc, que estamos acostumbrados.

150
00:09:53,000 --> 00:09:56,000
Luego está calloc, que hace lo mismo que malloc,

151
00:09:56,000 --> 00:09:59,000
pero va a cero todo para ti.

152
00:09:59,000 --> 00:10:04,000
Si alguna vez has querido poner todo en nulo después mallocing algo

153
00:10:04,000 --> 00:10:06,000
usted debe haber utilizado calloc en primer lugar en vez de escribir

154
00:10:06,000 --> 00:10:09,000
un bucle for para poner en cero el bloque de memoria.

155
00:10:09,000 --> 00:10:15,000
>> Realloc es como malloc y tiene un montón de casos especiales,

156
00:10:15,000 --> 00:10:19,000
pero básicamente lo que hace es realloc

157
00:10:19,000 --> 00:10:24,000
Se tarda un puntero que ya había sido asignado.

158
00:10:24,000 --> 00:10:27,000
Realloc es la función que desee prestar atención a aquí.

159
00:10:27,000 --> 00:10:31,000
Se toma un puntero que ya se habían vuelto de malloc.

160
00:10:31,000 --> 00:10:35,000
Digamos que solicitar a malloc un puntero de 10 bytes.

161
00:10:35,000 --> 00:10:38,000
Luego, más tarde te das cuenta de que querían 20 bytes,

162
00:10:38,000 --> 00:10:42,000
así que llame realloc en ese puntero con 20 bytes,

163
00:10:42,000 --> 00:10:47,000
y realloc copiará automáticamente sobre todas las cosas para usted.

164
00:10:47,000 --> 00:10:51,000
Si usted acaba de llamar a malloc otra vez, como si tuviera un bloque de 10 bytes.

165
00:10:51,000 --> 00:10:53,000
Ahora necesito un bloque de 20 bytes,

166
00:10:53,000 --> 00:10:58,000
así que si malloc 20 bytes, entonces tengo que copiar manualmente durante los 10 bytes de la primera cosa

167
00:10:58,000 --> 00:11:01,000
en lo segundo y luego liberar la primera cosa.

168
00:11:01,000 --> 00:11:04,000
Realloc se encargará de eso por ti.

169
00:11:04,000 --> 00:11:11,000
>> Note la firma va a ser void *,

170
00:11:11,000 --> 00:11:15,000
que se acaba de devolver un puntero al bloque de memoria,

171
00:11:15,000 --> 00:11:17,000
entonces void * ptr.

172
00:11:17,000 --> 00:11:22,000
Usted puede pensar void * como un puntero genérico.

173
00:11:22,000 --> 00:11:27,000
Por lo general, no tiene que tratar con void *,

174
00:11:27,000 --> 00:11:30,000
pero malloc devuelve un void *, y entonces es sólo utilizado como

175
00:11:30,000 --> 00:11:34,000
esto es en realidad va a ser un char *.

176
00:11:34,000 --> 00:11:37,000
La void * anterior que había sido devuelto por malloc

177
00:11:37,000 --> 00:11:41,000
ahora va a pasar a realloc, y luego el tamaño

178
00:11:41,000 --> 00:11:49,000
es el nuevo número de bytes que desea asignar, por lo que su nueva capacidad.

179
00:11:49,000 --> 00:11:57,000
Te voy a dar un par de minutos, y hacerlo en nuestro espacio.

180
00:11:57,000 --> 00:12:02,000
Comience con Revisión 1.

181
00:12:16,000 --> 00:12:21,000
Te voy a parar después de esperar alrededor de tiempo suficiente para aplicar presión,

182
00:12:21,000 --> 00:12:24,000
y luego me voy a dar otro descanso para hacer pop.

183
00:12:24,000 --> 00:12:27,000
Pero en realidad no es que el código mucho a todos.

184
00:12:27,000 --> 00:12:35,000
La mayoría del código es probablemente la materia en expansión, la expansión de la capacidad.

185
00:12:35,000 --> 00:12:39,000
Está bien, no hay presión para estar completamente terminado,

186
00:12:39,000 --> 00:12:47,000
pero siempre y cuando usted se siente como si estuvieras en el camino correcto, eso es bueno.

187
00:12:47,000 --> 00:12:53,000
>> ¿Alguien tiene algún código que se sientan cómodos conmigo tirando hacia arriba?

188
00:12:53,000 --> 00:12:59,000
Sí, lo haré, pero ¿alguien tiene algún código que pueda levantar?

189
00:12:59,000 --> 00:13:05,000
De acuerdo, puede empezar, lo guarda, lo que sea?

190
00:13:05,000 --> 00:13:09,000
Siempre se me olvida ese paso.

191
00:13:09,000 --> 00:13:15,000
Bueno, mirando push,

192
00:13:15,000 --> 00:13:18,000
¿quieres explicar tu código?

193
00:13:18,000 --> 00:13:24,000
[Estudiante] En primer lugar, he aumentado el tamaño.

194
00:13:24,000 --> 00:13:28,000
Supongo que tal vez yo debería tener eso, de todos modos, he aumentado el tamaño,

195
00:13:28,000 --> 00:13:31,000
y veo si es menor que la capacidad.

196
00:13:31,000 --> 00:13:36,000
Y si es inferior a la capacidad, que se añaden al sistema que ya tenemos.

197
00:13:36,000 --> 00:13:42,000
Y si no lo es, yo multiplicar la capacidad por 2,

198
00:13:42,000 --> 00:13:50,000
y reasignar la matriz de cadenas a algo con un tamaño mayor capacidad ahora.

199
00:13:50,000 --> 00:13:55,000
Y si eso no funciona, le digo al usuario y devolver false,

200
00:13:55,000 --> 00:14:04,000
y si está bien, entonces puse la cadena en el nuevo lugar.

201
00:14:04,000 --> 00:14:07,000
>> [Rob B.] Observe también que se utilizó un buen operador de bits aquí

202
00:14:07,000 --> 00:14:09,000
a multiplicar por 2.

203
00:14:09,000 --> 00:14:11,000
Recuerde, desviación a la izquierda siempre va a ser multiplicado por 2.

204
00:14:11,000 --> 00:14:15,000
Desplazamiento a la derecha se divide por 2, siempre y cuando recuerde que esto significa

205
00:14:15,000 --> 00:14:18,000
dividir por 2 como en un número entero dividido por 2.

206
00:14:18,000 --> 00:14:20,000
Puede truncar un 1 aquí o allá.

207
00:14:20,000 --> 00:14:26,000
Pero desplazamiento a la izquierda por una siempre va a ser multiplicado por 2,

208
00:14:26,000 --> 00:14:32,000
a menos que desbordamiento de los límites del número entero, y entonces no será.

209
00:14:32,000 --> 00:14:34,000
Un comentario al margen.

210
00:14:34,000 --> 00:14:39,000
Me gusta hacer, esto no va a cambiar la codificación de cualquier manera que sea,

211
00:14:39,000 --> 00:14:48,000
pero me gustaría hacer algo como esto.

212
00:14:48,000 --> 00:14:51,000
En realidad, se va a hacer un poco más.

213
00:15:04,000 --> 00:15:08,000
Tal vez este no es el caso perfecto para demostrar esto,

214
00:15:08,000 --> 00:15:14,000
pero me gusta segmento que en estos bloques de-

215
00:15:14,000 --> 00:15:17,000
bien, si esto si sucede, entonces yo voy a hacer algo,

216
00:15:17,000 --> 00:15:19,000
y entonces la función se lleva a cabo.

217
00:15:19,000 --> 00:15:22,000
Yo no tenga que desplazarse luego mis ojos todo el camino por la función

218
00:15:22,000 --> 00:15:25,000
para ver lo que pasa después de la otra persona.

219
00:15:25,000 --> 00:15:27,000
Es este caso, si ocurre, entonces simplemente volver.

220
00:15:27,000 --> 00:15:30,000
También tiene el beneficio añadido de todo lo bueno más allá de esta

221
00:15:30,000 --> 00:15:33,000
está desplazado a la izquierda una vez.

222
00:15:33,000 --> 00:15:40,000
Ya no necesito a si alguna vez cerca ridículamente largas filas,

223
00:15:40,000 --> 00:15:45,000
entonces esos 4 bytes puede ayudar, y también es el algo más a la izquierda,

224
00:15:45,000 --> 00:15:48,000
el menor se sienta abrumado si gusta-bueno, tengo que recordar

225
00:15:48,000 --> 00:15:53,000
Actualmente estoy en un bucle while dentro de un interior más de un bucle for.

226
00:15:53,000 --> 00:15:58,000
En cualquier lugar que usted puede hacer este cambio de inmediato, me gusta bastante.

227
00:15:58,000 --> 00:16:05,000
Es totalmente opcional y no se espera de ninguna manera.

228
00:16:05,000 --> 00:16:12,000
>> [Estudiante] ¿Debe existir un tamaño - en la condición de fallo?

229
00:16:12,000 --> 00:16:19,000
La condición de falla aquí es que no realloc, así que sí.

230
00:16:19,000 --> 00:16:22,000
Observe cómo en la condición de fallo, presumiblemente,

231
00:16:22,000 --> 00:16:26,000
a menos que la materia libre más tarde, siempre vamos a fallar

232
00:16:26,000 --> 00:16:29,000
no importa cuántas veces tratamos de empujar algo.

233
00:16:29,000 --> 00:16:32,000
Si seguimos presionando, seguimos incrementando el tamaño,

234
00:16:32,000 --> 00:16:36,000
a pesar de que no está poniendo nada en la pila.

235
00:16:36,000 --> 00:16:39,000
Por lo general, no incrementan el tamaño hasta

236
00:16:39,000 --> 00:16:43,000
después hemos logrado ponerlo en la pila.

237
00:16:43,000 --> 00:16:50,000
Por lo que le hacemos, decimos, ya sea aquí y aquí.

238
00:16:50,000 --> 00:16:56,000
Y entonces, en lugar de decir s.size capacidad ≤, es inferior a la capacidad,

239
00:16:56,000 --> 00:17:01,000
sólo porque nos mudamos dónde estaba todo.

240
00:17:01,000 --> 00:17:07,000
>> Y recuerde, el único lugar que podría devolver false

241
00:17:07,000 --> 00:17:14,000
Es aquí, donde realloc devuelve null,

242
00:17:14,000 --> 00:17:19,000
y si te quedas a recordar error estándar,

243
00:17:19,000 --> 00:17:22,000
tal vez usted podría considerar este caso, una en la que desea imprimir un error estándar,

244
00:17:22,000 --> 00:17:26,000
stderr fprintf así en lugar de imprimir directamente en la salida estándar.

245
00:17:26,000 --> 00:17:31,000
Una vez más, eso no es una expectativa, pero si se trata de un error,

246
00:17:31,000 --> 00:17:41,000
escribir printf, entonces es posible que desee hacer que imprima a un error estándar en lugar de la salida estándar.

247
00:17:41,000 --> 00:17:44,000
>> ¿Alguien tiene algo más que observar? Sí.

248
00:17:44,000 --> 00:17:47,000
[Estudiante] ¿Se puede pasar el [inaudible]?

249
00:17:47,000 --> 00:17:55,000
[Rob B.] Sí, el binariness real de él o sólo lo que es?

250
00:17:55,000 --> 00:17:57,000
[Estudiante] Así lo multiplicas por 2?

251
00:17:57,000 --> 00:17:59,000
[Rob B.] Sí, básicamente.

252
00:17:59,000 --> 00:18:11,000
En tierra binario, siempre tenemos nuestro conjunto de dígitos.

253
00:18:11,000 --> 00:18:22,000
Desplazamiento de esta izquierda por un Básicamente se inserta aquí en el lado derecho.

254
00:18:22,000 --> 00:18:25,000
Volver a esto, sólo recordar que todo en binario

255
00:18:25,000 --> 00:18:28,000
es una potencia de 2, por lo que esto representa 2 al 0,

256
00:18:28,000 --> 00:18:30,000
este 2 a la 1, 2 esta a la 2.

257
00:18:30,000 --> 00:18:33,000
Mediante la inserción de un 0 a un lado ahora mismo, simplemente cambiar todo de nuevo.

258
00:18:33,000 --> 00:18:38,000
Lo que solía ser de 2 a 0 es ahora de 2 a 1, es 2 a la 2.

259
00:18:38,000 --> 00:18:41,000
El lado derecho que insertamos

260
00:18:41,000 --> 00:18:44,000
necesariamente va a ser 0,

261
00:18:44,000 --> 00:18:46,000
lo cual tiene sentido.

262
00:18:46,000 --> 00:18:49,000
Si alguna vez multiplicar un número por 2, que no va a terminar extraño,

263
00:18:49,000 --> 00:18:54,000
por lo que el 2 a 0 el lugar debe ser 0,

264
00:18:54,000 --> 00:18:59,000
y esto es lo que media advertido antes es que si te quedas a pasar

265
00:18:59,000 --> 00:19:01,000
más allá del número de bits en un número entero,

266
00:19:01,000 --> 00:19:04,000
entonces este 1 va a terminar sonando.

267
00:19:04,000 --> 00:19:10,000
Esa es la única preocupación si usted sucede estar tratando con capacidades muy grandes.

268
00:19:10,000 --> 00:19:15,000
Pero en ese momento, entonces usted está tratando con un arsenal de miles de millones de cosas,

269
00:19:15,000 --> 00:19:25,000
que no pudo caber en la memoria de todos modos.

270
00:19:25,000 --> 00:19:31,000
>> Ahora podemos llegar a pop, lo cual es aún más fácil.

271
00:19:31,000 --> 00:19:36,000
Podrías me gusta si te ocurre hacer estallar un montón,

272
00:19:36,000 --> 00:19:38,000
y ahora está a la mitad de la capacidad de nuevo.

273
00:19:38,000 --> 00:19:42,000
Usted podría realloc para reducir la cantidad de memoria que tiene,

274
00:19:42,000 --> 00:19:47,000
pero usted no tiene que preocuparse por eso, por lo que el caso realloc sólo va a ser

275
00:19:47,000 --> 00:19:50,000
creciente memoria, nunca encogimiento memoria,

276
00:19:50,000 --> 00:19:59,000
que va a hacer súper pop fácil.

277
00:19:59,000 --> 00:20:02,000
Ahora colas, que van a ser como pilas,

278
00:20:02,000 --> 00:20:06,000
pero el fin de que se tome las cosas se invierte.

279
00:20:06,000 --> 00:20:10,000
En el ejemplo prototípico de una cola es una línea,

280
00:20:10,000 --> 00:20:12,000
así que supongo que si fueras Inglés, habría dicho

281
00:20:12,000 --> 00:20:17,000
un ejemplo prototípico de una cola es una cola.

282
00:20:17,000 --> 00:20:22,000
Así como una línea, si usted es la primera persona en la fila,

283
00:20:22,000 --> 00:20:24,000
que espera ser la primera persona fuera de la línea.

284
00:20:24,000 --> 00:20:31,000
Si usted es la última persona en la fila, usted va a ser la persona atendida pasado.

285
00:20:31,000 --> 00:20:35,000
A eso le llamamos modelo FIFO, mientras pila era patrón LIFO.

286
00:20:35,000 --> 00:20:40,000
Esas palabras son bastante universal.

287
00:20:40,000 --> 00:20:46,000
>> Al igual que las pilas y no como los arrays, las colas no suelen permitir el acceso a los elementos del medio.

288
00:20:46,000 --> 00:20:50,000
Aquí, una pila, tenemos push y pop.

289
00:20:50,000 --> 00:20:54,000
A continuación, pasamos a los he llamado en cola y quitar de la cola.

290
00:20:54,000 --> 00:20:58,000
También he oído que llama cambio y unshift.

291
00:20:58,000 --> 00:21:02,000
He oído a gente decir push y pop también se aplican a las colas.

292
00:21:02,000 --> 00:21:05,000
He oído a insertar, eliminar,

293
00:21:05,000 --> 00:21:11,000
así push y pop, si usted está hablando de pilas, que está empujando y haciendo estallar.

294
00:21:11,000 --> 00:21:16,000
Si usted está hablando acerca de las colas, se puede escoger las palabras que desea utilizar

295
00:21:16,000 --> 00:21:23,000
para la inserción y eliminación, y no hay consenso sobre lo que debe ser llamado.

296
00:21:23,000 --> 00:21:27,000
Pero aquí, tenemos que poner en cola y quitar de la cola.

297
00:21:27,000 --> 00:21:37,000
Ahora bien, la estructura se ve casi idéntica a la estructura de la pila.

298
00:21:37,000 --> 00:21:40,000
Pero tenemos que hacer un seguimiento de la cabeza.

299
00:21:40,000 --> 00:21:44,000
Supongo que lo dice por aquí, pero ¿por qué necesitamos la cabeza?

300
00:21:53,000 --> 00:21:57,000
Los prototipos son básicamente idénticos a push y pop.

301
00:21:57,000 --> 00:21:59,000
Usted puede pensar en él como push y pop.

302
00:21:59,000 --> 00:22:08,000
La única diferencia es pop vuelve-en lugar de la última, está devolviendo la primera.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, o algo así.

304
00:22:12,000 --> 00:22:14,000
Y aquí está el principio.

305
00:22:14,000 --> 00:22:17,000
Nuestra cola está completamente lleno, así que hay cuatro elementos que contiene.

306
00:22:17,000 --> 00:22:21,000
El final de nuestra cola es actualmente 2,

307
00:22:21,000 --> 00:22:24,000
y ahora vamos a insertar otra cosa.

308
00:22:24,000 --> 00:22:29,000
>> Cuando queremos insertar ese algo más, lo que hicimos para la versión de pila

309
00:22:29,000 --> 00:22:36,000
Se ampliamos nuestro bloque de memoria.

310
00:22:36,000 --> 00:22:40,000
¿Cuál es el problema con esto?

311
00:22:40,000 --> 00:22:45,000
[Estudiante] Mueve el 2.

312
00:22:45,000 --> 00:22:51,000
Lo que dije antes sobre el extremo de la cola,

313
00:22:51,000 --> 00:22:57,000
esto no tiene sentido que empecemos a 1,

314
00:22:57,000 --> 00:23:01,000
entonces queremos quitar de la cola 1, luego quitar de la cola 3, luego quitar de la cola 4,

315
00:23:01,000 --> 00:23:05,000
a continuación, quitar de la cola 2, a continuación, quitar de la cola de éste.

316
00:23:05,000 --> 00:23:08,000
No podemos usar realloc ahora,

317
00:23:08,000 --> 00:23:11,000
o por lo menos, usted tiene que utilizar realloc de una manera diferente.

318
00:23:11,000 --> 00:23:15,000
Pero es probable que no sólo debe utilizar realloc.

319
00:23:15,000 --> 00:23:18,000
Usted va a tener que copiar manualmente la memoria.

320
00:23:18,000 --> 00:23:21,000
>> Existen dos funciones para copiar la memoria.

321
00:23:21,000 --> 00:23:25,000
Hay memcopy y memmove.

322
00:23:25,000 --> 00:23:29,000
Actualmente estoy leyendo las páginas del manual para ver cuál te va a querer usar.

323
00:23:29,000 --> 00:23:35,000
Bueno, memcopy, la diferencia es

324
00:23:35,000 --> 00:23:38,000
que memcopy y memmove, uno maneja el caso correctamente

325
00:23:38,000 --> 00:23:41,000
donde está copiando en una región que pasa a superponerse a la región

326
00:23:41,000 --> 00:23:46,000
que está copiando.

327
00:23:46,000 --> 00:23:50,000
Memcopy no manejarlo. Memmove hace.

328
00:23:50,000 --> 00:23:59,000
Usted puede pensar en el problema, ya que-

329
00:23:59,000 --> 00:24:09,000
digamos que desea copiar este tipo,

330
00:24:09,000 --> 00:24:13,000
estos cuatro a este tipo otra vez.

331
00:24:13,000 --> 00:24:16,000
Al final, lo que la matriz debe ser similar

332
00:24:16,000 --> 00:24:26,000
después de que la copia es 2, 1, 2, 1, 3, 4, y luego un poco de materia en el extremo.

333
00:24:26,000 --> 00:24:29,000
Pero esto es dependiente del orden en el que realmente copiar,

334
00:24:29,000 --> 00:24:32,000
ya que si no consideramos el hecho de que la región se está copiando en

335
00:24:32,000 --> 00:24:35,000
se superpone a la que estamos copiando de,

336
00:24:35,000 --> 00:24:46,000
entonces podríamos hacer aquí como inicio, copie el 2 en el lugar al que desea ir,

337
00:24:46,000 --> 00:24:52,000
a continuación, pasar a nuestros punteros hacia adelante.

338
00:24:52,000 --> 00:24:56,000
>> Ahora vamos a estar aquí y aquí, y ahora queremos copiar

339
00:24:56,000 --> 00:25:04,000
este tipo a través de este tipo y mover nuestros punteros hacia adelante.

340
00:25:04,000 --> 00:25:07,000
Lo que vamos a terminar recibiendo es de 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
en lugar de la 2, 1, 2, 1, 3, 4 porque

342
00:25:10,000 --> 00:25:15,000
2, 1 hizo caso omiso de la original 3, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove que maneja correctamente.

344
00:25:19,000 --> 00:25:23,000
En este caso, básicamente, sólo utilice siempre memmove

345
00:25:23,000 --> 00:25:26,000
porque se maneja correctamente.

346
00:25:26,000 --> 00:25:29,000
Por lo general, no realiza ninguna peor.

347
00:25:29,000 --> 00:25:32,000
La idea es en lugar de comenzar desde el principio y la copia de esta manera

348
00:25:32,000 --> 00:25:35,000
como lo acaba de hacer aquí, se inicia desde el extremo y lo copia en,

349
00:25:35,000 --> 00:25:38,000
y en ese caso, nunca se puede tener un problema.

350
00:25:38,000 --> 00:25:40,000
No hay pérdida de rendimiento.

351
00:25:40,000 --> 00:25:47,000
Utilice siempre memmove. No te preocupes por memcopy.

352
00:25:47,000 --> 00:25:51,000
Y ahí es donde usted va a tener que memmove por separado

353
00:25:51,000 --> 00:26:01,000
la porción envuelta-en torno de su cola.

354
00:26:01,000 --> 00:26:04,000
No se preocupe si no está completamente terminado.

355
00:26:04,000 --> 00:26:10,000
Esto es más difícil que la pila, empuje, y el pop.

356
00:26:10,000 --> 00:26:15,000
>> ¿Alguien tiene algún código que podríamos trabajar?

357
00:26:15,000 --> 00:26:21,000
Aunque totalmente incompleto?

358
00:26:21,000 --> 00:26:23,000
[Estudiante] Sí, es totalmente incompleto, sin embargo.

359
00:26:23,000 --> 00:26:27,000
Completamente incompleto está bien, siempre y cuando, se puede ahorrar la revisión?

360
00:26:27,000 --> 00:26:32,000
Me olvido de que cada vez.

361
00:26:32,000 --> 00:26:39,000
Bueno, haciendo caso omiso de lo que sucede cuando tenemos que cambiar el tamaño de las cosas.

362
00:26:39,000 --> 00:26:42,000
Ignoran por completo cambio de tamaño.

363
00:26:42,000 --> 00:26:49,000
Explicar este código.

364
00:26:49,000 --> 00:26:54,000
Estoy comprobando en primer lugar si el tamaño es menor que la primera copia de todos

365
00:26:54,000 --> 00:27:01,000
y después de eso, inserto-I + tomar la cabeza de tamaño,

366
00:27:01,000 --> 00:27:05,000
y me aseguro de que se envuelve alrededor de la capacidad de la matriz,

367
00:27:05,000 --> 00:27:08,000
y puedo insertar la nueva cadena en esa posición.

368
00:27:08,000 --> 00:27:12,000
Entonces puedo aumentar el tamaño y devolver true.

369
00:27:12,000 --> 00:27:22,000
>> [Rob B.] Este es definitivamente uno de esos casos en que vas a querer usar mod.

370
00:27:22,000 --> 00:27:25,000
Cualquier tipo de caso en el que ha de envolver alrededor, si te parece envolver alrededor,

371
00:27:25,000 --> 00:27:29,000
el primer pensamiento debe ser mod.

372
00:27:29,000 --> 00:27:36,000
Como una optimización rápida / hacer que el código una línea más corta,

373
00:27:36,000 --> 00:27:42,000
te das cuenta de que la línea inmediatamente después de éste

374
00:27:42,000 --> 00:27:53,000
es sólo el tamaño + +, por lo que se fusionan en esta línea, el tamaño + +.

375
00:27:53,000 --> 00:27:58,000
Ahora aquí abajo, tenemos el caso

376
00:27:58,000 --> 00:28:01,000
en el que no tiene suficiente memoria,

377
00:28:01,000 --> 00:28:05,000
por lo que estamos aumentando nuestra capacidad por 2.

378
00:28:05,000 --> 00:28:09,000
Creo que se puede tener el mismo problema aquí, pero podemos ignorarla ahora,

379
00:28:09,000 --> 00:28:13,000
donde si no para aumentar su capacidad,

380
00:28:13,000 --> 00:28:18,000
entonces usted va a querer disminuir su capacidad de 2 de nuevo.

381
00:28:18,000 --> 00:28:24,000
Otra nota corta es igual que lo puede hacer + =,

382
00:28:24,000 --> 00:28:30,000
también se puede hacer << =.

383
00:28:30,000 --> 00:28:43,000
Casi cualquier cosa puede pasar antes de iguales, + =, | =, + =, << =.

384
00:28:43,000 --> 00:28:52,000
Char * nuevo es nuestro nuevo bloque de memoria.

385
00:28:52,000 --> 00:28:55,000
Oh, por aquí.

386
00:28:55,000 --> 00:29:02,000
>> ¿Qué piensa la gente de la clase de nuestro nuevo bloque de memoria?

387
00:29:02,000 --> 00:29:06,000
[Estudiante] Debe ser char **.

388
00:29:06,000 --> 00:29:12,000
Pensando en nuestra estructura hasta aquí,

389
00:29:12,000 --> 00:29:14,000
cadenas es lo que estamos reasignando.

390
00:29:14,000 --> 00:29:21,000
Estamos haciendo toda una nueva dinámica para el almacenamiento de los elementos de la cola.

391
00:29:21,000 --> 00:29:25,000
Lo que vamos a asignar a las cadenas es lo que estamos mallocing en este momento,

392
00:29:25,000 --> 00:29:30,000
y tan nuevo que va a ser un char **.

393
00:29:30,000 --> 00:29:34,000
Va a ser una matriz de cadenas.

394
00:29:34,000 --> 00:29:38,000
Entonces, ¿cuál es el caso en el que nos vamos a volver falso?

395
00:29:38,000 --> 00:29:41,000
[Estudiante] Deberíamos estar haciendo char *?

396
00:29:41,000 --> 00:29:44,000
[Rob B.] Sí, buena idea.

397
00:29:44,000 --> 00:29:46,000
[Estudiante] ¿Qué fue eso?

398
00:29:46,000 --> 00:29:49,000
[Rob B.] Queríamos hacer tamaño de char * porque ya no somos-

399
00:29:49,000 --> 00:29:53,000
en realidad esto sería un problema muy grande porque sizeof (char) sería 1.

400
00:29:53,000 --> 00:29:55,000
Sizeof char * va a ser 4,

401
00:29:55,000 --> 00:29:58,000
por lo que una gran cantidad de ocasiones en las que estamos tratando enteros,

402
00:29:58,000 --> 00:30:01,000
se tiende a salirse con la suya porque el tamaño de int y el tamaño de int *

403
00:30:01,000 --> 00:30:04,000
en un sistema de 32-bit va a ser la misma cosa.

404
00:30:04,000 --> 00:30:09,000
Pero aquí, sizeof (char) y sizeof (char *) son ahora va a ser la misma cosa.

405
00:30:09,000 --> 00:30:15,000
>> ¿Cuál es la circunstancia en la que volvemos falso?

406
00:30:15,000 --> 00:30:17,000
[Estudiante] Nuevo es nulo.

407
00:30:17,000 --> 00:30:23,000
Sí, si es nuevo es nulo, se devuelve falso,

408
00:30:23,000 --> 00:30:34,000
y me voy a tirar por aquí-

409
00:30:34,000 --> 00:30:37,000
[Estudiante] [inaudible]

410
00:30:37,000 --> 00:30:39,000
[Rob B.] Sí, esto está muy bien.

411
00:30:39,000 --> 00:30:46,000
Usted podría hacer 2 veces la capacidad o la capacidad de un cambio, y sólo entonces la coloque aquí o lo que sea.

412
00:30:46,000 --> 00:30:52,000
Lo haremos como lo teníamos.

413
00:30:52,000 --> 00:30:56,000
Capacidad >> = 1.

414
00:30:56,000 --> 00:31:08,000
Y nunca vamos a tener que preocuparse de perder su lugar el 1

415
00:31:08,000 --> 00:31:12,000
porque te fuiste cambiado por 1, por lo que el 1 de lugar es necesariamente un 0,

416
00:31:12,000 --> 00:31:16,000
tan a la derecha por un cambio, usted todavía va a estar bien.

417
00:31:16,000 --> 00:31:19,000
[Estudiante] ¿Es necesario hacerlo antes del regreso?

418
00:31:19,000 --> 00:31:29,000
[Rob B.] Sí, esto no tiene ningún sentido.

419
00:31:29,000 --> 00:31:36,000
>> Ahora supongamos que vamos a terminar devolviendo true hasta el final.

420
00:31:36,000 --> 00:31:39,000
La forma en que vamos a hacer estas memmoves,

421
00:31:39,000 --> 00:31:45,000
tenemos que tener cuidado con la forma en que ellos lo hacen.

422
00:31:45,000 --> 00:31:50,000
¿Alguien tiene alguna sugerencia de cómo lo hacemos?

423
00:32:17,000 --> 00:32:21,000
Este es nuestro principio.

424
00:32:21,000 --> 00:32:28,000
Inevitablemente, queremos empezar desde el principio otra vez

425
00:32:28,000 --> 00:32:35,000
y cosas de copia en desde allí, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
¿Cómo se hace eso?

427
00:32:41,000 --> 00:32:52,000
En primer lugar, tengo que mirar en la página de manual de memmove nuevo.

428
00:32:52,000 --> 00:32:57,000
Memmove, el orden de los argumentos de siempre es importante.

429
00:32:57,000 --> 00:33:01,000
Queremos que nuestro primer destino, la segunda fuente, la tercera tamaño.

430
00:33:01,000 --> 00:33:06,000
Hay una gran cantidad de funciones que revierten origen y destino.

431
00:33:06,000 --> 00:33:11,000
Destino, la fuente tiende a ser algo consistente.

432
00:33:17,000 --> 00:33:21,000
Mover, lo que se lo va a devolver?

433
00:33:21,000 --> 00:33:27,000
Devuelve un puntero al destino, por cualquier razón usted podría querer eso.

434
00:33:27,000 --> 00:33:32,000
Me imagino a leerlo, pero queremos avanzar en nuestro destino.

435
00:33:32,000 --> 00:33:35,000
>> ¿Cuál es nuestro destino va a ser?

436
00:33:35,000 --> 00:33:37,000
[Estudiante] Nuevo.

437
00:33:37,000 --> 00:33:39,000
[Rob B.] Sí, y ¿dónde estamos copiando?

438
00:33:39,000 --> 00:33:43,000
Lo primero que está copiando es este 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
¿Cuál es el este-1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
¿Cuál es la dirección de este 1?

441
00:33:55,000 --> 00:33:58,000
¿Cuál es la dirección de que 1?

442
00:33:58,000 --> 00:34:01,000
[Estudiante] [inaudible]

443
00:34:01,000 --> 00:34:03,000
[Rob B.] + Cara la dirección del primer elemento.

444
00:34:03,000 --> 00:34:05,000
¿Cómo hacemos para que el primer elemento de la matriz?

445
00:34:05,000 --> 00:34:10,000
[Estudiante] Queue.

446
00:34:10,000 --> 00:34:15,000
[Rob B.] Sí, q.strings.

447
00:34:15,000 --> 00:34:20,000
Recuerde, aquí, nuestra cabeza: 1.

448
00:34:20,000 --> 00:34:24,000
Maldita sea. Yo sólo creo que es por arte de magia-

449
00:34:24,000 --> 00:34:29,000
Aquí, nuestro jefe es 1. Voy a cambiar mi color también.

450
00:34:29,000 --> 00:34:36,000
Y aquí está cuerdas.

451
00:34:36,000 --> 00:34:41,000
Esto, nos puede escribir como lo hicimos aquí

452
00:34:41,000 --> 00:34:43,000
con cabezas + q.strings.

453
00:34:43,000 --> 00:34:51,000
Mucha gente también escribe y q.strings [cabeza].

454
00:34:51,000 --> 00:34:55,000
Esto no es realmente algo menos eficiente.

455
00:34:55,000 --> 00:34:58,000
Se podría pensar en ella como lo está dereferencing y luego obtener la dirección de,

456
00:34:58,000 --> 00:35:04,000
pero el compilador va a traducir a lo que teníamos antes de todos modos, q.strings + cabeza.

457
00:35:04,000 --> 00:35:06,000
De cualquier manera que usted desea pensar en ello.

458
00:35:06,000 --> 00:35:11,000
>> Y cuántos bytes queremos copiar?

459
00:35:11,000 --> 00:35:15,000
[Estudiante] Capacidad - cabeza.

460
00:35:15,000 --> 00:35:18,000
Capacidad - cabeza.

461
00:35:18,000 --> 00:35:21,000
Y entonces siempre se puede escribir un ejemplo

462
00:35:21,000 --> 00:35:23,000
para averiguar si es cierto.

463
00:35:23,000 --> 00:35:26,000
[Estudiante] Tiene que ser dividido por 2 a continuación.

464
00:35:26,000 --> 00:35:30,000
Sí, así que supongo que podría utilizar tamaño.

465
00:35:30,000 --> 00:35:35,000
Todavía tenemos tamaño es-

466
00:35:35,000 --> 00:35:39,000
usando tamaño, que tienen un tamaño igual a 4.

467
00:35:39,000 --> 00:35:42,000
Nuestro tamaño es 4. Nuestra cabeza es 1.

468
00:35:42,000 --> 00:35:46,000
Queremos copiar estos 3 elementos.

469
00:35:46,000 --> 00:35:54,000
Esa es la comprobación de validez de ese tamaño - cabeza está correctamente 3.

470
00:35:54,000 --> 00:35:58,000
Y regresando aquí, como hemos dicho antes,

471
00:35:58,000 --> 00:36:00,000
si utilizamos la capacidad, entonces tendríamos que dividir por 2

472
00:36:00,000 --> 00:36:04,000
porque ya hemos crecido nuestra capacidad, por lo que en su lugar, vamos a utilizar el tamaño.

473
00:36:11,000 --> 00:36:13,000
Que las copias de las porciones.

474
00:36:13,000 --> 00:36:18,000
Ahora, tenemos que copiar la otra parte, la parte que queda de la salida.

475
00:36:18,000 --> 00:36:28,000
>> Eso va a memmove en qué posición?

476
00:36:28,000 --> 00:36:32,000
[Estudiante] más del tamaño - la cabeza.

477
00:36:32,000 --> 00:36:38,000
Sí, por lo que ya ha copiado en el tamaño - bytes de la cabeza,

478
00:36:38,000 --> 00:36:43,000
y por lo tanto donde queremos copiar los bytes restantes es nuevo

479
00:36:43,000 --> 00:36:48,000
y luego el tamaño de menos-bien, el número de bytes que ya hemos copiado pulg

480
00:36:48,000 --> 00:36:52,000
Y entonces, ¿dónde estamos copiando?

481
00:36:52,000 --> 00:36:54,000
[Estudiante] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[Rob B.] Sí, q.strings.

483
00:36:56,000 --> 00:37:02,000
Podíamos hacer y q.strings [0].

484
00:37:02,000 --> 00:37:05,000
Esto es significativamente menos frecuente que esto.

485
00:37:05,000 --> 00:37:14,000
Si sólo va a ser 0, entonces usted tiende a ver q.strings.

486
00:37:14,000 --> 00:37:16,000
Ahí es donde estamos copiando.

487
00:37:16,000 --> 00:37:18,000
¿Cuántos bytes qué nos queda para copiar? >> [Estudiante] 10.

488
00:37:18,000 --> 00:37:20,000
Derecha.

489
00:37:20,000 --> 00:37:25,000
[Estudiante] ¿Tenemos que multiplicar 5 - 10 veces el tamaño de los bytes o algo así?

490
00:37:25,000 --> 00:37:30,000
Sí, así es, ¿qué es exactamente donde estamos copiando?

491
00:37:30,000 --> 00:37:32,000
[Estudiante] [inaudible]

492
00:37:32,000 --> 00:37:34,000
¿Cuál es el tipo de cosa que está copiando?

493
00:37:34,000 --> 00:37:36,000
[Estudiante] [inaudible]

494
00:37:36,000 --> 00:37:41,000
Sí, por lo que el char * s que estamos copiando, no sé de dónde los están viniendo.

495
00:37:41,000 --> 00:37:47,000
Bueno, ¿dónde están señalando, como las cuerdas, terminamos empujando a la cola

496
00:37:47,000 --> 00:37:49,000
o enqueuing en la cola.

497
00:37:49,000 --> 00:37:51,000
Cuando los están viniendo, no tenemos ni idea.

498
00:37:51,000 --> 00:37:56,000
Sólo tenemos que perder de vista el char * s mismos.

499
00:37:56,000 --> 00:38:00,000
No queremos copiar tamaño - bytes cabeza.

500
00:38:00,000 --> 00:38:03,000
Queremos copiar tamaño - cabeza char * s,

501
00:38:03,000 --> 00:38:11,000
así que vamos a multiplicarlo por sizeof (char *).

502
00:38:11,000 --> 00:38:17,000
Igual aquí abajo, la cabeza * sizeof (char *).

503
00:38:17,000 --> 00:38:24,000
>> [Estudiante] ¿Qué pasa con [inaudible]?

504
00:38:24,000 --> 00:38:26,000
Este derecho aquí?

505
00:38:26,000 --> 00:38:28,000
[Estudiante] No, más abajo, el tamaño - la cabeza.

506
00:38:28,000 --> 00:38:30,000
[Rob B.] Este derecho aquí?

507
00:38:30,000 --> 00:38:32,000
Aritmética de punteros.

508
00:38:32,000 --> 00:38:35,000
Cómo aritmética de punteros se va a trabajar es

509
00:38:35,000 --> 00:38:40,000
automáticamente se multiplica por el tamaño del tipo que estamos tratando.

510
00:38:40,000 --> 00:38:46,000
Al igual que aquí, nuevo + (tamaño - la cabeza)

511
00:38:46,000 --> 00:38:56,000
es exactamente equivalente a & [size - cabeza] nuevo

512
00:38:56,000 --> 00:39:00,000
hasta que esperamos que funcione correctamente,

513
00:39:00,000 --> 00:39:04,000
ya que si estamos tratando con una matriz int, entonces no lo hacemos índice int-

514
00:39:04,000 --> 00:39:07,000
o si es de un tamaño de 5 y desea que el 4 º elemento, entonces el índice en

515
00:39:07,000 --> 00:39:10,000
int matriz [4].

516
00:39:10,000 --> 00:39:14,000
Usted no-[4] * El tamaño de int.

517
00:39:14,000 --> 00:39:21,000
Eso se maneja de forma automática, y en este caso

518
00:39:21,000 --> 00:39:29,000
es, literalmente, equivalente, por lo que la sintaxis de soporte

519
00:39:29,000 --> 00:39:34,000
es sólo va a ser convertido en esto tan pronto como se compila.

520
00:39:34,000 --> 00:39:38,000
Eso es algo que tienes que tener cuidado de que

521
00:39:38,000 --> 00:39:42,000
al agregar tamaño - cabeza

522
00:39:42,000 --> 00:39:45,000
va a agregar no un byte.

523
00:39:45,000 --> 00:39:53,000
Usted va a añadir un char *, que puede ser una bytes o lo que sea.

524
00:39:53,000 --> 00:39:56,000
>> Otras preguntas?

525
00:39:56,000 --> 00:40:04,000
Está bien, quitar de la cola va a ser más fácil.

526
00:40:04,000 --> 00:40:11,000
Te voy a dar un minuto de implementar.

527
00:40:11,000 --> 00:40:18,000
Oh, y supongo que esta es la misma situación en que

528
00:40:18,000 --> 00:40:21,000
lo que el caso en cola, si estamos enqueuing nulo,

529
00:40:21,000 --> 00:40:24,000
tal vez queremos manejarlo, tal vez no lo hacemos.

530
00:40:24,000 --> 00:40:27,000
No lo volveré a hacer aquí, pero igual que nuestro caso pila.

531
00:40:27,000 --> 00:40:34,000
Si encolar nulo, lo que se quiere es pasar por alto.

532
00:40:34,000 --> 00:40:40,000
¿Alguien tiene algún código que puede levantar?

533
00:40:40,000 --> 00:40:45,000
[Estudiante] Sólo tengo quitar de la cola.

534
00:40:45,000 --> 00:40:56,000
La versión 2 es que-bien.

535
00:40:56,000 --> 00:40:59,000
Usted quiere explicar?

536
00:40:59,000 --> 00:41:01,000
[Estudiante] En primer lugar, asegúrese de que hay algo en la cola

537
00:41:01,000 --> 00:41:07,000
y que el tamaño va a la baja en 1.

538
00:41:07,000 --> 00:41:11,000
Que tiene que hacer eso, y luego que regrese la cabeza

539
00:41:11,000 --> 00:41:13,000
y luego mover la cabeza hacia arriba 1.

540
00:41:13,000 --> 00:41:19,000
Está bien, así que hay un caso de la esquina tenemos que tener en cuenta. Si.

541
00:41:19,000 --> 00:41:24,000
[Estudiante] Si tu cabeza está en el último elemento,

542
00:41:24,000 --> 00:41:26,000
entonces usted no quiere la cabeza para señalar fuera de la matriz.

543
00:41:26,000 --> 00:41:29,000
>> Sí, tan pronto como la cabeza en la final de nuestra matriz,

544
00:41:29,000 --> 00:41:35,000
cuando quitar de la cola, la cabeza debe ser modded nuevo a 0.

545
00:41:35,000 --> 00:41:40,000
Desafortunadamente, no podemos hacer eso en un solo paso.

546
00:41:40,000 --> 00:41:44,000
Creo que la forma en que probablemente solucionarlo es

547
00:41:44,000 --> 00:41:52,000
esto va a ser un char *, lo que estamos regresando,

548
00:41:52,000 --> 00:41:55,000
sea ​​cual sea su nombre de la variable quiere ser.

549
00:41:55,000 --> 00:42:02,000
Entonces queremos mod cabeza por nuestra capacidad

550
00:42:02,000 --> 00:42:10,000
y luego regresar ret.

551
00:42:10,000 --> 00:42:14,000
Mucha gente de aquí se podría hacer-

552
00:42:14,000 --> 00:42:19,000
Este es el caso de-usted ver a la gente hacer si la cabeza

553
00:42:19,000 --> 00:42:29,000
es mayor que la capacidad, hacer la cabeza - la capacidad.

554
00:42:29,000 --> 00:42:36,000
Y eso es sólo trabajar en torno a lo que es mod.

555
00:42:36,000 --> 00:42:41,000
Jefe mod = capacidad es mucho más limpio

556
00:42:41,000 --> 00:42:51,000
de una envoltura alrededor de si la cabeza más grande que la cabeza de capacidad - capacidad.

557
00:42:51,000 --> 00:42:56,000
>> ¿Preguntas?

558
00:42:56,000 --> 00:43:02,000
Bueno, lo último que nos queda es nuestra lista enlazada.

559
00:43:02,000 --> 00:43:07,000
Puede ser utilizado para algunos de los comportamientos lista enlazada si lo has hecho

560
00:43:07,000 --> 00:43:11,000
listas enlazadas en las tablas hash, si se hizo una tabla hash.

561
00:43:11,000 --> 00:43:15,000
Recomiendo hacer una tabla hash.

562
00:43:15,000 --> 00:43:17,000
Es posible que ya han hecho un trie,

563
00:43:17,000 --> 00:43:23,000
sino que trata son más difíciles.

564
00:43:23,000 --> 00:43:27,000
En teoría, son asintóticamente mejor.

565
00:43:27,000 --> 00:43:30,000
Pero basta con ver la gran pizarra,

566
00:43:30,000 --> 00:43:35,000
y trata de no hacer mejor, y ocupan más memoria.

567
00:43:35,000 --> 00:43:43,000
Todo lo relacionado intenta termina siendo peor para un trabajo más.

568
00:43:43,000 --> 00:43:49,000
Es lo que David Malan solución siempre es

569
00:43:49,000 --> 00:43:56,000
¿Siempre posts su solución trie, y vamos a ver donde actualmente está.

570
00:43:56,000 --> 00:44:00,000
Lo que él estaba bajo, David J?

571
00:44:00,000 --> 00:44:06,000
Es n º 18, de modo que no es terriblemente malo,

572
00:44:06,000 --> 00:44:09,000
y que va a ser uno de los mejores intentos que se pueda imaginar

573
00:44:09,000 --> 00:44:17,000
o uno de los mejores trata de un trie.

574
00:44:17,000 --> 00:44:23,000
¿No es siquiera su solución original?

575
00:44:23,000 --> 00:44:29,000
Me siento como trie soluciones tienden a ser más en este rango de uso de memoria RAM.

576
00:44:29,000 --> 00:44:33,000
>> Ve a la parte superior, y el uso de la memoria RAM es de un solo dígito.

577
00:44:33,000 --> 00:44:36,000
Ir hacia el fondo, y luego se empiezan a ver intenta

578
00:44:36,000 --> 00:44:41,000
donde se obtiene el uso de RAM absolutamente masiva,

579
00:44:41,000 --> 00:44:45,000
y tries son más difíciles.

580
00:44:45,000 --> 00:44:53,000
No del todo, pero vale la pena una experiencia educativa si se hizo una.

581
00:44:53,000 --> 00:44:56,000
Lo último es la lista enlazada,

582
00:44:56,000 --> 00:45:04,000
y estas tres cosas, pilas, colas y listas enlazadas,

583
00:45:04,000 --> 00:45:09,000
cualquier cosa futuro lo que haces en la informática

584
00:45:09,000 --> 00:45:12,000
asumirá que tiene familiaridad con estas cosas.

585
00:45:12,000 --> 00:45:19,000
Ellos son tan fundamental para todo.

586
00:45:19,000 --> 00:45:25,000
>> Listas enlazadas, y aquí tenemos una lista ligada simple va a ser nuestra implementación.

587
00:45:25,000 --> 00:45:34,000
¿Qué significa enlace simple en comparación con doblemente enlazada? Sí.

588
00:45:34,000 --> 00:45:37,000
[Estudiante] sólo apunta al siguiente puntero en lugar de los punteros,

589
00:45:37,000 --> 00:45:39,000
como la que le precede y el que le sigue.

590
00:45:39,000 --> 00:45:44,000
Sí, ¿y en formato de imagen, ¿qué he hecho?

591
00:45:44,000 --> 00:45:48,000
Tengo dos cosas. Tengo imagen e imagen.

592
00:45:48,000 --> 00:45:51,000
En formato de imagen, nuestra lista ligada simple,

593
00:45:51,000 --> 00:45:57,000
inevitablemente, tenemos algún tipo de puntero a la cabeza de la lista,

594
00:45:57,000 --> 00:46:02,000
y luego dentro de la lista, sólo tenemos punteros,

595
00:46:02,000 --> 00:46:05,000
y tal vez esto apunta a null.

596
00:46:05,000 --> 00:46:08,000
Va a ser un dibujo típico de una lista ligada sencilla.

597
00:46:08,000 --> 00:46:14,000
Una lista doblemente enlazada, puede ir hacia atrás.

598
00:46:14,000 --> 00:46:19,000
Si te doy un nodo en la lista, entonces necesariamente puede llegar a

599
00:46:19,000 --> 00:46:23,000
cualquier otro nodo en la lista si se trata de una lista doblemente enlazada.

600
00:46:23,000 --> 00:46:27,000
Pero si usted consigue el tercer nodo de la lista y se trata de una lista ligada simple,

601
00:46:27,000 --> 00:46:30,000
hay manera de que nunca va a llegar a los nodos de primera y segunda.

602
00:46:30,000 --> 00:46:34,000
Y hay ventajas e inconvenientes, y uno una evidente

603
00:46:34,000 --> 00:46:42,000
Se le ocupan más tamaño, y hay que perder de vista que estas cosas están apuntando ahora.

604
00:46:42,000 --> 00:46:49,000
Pero sólo se preocupan por enlace simple.

605
00:46:49,000 --> 00:46:53,000
>> Un par de cosas que vamos a tener que implementar.

606
00:46:53,000 --> 00:47:00,000
El nodo typedef struct, int i: struct nodo * siguiente; nodo.

607
00:47:00,000 --> 00:47:09,000
Eso typedef debe ser quemado en sus mentes.

608
00:47:09,000 --> 00:47:14,000
Quiz 1 debe ser como dar un typedef de un nodo de lista enlazada,

609
00:47:14,000 --> 00:47:18,000
y usted debería ser capaz de hacer garabatos que inmediatamente abajo

610
00:47:18,000 --> 00:47:22,000
sin siquiera pensar en ello.

611
00:47:22,000 --> 00:47:27,000
Supongo que un par de preguntas, ¿por qué necesitamos struct aquí?

612
00:47:27,000 --> 00:47:32,000
¿Por qué no podemos decir * nodo?

613
00:47:32,000 --> 00:47:35,000
[Estudiante] [inaudible]

614
00:47:35,000 --> 00:47:38,000
Si.

615
00:47:38,000 --> 00:47:44,000
La única cosa que define un nodo como una cosa

616
00:47:44,000 --> 00:47:47,000
es el propio typedef.

617
00:47:47,000 --> 00:47:55,000
Pero a partir de este momento, cuando estamos como el análisis a través de esta definición de nodo estructura,

618
00:47:55,000 --> 00:48:01,000
no hemos terminado nuestro typedef todavía, así que desde el typedef no ha terminado,

619
00:48:01,000 --> 00:48:05,000
nodo no existe.

620
00:48:05,000 --> 00:48:12,000
Pero struct nodo hace, y este nodo aquí,

621
00:48:12,000 --> 00:48:14,000
esto también podría ser llamado cualquier otra cosa.

622
00:48:14,000 --> 00:48:16,000
Esto podría llamarse n.

623
00:48:16,000 --> 00:48:19,000
Se podría llamar nodo de la lista enlazada.

624
00:48:19,000 --> 00:48:21,000
Se podría llamar cualquier cosa.

625
00:48:21,000 --> 00:48:26,000
Pero este nodo de estructura tiene que ser llamado lo mismo que este nodo de estructura.

626
00:48:26,000 --> 00:48:29,000
Lo que usted llama esto tiene que ser también aquí,

627
00:48:29,000 --> 00:48:32,000
y de modo que también responde al segundo punto de la cuestión

628
00:48:32,000 --> 00:48:37,000
razón por la cual, muchas veces, cuando usted ve las estructuras y typedefs de las estructuras,

629
00:48:37,000 --> 00:48:42,000
podrás ver las estructuras anónimas donde usted acaba de ver typedef struct,

630
00:48:42,000 --> 00:48:47,000
implementación de estructura, diccionario, o lo que sea.

631
00:48:47,000 --> 00:48:51,000
>> ¿Por qué aquí tenemos que decir nodo?

632
00:48:51,000 --> 00:48:54,000
¿Por qué no puede ser una struct anónimo?

633
00:48:54,000 --> 00:48:56,000
Es casi la misma respuesta.

634
00:48:56,000 --> 00:48:58,000
[Estudiante] Es necesario hacer referencia a ella en la estructura.

635
00:48:58,000 --> 00:49:04,000
Sí, dentro de la estructura, es necesario hacer referencia a la propia estructura.

636
00:49:04,000 --> 00:49:10,000
Si usted no da la estructura de un nombre, si es un struct anónimo, no se puede hacer referencia a ella.

637
00:49:10,000 --> 00:49:17,000
Y por último, estos no deben ser todo lo sencillo algo,

638
00:49:17,000 --> 00:49:20,000
y ellos le ayudarán a darse cuenta de que si estás escribiendo esto

639
00:49:20,000 --> 00:49:24,000
que usted está haciendo algo mal si este tipo de cosas no tienen sentido.

640
00:49:24,000 --> 00:49:28,000
Por último, pero no menos importante, ¿por qué tiene esto que ser * struct nodo?

641
00:49:28,000 --> 00:49:34,000
¿Por qué no pueden simplemente ser struct nodo siguiente?

642
00:49:34,000 --> 00:49:37,000
[Estudiante] Puntero a la estructura siguiente.

643
00:49:37,000 --> 00:49:39,000
Eso es inevitable lo que queremos.

644
00:49:39,000 --> 00:49:42,000
¿Por qué no podía ser de struct nodo siguiente?

645
00:49:42,000 --> 00:49:50,000
¿Por qué tiene que ser nodo * siguiente estructura? Si.

646
00:49:50,000 --> 00:49:53,000
[Estudiante] Es como un bucle infinito.

647
00:49:53,000 --> 00:49:55,000
Si.

648
00:49:55,000 --> 00:49:57,000
[Estudiante] Todo sería en uno.

649
00:49:57,000 --> 00:50:02,000
Sí, sólo pensar en lo que haríamos tamaño o algo así.

650
00:50:02,000 --> 00:50:08,000
Tamaño de una estructura es básicamente + o - algún patrón aquí o allá.

651
00:50:08,000 --> 00:50:15,000
Es, básicamente, va a ser la suma de los tamaños de las cosas en la estructura.

652
00:50:15,000 --> 00:50:18,000
Este derecho aquí, sin cambiar nada, el tamaño va a ser fácil.

653
00:50:18,000 --> 00:50:24,000
Tamaño de nodo struct va a ser el tamaño de i + de tamaño próximo.

654
00:50:24,000 --> 00:50:27,000
Tamaño de i va a ser 4. Tamaño de la que viene va a ser 4.

655
00:50:27,000 --> 00:50:30,000
Tamaño de nodo struct va a ser 8.

656
00:50:30,000 --> 00:50:34,000
Si no tenemos el *, pensando en sizeof,

657
00:50:34,000 --> 00:50:37,000
a continuación, sizeof (i) va a ser 4.

658
00:50:37,000 --> 00:50:43,000
Tamaño de nodo struct siguiente va a ser el tamaño de i + tamaño de nodo struct siguiente

659
00:50:43,000 --> 00:50:46,000
+ Tamaño de i + tamaño de struct nodo siguiente.

660
00:50:46,000 --> 00:50:55,000
Sería una recursión infinita de nodos.

661
00:50:55,000 --> 00:51:00,000
Por ello, es así como las cosas tienen que ser.

662
00:51:00,000 --> 00:51:03,000
>> Una vez más, sin duda que memorizar,

663
00:51:03,000 --> 00:51:06,000
o por lo menos lo entiendo bastante que usted puede ser capaz de

664
00:51:06,000 --> 00:51:12,000
razón por lo que debe ser similar.

665
00:51:12,000 --> 00:51:14,000
Las cosas que vamos a querer implementar.

666
00:51:14,000 --> 00:51:18,000
Si la longitud de la lista-

667
00:51:18,000 --> 00:51:21,000
usted podría engañar y mantener en torno a un

668
00:51:21,000 --> 00:51:24,000
longitud global o algo, pero no vamos a hacer eso.

669
00:51:24,000 --> 00:51:28,000
Vamos a contar la longitud de la lista.

670
00:51:28,000 --> 00:51:34,000
Hemos contiene, por lo que, básicamente, como una búsqueda,

671
00:51:34,000 --> 00:51:41,000
así que tenemos una lista enlazada de enteros para ver si este entero está en la lista enlazada.

672
00:51:41,000 --> 00:51:44,000
Anteponer se va a insertar en el comienzo de la lista.

673
00:51:44,000 --> 00:51:46,000
Append se va a insertar al final.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted se va a insertar en la posición de la lista ordenada.

675
00:51:53,000 --> 00:52:01,000
Tipo de Insert_sorted asume que nunca ha utilizado anteponer o anexar en malos pasos.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted cuando estás implementando insert_sorted-

677
00:52:09,000 --> 00:52:13,000
digamos que tenemos nuestra lista enlazada.

678
00:52:13,000 --> 00:52:18,000
Esto es lo que actualmente parece, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
Quiero insertar 3, así que siempre que la lista en sí ya está ordenado,

680
00:52:24,000 --> 00:52:27,000
es fácil de encontrar en 3 pertenece.

681
00:52:27,000 --> 00:52:29,000
Empiezo a 2.

682
00:52:29,000 --> 00:52:32,000
De acuerdo, 3 es mayor que 2, así que quiero seguir adelante.

683
00:52:32,000 --> 00:52:35,000
Oh, 4 es demasiado grande, así que sé 3 va a ir entre 2 y 4,

684
00:52:35,000 --> 00:52:39,000
y tengo que arreglar los punteros y todas esas cosas.

685
00:52:39,000 --> 00:52:43,000
Pero si no nos utilicen exclusivamente insert_sorted,

686
00:52:43,000 --> 00:52:50,000
como vamos a decir que anteponer 6,

687
00:52:50,000 --> 00:52:55,000
entonces mi lista enlazada se va a convertir esto.

688
00:52:55,000 --> 00:53:01,000
Ahora no tiene sentido, así que para insert_sorted, sólo puede asumir

689
00:53:01,000 --> 00:53:04,000
que la lista está ordenada, a pesar de que existen operaciones

690
00:53:04,000 --> 00:53:09,000
que puede hacer que no se clasifican, y eso es todo.

691
00:53:09,000 --> 00:53:20,000
Encuentre un útil insert-esas son las cosas principales que usted va a tener que poner en práctica.

692
00:53:20,000 --> 00:53:24,000
>> Por ahora, tome un minuto para hacer la longitud y contiene,

693
00:53:24,000 --> 00:53:30,000
y los que deben ser relativamente rápida.

694
00:53:41,000 --> 00:53:48,000
Al acercarse la hora de cierre, por lo que nadie tiene nada para largo o contiene?

695
00:53:48,000 --> 00:53:50,000
Van a ser casi idénticos.

696
00:53:50,000 --> 00:53:57,000
[Estudiante] Longitud.

697
00:53:57,000 --> 00:54:01,000
Vamos a ver, a revisión.

698
00:54:01,000 --> 00:54:04,000
Bien.

699
00:54:12,000 --> 00:54:15,000
Usted quiere explicar?

700
00:54:15,000 --> 00:54:21,000
[Estudiante] Acabo de crear un nodo puntero e inicializarla a la primera, que es nuestra variable global,

701
00:54:21,000 --> 00:54:27,000
y luego compruebo para ver si es nulo, así que no te dan una falla seg y devolver 0 si ese es el caso.

702
00:54:27,000 --> 00:54:34,000
De lo contrario, recorrer, hacer el seguimiento de dentro entera

703
00:54:34,000 --> 00:54:38,000
cuántas veces me he accedido al siguiente elemento de la lista

704
00:54:38,000 --> 00:54:43,000
y en la operación de incremento misma también acceso a ese elemento real,

705
00:54:43,000 --> 00:54:47,000
y entonces yo continuamente hacer el cheque para ver si es nulo,

706
00:54:47,000 --> 00:54:56,000
y si es nulo, entonces se aborta y sólo devuelve el número de elementos que he accedido.

707
00:54:56,000 --> 00:55:01,000
>> [Rob B.] ¿Alguien tiene algún comentario sobre cualquier cosa?

708
00:55:01,000 --> 00:55:06,000
Esto se ve muy bien la corrección sabio.

709
00:55:06,000 --> 00:55:10,000
[Estudiante] No creo que se necesita el nodo == null.

710
00:55:10,000 --> 00:55:13,000
Sí, ¿y si el nodo == 0 devuelve null.

711
00:55:13,000 --> 00:55:18,000
Pero si el nodo == null entonces esta-oh, hay un problema de corrección.

712
00:55:18,000 --> 00:55:23,000
Era justo que estés i volver, pero no es de alcance en estos momentos.

713
00:55:23,000 --> 00:55:30,000
Sólo tiene int i, por lo que = 0.

714
00:55:30,000 --> 00:55:34,000
Pero si el nodo es nulo, entonces yo todavía va a ser 0,

715
00:55:34,000 --> 00:55:39,000
y vamos a devolver 0, por lo que este caso es idéntico.

716
00:55:39,000 --> 00:55:48,000
Otra cosa común es mantener la declaración

717
00:55:48,000 --> 00:55:51,000
de nodo dentro del bucle for.

718
00:55:51,000 --> 00:55:54,000
Se podría decir que-oh, no.

719
00:55:54,000 --> 00:55:56,000
Vamos a mantenerlo como este.

720
00:55:56,000 --> 00:55:59,000
Probablemente me pondría int i = 0 aquí,

721
00:55:59,000 --> 00:56:05,000
entonces el nodo node = * primero aquí.

722
00:56:05,000 --> 00:56:11,000
Y esta es probablemente la forma-deshacerse de esto ahora.

723
00:56:11,000 --> 00:56:14,000
Esta es probablemente la forma en que lo hubiera escrito.

724
00:56:14,000 --> 00:56:21,000
Usted podría también-verlo así.

725
00:56:21,000 --> 00:56:25,000
Esta estructura de bucle aquí

726
00:56:25,000 --> 00:56:30,000
debe ser casi tan natural para ti como para int i = 0

727
00:56:30,000 --> 00:56:33,000
i es menor que la longitud de array i + +.

728
00:56:33,000 --> 00:56:38,000
Si así es como iterar sobre una matriz, así es como recorrer un lista enlazada.

729
00:56:38,000 --> 00:56:45,000
>> Esta debe ser la naturaleza segundos en algún momento.

730
00:56:45,000 --> 00:56:50,000
Con esto en mente, esto va a ser casi lo mismo.

731
00:56:50,000 --> 00:56:57,000
Usted va a querer para iterar sobre una lista enlazada.

732
00:56:57,000 --> 00:57:02,000
Si el nodo-No tengo ni idea de cuál es el valor que se llama.

733
00:57:02,000 --> 00:57:04,000
Nodo i.

734
00:57:04,000 --> 00:57:15,000
Si el valor en el nodo i = return true, y eso es todo.

735
00:57:15,000 --> 00:57:18,000
Tenga en cuenta que la única manera que alguna vez vuelvo falso

736
00:57:18,000 --> 00:57:23,000
si es iterar sobre la lista entera vinculados y nunca devolver true,

737
00:57:23,000 --> 00:57:29,000
así que eso es lo que hace.

738
00:57:29,000 --> 00:57:36,000
Como nota lateral, es probable que no se llega a añadir o anteponer.

739
00:57:36,000 --> 00:57:39,000
>> Última nota rápida.

740
00:57:39,000 --> 00:57:52,000
Si usted ve la palabra clave static, por lo que vamos a decir static int cuenta = 0,

741
00:57:52,000 --> 00:57:56,000
entonces lo que hacemos cuenta + +, básicamente se puede pensar en ella como una variable global,

742
00:57:56,000 --> 00:58:00,000
a pesar de que acabo de decir no es así como vamos a implementar longitud.

743
00:58:00,000 --> 00:58:06,000
Estoy haciendo esto aquí, y luego contar + +.

744
00:58:06,000 --> 00:58:11,000
De cualquier manera que podamos entrar en un nodo en la lista enlazada estamos incrementando nuestra cuenta.

745
00:58:11,000 --> 00:58:15,000
El punto de esto es lo que significa la palabra clave static.

746
00:58:15,000 --> 00:58:20,000
Si sólo tuviera int count = 0 que sería un habitual variable global edad.

747
00:58:20,000 --> 00:58:25,000
¿Qué medios estático int cuenta es que se trata de una variable global de este archivo.

748
00:58:25,000 --> 00:58:28,000
Es imposible para algún otro archivo,

749
00:58:28,000 --> 00:58:34,000
gusta pensar en pset 5, si usted ha comenzado.

750
00:58:34,000 --> 00:58:39,000
Usted tiene tanto speller.c, y usted tiene dictionary.c,

751
00:58:39,000 --> 00:58:42,000
y si lo que declara una cosa global, entonces cualquier cosa en speller.c

752
00:58:42,000 --> 00:58:45,000
Se puede acceder en dictionary.c y viceversa.

753
00:58:45,000 --> 00:58:48,000
Las variables globales son accesibles en cualquier archivo. C,

754
00:58:48,000 --> 00:58:54,000
pero las variables estáticas sólo se puede acceder desde el propio archivo,

755
00:58:54,000 --> 00:59:01,000
así que dentro de corrector ortográfico o en el interior de dictionary.c,

756
00:59:01,000 --> 00:59:06,000
esto es un poco cómo iba a declarar mi variable para el tamaño de mi matriz

757
00:59:06,000 --> 00:59:10,000
o el tamaño de mi número de palabras en el diccionario.

758
00:59:10,000 --> 00:59:15,000
Puesto que no es necesario declarar una variable global que nadie tiene acceso,

759
00:59:15,000 --> 00:59:18,000
En realidad sólo se preocupan por él para mis propios fines.

760
00:59:18,000 --> 00:59:21,000
>> Lo bueno de esto es también la materia colisión nombre completo.

761
00:59:21,000 --> 00:59:27,000
Si algún otro archivo intenta utilizar una variable global llamada recuento, las cosas van mal, muy mal,

762
00:59:27,000 --> 00:59:33,000
por lo que esta bien mantiene las cosas seguras, y sólo se puede acceder a ella,

763
00:59:33,000 --> 00:59:38,000
y nadie más puede hacerlo, y si alguien se declara una variable global llamada recuento

764
00:59:38,000 --> 00:59:43,000
entonces no va a interferir con la variable estática denominada conteo.

765
00:59:43,000 --> 00:59:47,000
Eso es lo que es estático. Es una variable global de archivos.

766
00:59:47,000 --> 00:59:52,000
>> Las preguntas sobre cualquier cosa?

767
00:59:52,000 --> 00:59:59,000
Todo listo. Bye.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]