1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [Oddelek 6] [Več Udobna]

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

3
00:00:04,000 --> 00:00:09,000
[To je CS50.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> Mi lahko odpravite do našega oddelka vprašanj.

5
00:00:11,000 --> 00:00:17,000
Sem poslal URL za prostor poprej.

6
00:00:17,000 --> 00:00:22,000
Začetek del vprašanj, pravijo,

7
00:00:22,000 --> 00:00:26,000
Očitno nisem povsem unsick, je zelo enostavno vprašanje

8
00:00:26,000 --> 00:00:28,000
za kaj se valgrind?

9
00:00:28,000 --> 00:00:30,000
Kaj valgrind storiti?

10
00:00:30,000 --> 00:00:34,000
Kdor bi rad povedal, kaj valgrind ne?

11
00:00:34,000 --> 00:00:36,000
[Študent] Preveri spomin pušča.

12
00:00:36,000 --> 00:00:41,000
Ja, valgrind je splošno spomin skladiščnik.

13
00:00:41,000 --> 00:00:44,000
Prav na koncu, vam pove, če imate spomin razpoka,

14
00:00:44,000 --> 00:00:49,000
kar je predvsem tisto, kar smo jo uporabi za, ker če hočeš

15
00:00:49,000 --> 00:00:54,000
pa tudi v problemski sklop, ali če želite

16
00:00:54,000 --> 00:00:59,000
priti na veliki ladji, morate imeti nobenih spomin razpoka sploh,

17
00:00:59,000 --> 00:01:01,000
in v primeru, da imate pomnilnika, ki ga ni mogoče najti,

18
00:01:01,000 --> 00:01:04,000
Prav tako ne pozabite, da vsakič, ko odprete datoteko

19
00:01:04,000 --> 00:01:07,000
in če ga ne zaprejo, to je pomnilnika.

20
00:01:07,000 --> 00:01:10,000
>> Veliko ljudi, ki iščejo nekaj vozlišče, da oni ne sprosti

21
00:01:10,000 --> 00:01:15,000
če res, da ni zaprl slovar v prvi fazi.

22
00:01:15,000 --> 00:01:19,000
Prav tako vam pove, ali imate veljaven bere ali piše,

23
00:01:19,000 --> 00:01:22,000
kar pomeni, če ste poskušali določiti vrednost

24
00:01:22,000 --> 00:01:26,000
To je po koncu kup in to ne zgodi, da SEG napake

25
00:01:26,000 --> 00:01:30,000
ampak valgrind ga ujame, saj ne bi bilo treba dejansko obstaja pisni obliki,

26
00:01:30,000 --> 00:01:33,000
in tako zagotovo ne bi imeli kaj od naštetega ne.

27
00:01:33,000 --> 00:01:38,000
Kako uporabljati valgrind?

28
00:01:38,000 --> 00:01:42,000
Kako uporabljati valgrind?

29
00:01:42,000 --> 00:01:45,000
>> To je splošno vprašanje

30
00:01:45,000 --> 00:01:49,000
vrsta prost in pogled na izhod.

31
00:01:49,000 --> 00:01:51,000
Proizvodnja je zasenčil veliko časa.

32
00:01:51,000 --> 00:01:54,000
Tam je tudi zanimivo napake, kjer, če imate nekaj hudo narobe stvar

33
00:01:54,000 --> 00:01:59,000
dogaja v krogu, nato pa bo na koncu rekel: "To je zame veliko napak.

34
00:01:59,000 --> 00:02:03,000
Jaz sem nehala šteti zdaj. "

35
00:02:03,000 --> 00:02:08,000
To je v bistvu tekstovni izhod, da boste morali razčleniti.

36
00:02:08,000 --> 00:02:13,000
Na koncu bo povedal vse spomin razpoka, ki jih imate,

37
00:02:13,000 --> 00:02:16,000
koliko blokov, ki so lahko koristne, saj

38
00:02:16,000 --> 00:02:20,000
če je en blok unfreed, potem je običajno lažje najti

39
00:02:20,000 --> 00:02:23,000
kot 1.000 ulic unfreed.

40
00:02:23,000 --> 00:02:26,000
1000 bloki unfreed verjetno pomeni, da ne boš sprostila

41
00:02:26,000 --> 00:02:30,000
vaše povezani seznam ustrezno ali kaj.

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

43
00:02:32,000 --> 00:02:35,000
>> Zdaj imamo del vprašanj,

44
00:02:35,000 --> 00:02:38,000
ki vam ni treba prenesti.

45
00:02:38,000 --> 00:02:41,000
Lahko kliknete na moje ime in jih potegnite navzgor v prostoru.

46
00:02:41,000 --> 00:02:44,000
Sedaj kliknite na meni.

47
00:02:44,000 --> 00:02:46,000
Revizija 1 bo sklad, ki smo 1. dela.

48
00:02:46,000 --> 00:02:55,000
Revizija 2 bo čakalna vrsta in revizija 3 bodo posamič povezani seznam.

49
00:02:55,000 --> 00:02:58,000
Speljevanje z našo dimnika.

50
00:02:58,000 --> 00:03:02,000
Kot piše tukaj, sklad je eden od najbolj osnovne,

51
00:03:02,000 --> 00:03:07,000
temeljne podatkovne strukture v računalništvu.

52
00:03:07,000 --> 00:03:11,000
Zelo prototip primer

53
00:03:11,000 --> 00:03:13,000
kup plošč v jedilnici.

54
00:03:13,000 --> 00:03:16,000
To je v bistvu, ko ste se predstavili kup,

55
00:03:16,000 --> 00:03:20,000
kdo bo rekel: "Oh, kot kup plošč."

56
00:03:20,000 --> 00:03:22,000
Ti kup pladnje navzgor.

57
00:03:22,000 --> 00:03:24,000
Potem ko greš za vleko pladenj

58
00:03:24,000 --> 00:03:31,000
prvi pladenj, da je pridobivanje potegnil je zadnja, ki je bila dana na kupu.

59
00:03:31,000 --> 00:03:34,000
Sveženj prav tako, kot da tukaj piše,

60
00:03:34,000 --> 00:03:37,000
imamo segment pomnilnika se imenuje sklad.

61
00:03:37,000 --> 00:03:40,000
In zakaj ga imenujejo dimnik?

62
00:03:40,000 --> 00:03:42,000
>> Ker se kot kup strukture podatkov,

63
00:03:42,000 --> 00:03:46,000
ga potisne in pops dimnih okvirjev na sklad,

64
00:03:46,000 --> 00:03:53,000
če zložaja okvirji so kot poseben poziv funkcije.

65
00:03:53,000 --> 00:03:57,000
In kot kup, boste vedno morali vrniti

66
00:03:57,000 --> 00:04:03,000
od klic funkcije, preden lahko prideš v nižjih okvirjev dimnika znova.

67
00:04:03,000 --> 00:04:08,000
Ne, ne moreš imajo glavno call foo bar in bar se vrnete v glavni neposredno.

68
00:04:08,000 --> 00:04:14,000
Vedno moraš na pravi kup potiska in živahen.

69
00:04:14,000 --> 00:04:18,000
Obe dejavnosti, kot sem rekel, je push in pop.

70
00:04:18,000 --> 00:04:20,000
Tisti, ki so univerzalni pogoji.

71
00:04:20,000 --> 00:04:26,000
Vedeti morate push in pop v smislu nizov ne glede na to, kaj.

72
00:04:26,000 --> 00:04:28,000
Bomo videli, čakalne vrste so nekako drugačni.

73
00:04:28,000 --> 00:04:32,000
To sploh nima univerzalnega izraza, ampak push in pop so univerzalni za skladih.

74
00:04:32,000 --> 00:04:34,000
Push je pravkar dal na kup.

75
00:04:34,000 --> 00:04:37,000
Pop je vzlet sklada.

76
00:04:37,000 --> 00:04:43,000
In vidimo, tukaj imamo typedef struct stack,

77
00:04:43,000 --> 00:04:46,000
tako da imamo char nizi **.

78
00:04:46,000 --> 00:04:51,000
Ne bodi prestrašen z vsemi **.

79
00:04:51,000 --> 00:04:54,000
To se bo končalo niz nizov

80
00:04:54,000 --> 00:04:58,000
ali niz kazalcev na znake, kjer je to

81
00:04:58,000 --> 00:05:00,000
kazalci na znake ponavadi strune.

82
00:05:00,000 --> 00:05:05,000
Ni nujno, da so strune, ampak tukaj gredo za godala.

83
00:05:05,000 --> 00:05:08,000
>> Imamo vrsto nizov.

84
00:05:08,000 --> 00:05:14,000
Imamo velikosti, kar pomeni, koliko elementov je trenutno na sklad,

85
00:05:14,000 --> 00:05:19,000
in potem imamo sposobnost, ki je, koliko elementov je lahko na kupu.

86
00:05:19,000 --> 00:05:22,000
Kapaciteta naj bi začeli v nekaj več kot 1,

87
00:05:22,000 --> 00:05:27,000
ampak velikost se dogaja, da začnete kot 0.

88
00:05:27,000 --> 00:05:36,000
Zdaj pa so v bistvu tri različne načine si lahko zamislite dimnika.

89
00:05:36,000 --> 00:05:39,000
No, verjetno obstaja več, vendar pa sta dva glavna načina

90
00:05:39,000 --> 00:05:43,000
ga lahko izvaja z uporabo polja, ali pa jo izvaja z uporabo povezani seznam.

91
00:05:43,000 --> 00:05:48,000
Povezani seznam je nekako nepomembno, da bi nizov iz.

92
00:05:48,000 --> 00:05:51,000
To je zelo enostavno narediti kup uporabo povezani seznam,

93
00:05:51,000 --> 00:05:55,000
tako da tukaj, bomo narediti kup z nizi,

94
00:05:55,000 --> 00:05:59,000
in nato z uporabo polja, tam je tudi dva načina, kako lahko mislijo o tem.

95
00:05:59,000 --> 00:06:01,000
Prej, ko sem rekel, da bomo imeli zmogljivosti za sklad,

96
00:06:01,000 --> 00:06:04,000
tako da bomo lahko fit element na sklad.

97
00:06:04,000 --> 00:06:09,000
>> Tisti, način, kako se lahko zgodi, je, kot ko ste zadeli 10 elementov, potem ste končali.

98
00:06:09,000 --> 00:06:13,000
Morda veš, da je zgornja meja 10 stvari na svetu

99
00:06:13,000 --> 00:06:16,000
Nikoli ne boste imeli več kot 10 stvari na kup,

100
00:06:16,000 --> 00:06:20,000
v tem primeru lahko imajo zgornjo mejo na velikost vašega dimnika.

101
00:06:20,000 --> 00:06:23,000
Ali pa imaš vaš dimnik mora brezmejna,

102
00:06:23,000 --> 00:06:27,000
če pa delaš niz, kar pomeni, da vsak čas ste zadeli 10 elementov,

103
00:06:27,000 --> 00:06:29,000
potem boste morali, da zraste do 20 elementov, in ko ste zadeli 20 elementov,

104
00:06:29,000 --> 00:06:33,000
boste morali za rast vašega array 30 elementi ali 40 elementov.

105
00:06:33,000 --> 00:06:37,000
Vi boste potrebovali za povečanje zmogljivosti, ki je tisto, kar bomo na tem mestu.

106
00:06:37,000 --> 00:06:40,000
Vsakič smo dosegli največjo velikost našega dimnika,

107
00:06:40,000 --> 00:06:46,000
ko smo potisnite nekaj drugega naprej, bomo morali povečati zmogljivosti.

108
00:06:46,000 --> 00:06:50,000
Tukaj smo pritisk je deklariran kot bool pritiskom (char * str).

109
00:06:50,000 --> 00:06:54,000
Char * str je niz, ki smo si prizadevajo na kupu,

110
00:06:54,000 --> 00:06:58,000
bool in samo pravi, ali nam je uspelo ali ne.

111
00:06:58,000 --> 00:07:00,000
>> Kako ne?

112
00:07:00,000 --> 00:07:04,000
Kaj je edina okoliščina, ki jo lahko zamislite

113
00:07:04,000 --> 00:07:07,000
, kjer bi se morali vrniti napačna?

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

115
00:07:09,000 --> 00:07:12,000
[Študent] Če je to polno in smo z uporabo omejujejo izvajanje.

116
00:07:12,000 --> 00:07:17,000
Ja, kako opredeliti, je odgovoril:

117
00:07:17,000 --> 00:07:23,000
če je poln in smo z uporabo omejene izvajanje.

118
00:07:23,000 --> 00:07:26,000
Potem bomo zagotovo vrne false.

119
00:07:26,000 --> 00:07:31,000
Takoj, ko bomo zadeli 10 stvari, v polju, ne moremo fit 11, zato se vrnemo false.

120
00:07:31,000 --> 00:07:32,000
Kaj pa, če je brezmejna to? Ja.

121
00:07:32,000 --> 00:07:38,000
Če ne morete razširiti paleto iz nekega razloga.

122
00:07:38,000 --> 00:07:43,000
Ja, spomin je omejen vir,

123
00:07:43,000 --> 00:07:51,000
in na koncu, če želimo ohraniti potiskajo stvari na kup, znova in znova,

124
00:07:51,000 --> 00:07:54,000
bomo poskušali dodeliti večjo paleto, da se prilega

125
00:07:54,000 --> 00:07:59,000
večja zmogljivost in malloc ali karkoli bomo s vrača false.

126
00:07:59,000 --> 00:08:02,000
No, malloc vrne null.

127
00:08:02,000 --> 00:08:05,000
>> Ne pozabite, vsak čas se kdaj poklicati malloc, morate biti preverjanje, da vidim, če je

128
00:08:05,000 --> 00:08:12,000
vrne za nične, ali pa, da je pravilnost odbitka.

129
00:08:12,000 --> 00:08:17,000
Ker želimo imeti neomejenem stack,

130
00:08:17,000 --> 00:08:21,000
edini primer, da bomo vračali napačno je, če skušamo

131
00:08:21,000 --> 00:08:26,000
povečanje zmogljivosti in malloc ali karkoli vrne false.

132
00:08:26,000 --> 00:08:30,000
Potem pop prevzema nobene utemeljitve,

133
00:08:30,000 --> 00:08:37,000
in vrne niz, ki je na vrhu dimnika.

134
00:08:37,000 --> 00:08:41,000
Karkoli je bilo nazadnje potisnilo na stack je tisto, pop se vrača,

135
00:08:41,000 --> 00:08:44,000
prav tako pa ga odstrani iz dimnika.

136
00:08:44,000 --> 00:08:50,000
In opazil, da se vrne null, če ni nič na kupu.

137
00:08:50,000 --> 00:08:53,000
Vedno je možno, da je sklad prazen.

138
00:08:53,000 --> 00:08:55,000
V Java, če ste navajeni na to, ali drugih jezikov,

139
00:08:55,000 --> 00:09:01,000
poskuša pop iz praznega dimnik lahko povzroči izjeme ali kaj podobnega.

140
00:09:01,000 --> 00:09:09,000
>> Toda v C, null je nekako veliko primerov, kako ravnamo s temi težavami.

141
00:09:09,000 --> 00:09:13,000
Vračanje nično je, kako bomo pomenilo, da je sklad prazen.

142
00:09:13,000 --> 00:09:16,000
Pripravili smo kodo, ki bo preizkusil vaš dimnik funkcionalnost,

143
00:09:16,000 --> 00:09:19,000
izvajanje push in pop.

144
00:09:19,000 --> 00:09:23,000
To ne bo veliko kode.

145
00:09:23,000 --> 00:09:40,000
Bom, pravzaprav, preden bomo to storili, namig, namig-

146
00:09:40,000 --> 00:09:44,000
Če še niste videli, malloc ni edina funkcija

147
00:09:44,000 --> 00:09:47,000
ki dodeljuje spomin na kup za vas.

148
00:09:47,000 --> 00:09:51,000
Obstaja družina Pos funkcij.

149
00:09:51,000 --> 00:09:53,000
Prvi je malloc, ki ste navajeni.

150
00:09:53,000 --> 00:09:56,000
Potem je tu še calloc, ki počne isto stvar kot knjižnične funkcije malloc,

151
00:09:56,000 --> 00:09:59,000
vendar bo nič, vse za vas.

152
00:09:59,000 --> 00:10:04,000
Če ste si kdaj želeli nastaviti vse na null po nekaj mallocing

153
00:10:04,000 --> 00:10:06,000
moral bi samo uporabljati calloc na prvem mestu, namesto pisanja

154
00:10:06,000 --> 00:10:09,000
zanka za nič ven celoten blok pomnilnika.

155
00:10:09,000 --> 00:10:15,000
>> Realloc je kot knjižnične funkcije malloc in ima veliko posebnih primerih,

156
00:10:15,000 --> 00:10:19,000
ampak v bistvu tisto, kar počne, je realloc

157
00:10:19,000 --> 00:10:24,000
je potrebno kazalec, ki je bila že dodeljena.

158
00:10:24,000 --> 00:10:27,000
Realloc je funkcija želite biti pozoren tukaj.

159
00:10:27,000 --> 00:10:31,000
Potrebno je kazalec, ki je že vrnil iz knjižnične funkcije malloc.

160
00:10:31,000 --> 00:10:35,000
Recimo, da zahteva od knjižnične funkcije malloc kazalec na 10 bajtov.

161
00:10:35,000 --> 00:10:38,000
Kasneje se zaveš, da je želel 20 bajtov,

162
00:10:38,000 --> 00:10:42,000
tako praviš na to realloc kazalec s 20 bajtov,

163
00:10:42,000 --> 00:10:47,000
in bo realloc samodejno kopiranje nad vsem, kar za vas.

164
00:10:47,000 --> 00:10:51,000
Če ste pravkar poklical malloc spet, kot sem blok 10 bajtov.

165
00:10:51,000 --> 00:10:53,000
Zdaj moram blok 20 bajtov,

166
00:10:53,000 --> 00:10:58,000
Torej, če sem malloc 20 bajtov, potem pa sem moral ročno kopirati v 10 bajtov iz prve stvari

167
00:10:58,000 --> 00:11:01,000
v drugo stvar in potem je prva stvar proste.

168
00:11:01,000 --> 00:11:04,000
Realloc bo poskrbel za vas.

169
00:11:04,000 --> 00:11:11,000
>> Obvestilo podpis se bo nična *

170
00:11:11,000 --> 00:11:15,000
ki je pravkar vrnil kazalec na blok pomnilnika,

171
00:11:15,000 --> 00:11:17,000
potem nična * ptr.

172
00:11:17,000 --> 00:11:22,000
Si lahko zamislite * praznim kot generično kazalca.

173
00:11:22,000 --> 00:11:27,000
Na splošno se nikoli ne ukvarjajo z * nična,

174
00:11:27,000 --> 00:11:30,000
vendar malloc se vrača na void *, in potem je samo uporablja kot

175
00:11:30,000 --> 00:11:34,000
to se dejansko dogaja, da je char *.

176
00:11:34,000 --> 00:11:37,000
Prejšnji void *, ki se je vrnil z knjižnične funkcije malloc

177
00:11:37,000 --> 00:11:41,000
Zdaj bo treba podati realloc, nato pa velikost

178
00:11:41,000 --> 00:11:49,000
je novo število bajtov, ki jih želite razporediti, tako da bo nova zmogljivost.

179
00:11:49,000 --> 00:11:57,000
Dal vam bom nekaj minut, in to v našem prostoru.

180
00:11:57,000 --> 00:12:02,000
Začnite z revizije 1.

181
00:12:16,000 --> 00:12:21,000
Jaz bom prenehati, ko upam, da o tem dovolj časa za izvajanje pritiska,

182
00:12:21,000 --> 00:12:24,000
in potem ti dam še en odmor narediti pop.

183
00:12:24,000 --> 00:12:27,000
Ampak to res ni veliko kode sploh.

184
00:12:27,000 --> 00:12:35,000
Najbolj koda je verjetno širi stvari, ki se širi zmogljivosti.

185
00:12:35,000 --> 00:12:39,000
Ok, ni pritiska, da je treba v celoti narejena,

186
00:12:39,000 --> 00:12:47,000
ampak tako dolgo, kot se počutite, kot da ste na pravi poti, to je dobro.

187
00:12:47,000 --> 00:12:53,000
>> Ima kdo kakšno kodo, se počutite udobno z mano vleče navzgor?

188
00:12:53,000 --> 00:12:59,000
Ja, bom, ampak ali ima kdo kakšno kodo, da lahko potegnili gor?

189
00:12:59,000 --> 00:13:05,000
Ok, lahko začnete, ga shranite, karkoli že je?

190
00:13:05,000 --> 00:13:09,000
Vedno pozabim ta korak.

191
00:13:09,000 --> 00:13:15,000
Ok, ki si ogleduje pritiskom,

192
00:13:15,000 --> 00:13:18,000
hočeš, da pojasni svojo kodo?

193
00:13:18,000 --> 00:13:24,000
[Študent] Najprej sem povečal velikost.

194
00:13:24,000 --> 00:13:28,000
Mislim, mogoče bi moral imeti, da, kljub temu, sem povečal velikost,

195
00:13:28,000 --> 00:13:31,000
in vidim, če je manjša od zmogljivosti.

196
00:13:31,000 --> 00:13:36,000
In če je to manj kot zmogljivost, sem dodati polja, ki jih že imajo.

197
00:13:36,000 --> 00:13:42,000
In če je ne bi, pomnožite zmogljivosti z 2,

198
00:13:42,000 --> 00:13:50,000
in sem prerazporedi strune niz nekaj z večjo velikostjo zmogljivosti zdaj.

199
00:13:50,000 --> 00:13:55,000
In če to ne uspe, bom povedal uporabnika in vrne false,

200
00:13:55,000 --> 00:14:04,000
in če je to v redu, potem pa sem dal niz v novem mestu.

201
00:14:04,000 --> 00:14:07,000
>> [Rob B.] Tudi obvestilo, da smo lepo bitni operaterja tukaj

202
00:14:07,000 --> 00:14:09,000
pomnoži z 2.

203
00:14:09,000 --> 00:14:11,000
Ne pozabite, levo premik se vedno dogaja, da se pomnoži z 2.

204
00:14:11,000 --> 00:14:15,000
Pravica do premika deli z 2 dokler ga ne pozabite, da to pomeni,

205
00:14:15,000 --> 00:14:18,000
delimo z 2 kot celo število deljeno z 2.

206
00:14:18,000 --> 00:14:20,000
Morda je odsekana 1 tukaj in tam.

207
00:14:20,000 --> 00:14:26,000
Toda premik levo po 1 se vedno dogaja, da se pomnožijo z 2,

208
00:14:26,000 --> 00:14:32,000
razen če prekoračitev meje iz celega števila, nato pa je ne bo.

209
00:14:32,000 --> 00:14:34,000
Komentar strani.

210
00:14:34,000 --> 00:14:39,000
Všeč mi je storiti, se to ne bo spremenilo kodiranje kakršen koli način,

211
00:14:39,000 --> 00:14:48,000
ampak mi je všeč, da narediš nekaj takega.

212
00:14:48,000 --> 00:14:51,000
To dejansko se dogaja, da je nekoliko daljši.

213
00:15:04,000 --> 00:15:08,000
Mogoče to ni popoln primer, da to dokažejo,

214
00:15:08,000 --> 00:15:14,000
ampak mi je všeč, da je v teh odsekih bloke,

215
00:15:14,000 --> 00:15:17,000
ok, če se to zgodi, če je, potem bom naredil nekaj,

216
00:15:17,000 --> 00:15:19,000
, nato pa se izvede funkcija.

217
00:15:19,000 --> 00:15:22,000
Ne rabim, da se pomaknite moje oči vse do konca funkcije

218
00:15:22,000 --> 00:15:25,000
da vidimo, kaj se zgodi po drugem.

219
00:15:25,000 --> 00:15:27,000
To je, če je to, če se zgodi, nato pa sem vrnil.

220
00:15:27,000 --> 00:15:30,000
Ima tudi lepo dodatno korist vsega tega preko

221
00:15:30,000 --> 00:15:33,000
Zdaj se nagne levo enkrat.

222
00:15:33,000 --> 00:15:40,000
Jaz ne potrebujete več, če boste kdaj v bližini smešno dolge proge,

223
00:15:40,000 --> 00:15:45,000
potem ti 4 bajte pomoč, pa tudi bolj levo je nekaj,

224
00:15:45,000 --> 00:15:48,000
manj obremenjeni vi počutili, če želite, v redu, moram zapomniti

225
00:15:48,000 --> 00:15:53,000
Jaz sem trenutno v while zanko notranji strani drugega notranjost za zanke.

226
00:15:53,000 --> 00:15:58,000
Kjerkoli lahko to narediš vrnitev takoj, mi je nekako všeč.

227
00:15:58,000 --> 00:16:05,000
To je povsem neobvezna in ni pričakovati, na kakršen koli način.

228
00:16:05,000 --> 00:16:12,000
>> [Študent] Če obstaja velikosti - v okvari stanju?

229
00:16:12,000 --> 00:16:19,000
Pred izpadom pogoj tu nismo realloc, tako da.

230
00:16:19,000 --> 00:16:22,000
Opazuj, kako v okvari stanju, domnevno

231
00:16:22,000 --> 00:16:26,000
če ne bomo free stuff kasneje, mi vedno dogaja, da ne

232
00:16:26,000 --> 00:16:29,000
ne glede na to, kolikokrat smo poskušali pritisniti nekaj.

233
00:16:29,000 --> 00:16:32,000
Če imamo potiskanje, smo ostali povečevanje velikosti,

234
00:16:32,000 --> 00:16:36,000
čeprav mi ne postavljajte predmetov na kupu.

235
00:16:36,000 --> 00:16:39,000
Ponavadi ne prirastek velikosti do

236
00:16:39,000 --> 00:16:43,000
ko smo uspešno jo položite na kup.

237
00:16:43,000 --> 00:16:50,000
Mi bi to naredil, recimo, bodisi tukaj in tukaj.

238
00:16:50,000 --> 00:16:56,000
In potem namesto da bi rekel s.size ≤ zmogljivosti, to je manj kot zmogljivosti,

239
00:16:56,000 --> 00:17:01,000
Samo zato, ker smo se preselili, če je bilo vse.

240
00:17:01,000 --> 00:17:07,000
>> In ne pozabite, da je edini kraj, da bi se lahko vrne false

241
00:17:07,000 --> 00:17:14,000
Tukaj je, kjer realloc vrne null,

242
00:17:14,000 --> 00:17:19,000
in če se zgodi, da se spomnite standardna napaka,

243
00:17:19,000 --> 00:17:22,000
Mogoče bi si, da je to primer, ko želite natisniti standardna napaka,

244
00:17:22,000 --> 00:17:26,000
Tako ovrednotenj stderr in ne le tiskanje neposredno na standardni izhod.

245
00:17:26,000 --> 00:17:31,000
Še enkrat, to ni pričakovati, če pa je napaka,

246
00:17:31,000 --> 00:17:41,000
vnesite printf, potem boste morda želeli, da bi bilo tiskanje na standardne napake namesto standardne ven.

247
00:17:41,000 --> 00:17:44,000
>> Kdor še kaj, da se seznani? Da.

248
00:17:44,000 --> 00:17:47,000
[Študent] Lahko greš čez [neslišno]?

249
00:17:47,000 --> 00:17:55,000
[Rob B.] Ja, dejansko binariness od tega, ali kaj je to?

250
00:17:55,000 --> 00:17:57,000
[Študent] Torej si jo pomnožimo z 2?

251
00:17:57,000 --> 00:17:59,000
[Rob B.] Ja, v bistvu.

252
00:17:59,000 --> 00:18:11,000
V binarnem zemljišča, smo vedno imamo niz številk.

253
00:18:11,000 --> 00:18:22,000
Premik to levo do 1. vstavi v bistvu je tukaj na desni strani.

254
00:18:22,000 --> 00:18:25,000
Nazaj na to, samo spomniti, da je vse, kar je v binarni

255
00:18:25,000 --> 00:18:28,000
je moč 2, tako da to predstavlja 2 do 0,

256
00:18:28,000 --> 00:18:30,000
Ta 2 na 1, to 2 k 2.

257
00:18:30,000 --> 00:18:33,000
Z vstavitvijo 0 do sedaj desni strani, samo premakniti vse več.

258
00:18:33,000 --> 00:18:38,000
Kar je bilo 2 do 0 je sedaj 2 na 1, 2 je za 2.

259
00:18:38,000 --> 00:18:41,000
Na desni strani, da se vstavi

260
00:18:41,000 --> 00:18:44,000
je nujno, da bo 0,

261
00:18:44,000 --> 00:18:46,000
ki ima smisel.

262
00:18:46,000 --> 00:18:49,000
Če ste kdaj pomnožimo s številko 2, pa se ne bo končala čudno,

263
00:18:49,000 --> 00:18:54,000
Tako naj bi 2 do kraja 0 0,

264
00:18:54,000 --> 00:18:59,000
in to je tisto, napol sem opozoril, preden je, če se vam zgodi premik

265
00:18:59,000 --> 00:19:01,000
po številu bitov v celo število

266
00:19:01,000 --> 00:19:04,000
potem je to 1 se bo na koncu tekoč off.

267
00:19:04,000 --> 00:19:10,000
To je edina skrb, če se zgodi, da se ukvarjajo z zelo velikimi zmogljivostmi.

268
00:19:10,000 --> 00:19:15,000
Toda na tej točki, potem imate opravka s celo vrsto milijard stvari,

269
00:19:15,000 --> 00:19:25,000
ki morda ne spadajo v spomin vseeno.

270
00:19:25,000 --> 00:19:31,000
>> Sedaj lahko pridemo do popa, ki je še lažje.

271
00:19:31,000 --> 00:19:36,000
Lahko bi se bilo všeč, če se zgodi, da pop cel kup,

272
00:19:36,000 --> 00:19:38,000
in zdaj si na polovici zmogljivosti znova.

273
00:19:38,000 --> 00:19:42,000
Lahko realloc za krčenje količino pomnilnika imate,

274
00:19:42,000 --> 00:19:47,000
vendar vam ni treba skrbeti, da je to edini primer realloc se bo

275
00:19:47,000 --> 00:19:50,000
raste spomin, ne zmanjšuje spomin,

276
00:19:50,000 --> 00:19:59,000
ki se dogaja, da pop super enostavno.

277
00:19:59,000 --> 00:20:02,000
Zdaj dolge čakalne vrste, ki se bo kot nizov,

278
00:20:02,000 --> 00:20:06,000
vendar je spremenil vrstni red, ki ga sprejme stvari.

279
00:20:06,000 --> 00:20:10,000
Prototip primer vrsti je linija,

280
00:20:10,000 --> 00:20:12,000
tako da mislim, če ste bili angleški, bi rekel,

281
00:20:12,000 --> 00:20:17,000
prototip primer vrsti je čakalna vrsta.

282
00:20:17,000 --> 00:20:22,000
Tako kot črte, če si prvi, ki je v skladu,

283
00:20:22,000 --> 00:20:24,000
pričakujete, da bo prva oseba iz linije.

284
00:20:24,000 --> 00:20:31,000
Če ste zadnja oseba, ki je v skladu, ki ga bo zadnja oseba na popravilo.

285
00:20:31,000 --> 00:20:35,000
Pravimo, da je FIFO vzorec, medtem ko je sklad LIFO vzorec.

286
00:20:35,000 --> 00:20:40,000
Te besede so zelo univerzalna.

287
00:20:40,000 --> 00:20:46,000
>> Kot skladih in v nasprotju z nizi, čakalne vrste navadno ne dovolijo dostopa do elementov na sredini.

288
00:20:46,000 --> 00:20:50,000
Tu sklad, imamo push in pop.

289
00:20:50,000 --> 00:20:54,000
Tu se zgodi, da so zahtevali jim enqueue in dequeue.

290
00:20:54,000 --> 00:20:58,000
Prav tako sem slišal jih imenujemo spremembe in unshift.

291
00:20:58,000 --> 00:21:02,000
Slišal sem, da ljudje pravijo, push in pop veljajo tudi za čas čakanja.

292
00:21:02,000 --> 00:21:05,000
Slišal sem vstavite, odstranite,

293
00:21:05,000 --> 00:21:11,000
Tako potiskanje in pop, če govorimo o skladih, ki ga potiskajo in živahen.

294
00:21:11,000 --> 00:21:16,000
Če govoriš o vrsti, lahko izberete tudi besede, ki jih želite uporabljati

295
00:21:16,000 --> 00:21:23,000
za vstavljanje in odstranjevanje, pa ni soglasja o tem, kaj je treba imenujejo.

296
00:21:23,000 --> 00:21:27,000
Ampak tukaj imamo enqueue in dequeue.

297
00:21:27,000 --> 00:21:37,000
Zdaj, struct izgleda skoraj identično dimnika struct.

298
00:21:37,000 --> 00:21:40,000
Vendar moramo slediti glavo.

299
00:21:40,000 --> 00:21:44,000
Mislim, da je pravi dol, ampak zakaj moramo glavo?

300
00:21:53,000 --> 00:21:57,000
Prototipov, so v bistvu enaki za potiskanje in pop.

301
00:21:57,000 --> 00:21:59,000
Lahko pomislite, da Pritisni in popa.

302
00:21:59,000 --> 00:22:08,000
Edina razlika je, pop vrača, namesto zadnje, to je vrnil prvi.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, ali kaj podobnega.

304
00:22:12,000 --> 00:22:14,000
In tu je začetek.

305
00:22:14,000 --> 00:22:17,000
Naša vrsta je povsem poln, tako da je štiri elemente v njej.

306
00:22:17,000 --> 00:22:21,000
Konec naši vrsti je trenutno 2,

307
00:22:21,000 --> 00:22:24,000
in zdaj gremo vstaviti nekaj drugega.

308
00:22:24,000 --> 00:22:29,000
>> Ko želimo dodati, da je nekaj drugega, kar smo naredili za dimnik različici

309
00:22:29,000 --> 00:22:36,000
je smo razširili našo blok pomnilnika.

310
00:22:36,000 --> 00:22:40,000
Kaj je narobe s tem?

311
00:22:40,000 --> 00:22:45,000
[Študent] premaknete 2.

312
00:22:45,000 --> 00:22:51,000
Kaj sem rekel prej o koncu čakalne vrste,

313
00:22:51,000 --> 00:22:57,000
To nima nobenega smisla, da začnemo na 1,

314
00:22:57,000 --> 00:23:01,000
potem želimo dequeue 1, potem dequeue 3, nato dequeue 4,

315
00:23:01,000 --> 00:23:05,000
potem dequeue 2, potem dequeue to.

316
00:23:05,000 --> 00:23:08,000
Ne moremo uporabiti realloc zdaj,

317
00:23:08,000 --> 00:23:11,000
ali vsaj, boste morali uporabiti realloc na drugačen način.

318
00:23:11,000 --> 00:23:15,000
Ampak ti verjetno ne bi smeli uporabljati le realloc.

319
00:23:15,000 --> 00:23:18,000
Boste morali ročno kopirate spomin.

320
00:23:18,000 --> 00:23:21,000
>> Obstajata dve funkciji za kopiranje pomnilnika.

321
00:23:21,000 --> 00:23:25,000
Tukaj je memcopy in memmove.

322
00:23:25,000 --> 00:23:29,000
Jaz sem trenutno berete strani man da vidite, katera boste želeli uporabiti.

323
00:23:29,000 --> 00:23:35,000
Ok, memcopy je razlika

324
00:23:35,000 --> 00:23:38,000
da memcopy in memmove, ena obravnava zadevo pravilno

325
00:23:38,000 --> 00:23:41,000
če ste kopirate v regiji, ki se zgodi, da se prekrivajo regijo

326
00:23:41,000 --> 00:23:46,000
ste kopiranju.

327
00:23:46,000 --> 00:23:50,000
Memcopy ni zmogel. Memmove ne.

328
00:23:50,000 --> 00:23:59,000
Si lahko težave, kot-

329
00:23:59,000 --> 00:24:09,000
recimo, da želim, da bi kopirali tega tipa,

330
00:24:09,000 --> 00:24:13,000
te štiri s tem tipom več.

331
00:24:13,000 --> 00:24:16,000
Na koncu, kaj bi moral niz izgledal

332
00:24:16,000 --> 00:24:26,000
ko je kopija 2, 1, 2, 1, 3, 4, in še nekaj stvari na koncu.

333
00:24:26,000 --> 00:24:29,000
Ampak to je odvisno od reda, v katerem smo dejansko kopiranje,

334
00:24:29,000 --> 00:24:32,000
ker če ne upoštevamo dejstvo, da je regija smo kopiranje v

335
00:24:32,000 --> 00:24:35,000
prekriva 1 smo kopiranju,

336
00:24:35,000 --> 00:24:46,000
potem lahko delamo kot začetek tukaj, kopiranje 2 na mesta, ki ga želite iti,

337
00:24:46,000 --> 00:24:52,000
premaknite naših nasvetov naprej.

338
00:24:52,000 --> 00:24:56,000
>> Zdaj bomo tukaj in tukaj in zdaj želimo kopirati

339
00:24:56,000 --> 00:25:04,000
ta tip v tem tipom in da naše napotke naprej.

340
00:25:04,000 --> 00:25:07,000
Kaj bomo na koncu dobili za 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
namesto ustreznih 2, 1, 2, 1, 3, 4, saj

342
00:25:10,000 --> 00:25:15,000
2, 1 razveljavljena izvirno 3, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove ročaji, da pravilno.

344
00:25:19,000 --> 00:25:23,000
V tem primeru je v bistvu samo vedno uporabite memmove

345
00:25:23,000 --> 00:25:26,000
ker jo obravnava pravilno.

346
00:25:26,000 --> 00:25:29,000
Na splošno ne opravljajo nobene hujše.

347
00:25:29,000 --> 00:25:32,000
Ideja je, namesto da začnejo od začetka in kopiranje na ta način

348
00:25:32,000 --> 00:25:35,000
kot smo pravkar naredil tukaj, se začne ob koncu leta in kopira,

349
00:25:35,000 --> 00:25:38,000
in v tem primeru nikoli ne moreš imeti težav.

350
00:25:38,000 --> 00:25:40,000
Tukaj ni zmogljivost izgubljena.

351
00:25:40,000 --> 00:25:47,000
Vedno uporabljajte memmove. Nikoli ne skrbi memcopy.

352
00:25:47,000 --> 00:25:51,000
In to je, če boste morali ločeno memmove

353
00:25:51,000 --> 00:26:01,000
Zavit-okrog delež v čakalno vrsto.

354
00:26:01,000 --> 00:26:04,000
Brez skrbi, če ne v celoti narejena.

355
00:26:04,000 --> 00:26:10,000
To je težje, kot dimnik, potiskanje in pop.

356
00:26:10,000 --> 00:26:15,000
>> Vsakdo ima kakršne koli kode, da bi lahko delo z?

357
00:26:15,000 --> 00:26:21,000
Tudi če popolnoma nepopolni?

358
00:26:21,000 --> 00:26:23,000
[Študent] Ja, to je popolnoma nepopolna, čeprav.

359
00:26:23,000 --> 00:26:27,000
Popolnoma nepopolna je v redu, dokler smo, lahko shranite na pregled?

360
00:26:27,000 --> 00:26:32,000
Pozabil sem, da je vsak čas.

361
00:26:32,000 --> 00:26:39,000
Ok, ne upošteva kaj se zgodi, ko bomo morali spremeniti velikost stvari.

362
00:26:39,000 --> 00:26:42,000
Popolnoma ignorirati velikost.

363
00:26:42,000 --> 00:26:49,000
Razloži to kodo.

364
00:26:49,000 --> 00:26:54,000
Jaz sem preverjanje najprej, če je manjše od izvoda najprej

365
00:26:54,000 --> 00:27:01,000
in nato po tem, sem vstavil, vzamem glavo + velikost,

366
00:27:01,000 --> 00:27:05,000
in sem se prepričajte, da ovije okoli zmogljivosti matrike,

367
00:27:05,000 --> 00:27:08,000
in sem vstavil nov niz na tem položaju.

368
00:27:08,000 --> 00:27:12,000
Potem sem se poveča velikost in return true.

369
00:27:12,000 --> 00:27:22,000
>> [Rob B.] To je zagotovo ena izmed tistih primerih, ko jih boste želeli, da se z uporabo mod.

370
00:27:22,000 --> 00:27:25,000
Kakršna koli primeru, ko ste okoli zavijanje, če misliš, da okoli zavijanje,

371
00:27:25,000 --> 00:27:29,000
takojšnja misel bi morala biti mod.

372
00:27:29,000 --> 00:27:36,000
Kot hitro optimizacijo / bo vaš kodo eno vrstico krajši,

373
00:27:36,000 --> 00:27:42,000
opazite, da je linija, takoj po tem 1

374
00:27:42,000 --> 00:27:53,000
je samo velikost + +, tako da združitev, da v tej vrstici, velikost + +.

375
00:27:53,000 --> 00:27:58,000
Zdaj tukaj imamo primer

376
00:27:58,000 --> 00:28:01,000
če nimamo dovolj pomnilnika,

377
00:28:01,000 --> 00:28:05,000
Tako smo povečali našo sposobnost za 2.

378
00:28:05,000 --> 00:28:09,000
Mislim, da bi lahko imeli enako težavo, vendar pa lahko prezreti zdaj,

379
00:28:09,000 --> 00:28:13,000
če, če ni uspelo povečati svojo zmogljivost,

380
00:28:13,000 --> 00:28:18,000
potem boste želeli, da zmanjša vašo sposobnost za 2 znova.

381
00:28:18,000 --> 00:28:24,000
Še ena kratka opomba je prav tako kot lahko to storite + =,

382
00:28:24,000 --> 00:28:30,000
Prav tako lahko naredite << =.

383
00:28:30,000 --> 00:28:43,000
Skoraj vse, kar lahko gre, preden je enak, + =, | =, & =, = <<.

384
00:28:43,000 --> 00:28:52,000
Char * Nova je naš novi blok pomnilnika.

385
00:28:52,000 --> 00:28:55,000
Oh, tukaj.

386
00:28:55,000 --> 00:29:02,000
>> Kaj ljudje mislijo o vrsti našega novega bloka spomin?

387
00:29:02,000 --> 00:29:06,000
[Študent] Treba je biti char **.

388
00:29:06,000 --> 00:29:12,000
Razmišljate nazaj na našo struct tukaj,

389
00:29:12,000 --> 00:29:14,000
strune je tisto, kar prerazporeditev.

390
00:29:14,000 --> 00:29:21,000
Trudimo se, da celotno novo dinamično shranjevanje elementov v vrsti.

391
00:29:21,000 --> 00:29:25,000
Kaj bomo dodelil svojim nizov je tisto, kar smo mallocing zdaj,

392
00:29:25,000 --> 00:29:30,000
in tako nova, se bo char **.

393
00:29:30,000 --> 00:29:34,000
To se dogaja, da je nabor nizov.

394
00:29:34,000 --> 00:29:38,000
Kaj pa je tako, pod katerimi se bomo vrnili napačen?

395
00:29:38,000 --> 00:29:41,000
[Študent] Če smo se delaš char *?

396
00:29:41,000 --> 00:29:44,000
[Rob B.] Ja, dobro klic.

397
00:29:44,000 --> 00:29:46,000
[Študent] Kaj je bilo to?

398
00:29:46,000 --> 00:29:49,000
[Rob B.] Želeli smo narediti velikosti char *, ker nismo več-

399
00:29:49,000 --> 00:29:53,000
To bi dejansko zelo velik problem, saj bi sizeof (char) je 1.

400
00:29:53,000 --> 00:29:55,000
Char * sizeof se bo 4,

401
00:29:55,000 --> 00:29:58,000
tako veliko krat, ko ste se ukvarjajo z ints,

402
00:29:58,000 --> 00:30:01,000
ste nagnjeni k oditi z njim, ker je velikost notr in velikosti int *

403
00:30:01,000 --> 00:30:04,000
na 32-bitnem sistemu se bo ista stvar.

404
00:30:04,000 --> 00:30:09,000
Ampak tukaj, sizeof (char) in sizeof (char *), so se zdaj dogaja, da je ista stvar.

405
00:30:09,000 --> 00:30:15,000
>> Kaj je okoliščina, ko se vrnemo false?

406
00:30:15,000 --> 00:30:17,000
[Študent] Nov je nična.

407
00:30:17,000 --> 00:30:23,000
Ja, če novi ničelna, vrnemo false,

408
00:30:23,000 --> 00:30:34,000
in bom vrgel dol-

409
00:30:34,000 --> 00:30:37,000
[Študent] [neslišno]

410
00:30:37,000 --> 00:30:39,000
[Rob B.] Ja, to je v redu.

411
00:30:39,000 --> 00:30:46,000
Če ne bi naredila 2-krat zmogljivost ali zmogljivosti shift 1 in šele potem jo nastavite tukaj ali karkoli.

412
00:30:46,000 --> 00:30:52,000
Mi bomo to, kot smo ga imeli.

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

414
00:30:56,000 --> 00:31:08,000
In ti nikoli ne bo treba skrbeti, da bi izgubili 1 je potekala

415
00:31:08,000 --> 00:31:12,000
ker si pustil premakne za 1, tako da je mesto 1 je nujno 0,

416
00:31:12,000 --> 00:31:16,000
Pravica do premika z 1, še vedno bo v redu.

417
00:31:16,000 --> 00:31:19,000
[Študent] Ali morate storiti, da bo pred vrnitvijo?

418
00:31:19,000 --> 00:31:29,000
[Rob B.] Ja, to pomeni nikakršnega smisla.

419
00:31:29,000 --> 00:31:36,000
>> Vzemimo, da bomo na koncu vrne res do konca.

420
00:31:36,000 --> 00:31:39,000
Tako bomo narediti te memmoves,

421
00:31:39,000 --> 00:31:45,000
moramo biti previdni pri tem, kako jih narediti.

422
00:31:45,000 --> 00:31:50,000
Ali ima kdo kakšne predloge za to, kako jih bomo naredili?

423
00:32:17,000 --> 00:32:21,000
Tukaj je naš začetek.

424
00:32:21,000 --> 00:32:28,000
Neizogibno je, da bomo začeli na začetku znova

425
00:32:28,000 --> 00:32:35,000
in kopijo stvari od tam, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
Kako si to naredil?

427
00:32:41,000 --> 00:32:52,000
Najprej moram gledati na človeka stran za memmove znova.

428
00:32:52,000 --> 00:32:57,000
Memmove, da argumentov je vedno pomembna.

429
00:32:57,000 --> 00:33:01,000
Želimo, da naš cilj prvi, 2. vir, velikost tretji.

430
00:33:01,000 --> 00:33:06,000
Obstaja veliko funkcij, ki obrne vira in cilja.

431
00:33:06,000 --> 00:33:11,000
Destinacija, vir kaže, da je v skladu umirila.

432
00:33:17,000 --> 00:33:21,000
Umaknite se, kaj se je vrnil?

433
00:33:21,000 --> 00:33:27,000
Vrne kazalec na namembni kraj, iz katerega koli razloga boste morda želeli.

434
00:33:27,000 --> 00:33:32,000
Znam prebrati sliko, vendar želimo, da se premaknete v naši okolici.

435
00:33:32,000 --> 00:33:35,000
>> Kaj je naš cilj, da bo?

436
00:33:35,000 --> 00:33:37,000
[Študent] Nova.

437
00:33:37,000 --> 00:33:39,000
[Rob B.] Ja, in kje smo kopirate?

438
00:33:39,000 --> 00:33:43,000
Prva stvar, ki mi je to kopiranje 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
Kaj je to-1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
Kakšen je naslov tega 1?

441
00:33:55,000 --> 00:33:58,000
Kakšen je naslov tega 1?

442
00:33:58,000 --> 00:34:01,000
[Študent] [neslišno]

443
00:34:01,000 --> 00:34:03,000
[Rob B.] + Neposredne naslov prvega elementa.

444
00:34:03,000 --> 00:34:05,000
Kako bomo prišli prvi element v matriki?

445
00:34:05,000 --> 00:34:10,000
[Študent] čakalne vrste.

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

447
00:34:15,000 --> 00:34:20,000
Ne pozabite, tu je naša glava je 1.

448
00:34:20,000 --> 00:34:24,000
To presneto. Mislim, da je to čudežno-

449
00:34:24,000 --> 00:34:29,000
Tu je naša glava je 1. Jaz bom spremeniti svoje barve preveč.

450
00:34:29,000 --> 00:34:36,000
In tukaj je strune.

451
00:34:36,000 --> 00:34:41,000
To je lahko bodisi napisati kot smo tukaj

452
00:34:41,000 --> 00:34:43,000
z glavami + q.strings.

453
00:34:43,000 --> 00:34:51,000
Veliko ljudi tudi napiši & q.strings [head].

454
00:34:51,000 --> 00:34:55,000
To ni res nič manj učinkovita.

455
00:34:55,000 --> 00:34:58,000
Morda si mislite o njem, kot ste ga Dereferenciranje in nato dobili naslov,

456
00:34:58,000 --> 00:35:04,000
vendar se bo prevajalnik prevesti, kar smo jih imeli pred nekako, q.strings + glava.

457
00:35:04,000 --> 00:35:06,000
Kakorkoli želite razmišljati o tem.

458
00:35:06,000 --> 00:35:11,000
>> In koliko bajtov želimo kopirati?

459
00:35:11,000 --> 00:35:15,000
[Študent] Moč - glava.

460
00:35:15,000 --> 00:35:18,000
Kapaciteta - glava.

461
00:35:18,000 --> 00:35:21,000
In potem si lahko vedno napišete primer

462
00:35:21,000 --> 00:35:23,000
da ugotovimo, če je to v redu.

463
00:35:23,000 --> 00:35:26,000
[Študent], je treba deliti z 2, potem.

464
00:35:26,000 --> 00:35:30,000
Ja, mislim, da smo lahko uporabite velikost.

465
00:35:30,000 --> 00:35:35,000
Še vedno imamo velikosti pa-

466
00:35:35,000 --> 00:35:39,000
z uporabo velikosti, imamo velikost enako 4.

467
00:35:39,000 --> 00:35:42,000
Naša velikost je 4. Naš vodja je 1.

468
00:35:42,000 --> 00:35:46,000
Želimo kopiranje teh 3 elementov.

469
00:35:46,000 --> 00:35:54,000
To je duševno zdravje, da se preveri velikost - glava je pravilno 3.

470
00:35:54,000 --> 00:35:58,000
In prišel sem, tako kot smo že omenili,

471
00:35:58,000 --> 00:36:00,000
če bi uporabili sposobnosti, potem bi morali deliti z 2

472
00:36:00,000 --> 00:36:04,000
ker smo že prerasla svoje sposobnosti, tako da namesto, da bomo uporabo velikosti.

473
00:36:11,000 --> 00:36:13,000
, Ki kopira ta del.

474
00:36:13,000 --> 00:36:18,000
Zdaj moramo kopirati drugi del, tisti del, ki je ostalo od vsega začetka.

475
00:36:18,000 --> 00:36:28,000
>> To bo memmove v kakšnem položaju?

476
00:36:28,000 --> 00:36:32,000
[Študent] plus size - glava.

477
00:36:32,000 --> 00:36:38,000
Ja, tako smo že kopirali v velikosti - glavo bajte

478
00:36:38,000 --> 00:36:43,000
in tako, če želimo kopirati preostale bajte je novega

479
00:36:43,000 --> 00:36:48,000
nato pa velikost minus pa se je število bajtov smo že kopirali noter

480
00:36:48,000 --> 00:36:52,000
In potem ko smo kopirate?

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

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

483
00:36:56,000 --> 00:37:02,000
Mi ne bi naredila in q.strings [0].

484
00:37:02,000 --> 00:37:05,000
To je precej manj pogosti kot to.

485
00:37:05,000 --> 00:37:14,000
Če je le, da bo 0, potem boste pogosto videli q.strings.

486
00:37:14,000 --> 00:37:16,000
To je, če smo kopiranju.

487
00:37:16,000 --> 00:37:18,000
Koliko zlogov pa smo prepuščeni slišiš? >> [Študent] 10.

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

489
00:37:20,000 --> 00:37:25,000
[Študent] Ali moramo množiti 5-10 krat v velikosti od bajte ali kaj podobnega?

490
00:37:25,000 --> 00:37:30,000
Ja, tako je to, če-kaj točno se kopiranje?

491
00:37:30,000 --> 00:37:32,000
[Študent] [neslišno]

492
00:37:32,000 --> 00:37:34,000
Kakšna je vrsta stvari smo kopiranje?

493
00:37:34,000 --> 00:37:36,000
[Študent] [neslišno]

494
00:37:36,000 --> 00:37:41,000
Ja, char * i, da smo kopiranje, ne vemo, če ti prihajajo iz.

495
00:37:41,000 --> 00:37:47,000
No, če oni kažejo na, kot so strune, smo na koncu jo potisnil na čakalni vrsti

496
00:37:47,000 --> 00:37:49,000
ali enqueuing na vrsti.

497
00:37:49,000 --> 00:37:51,000
Če tisti, prihajajo iz, ne vemo.

498
00:37:51,000 --> 00:37:56,000
Vedeti pa je treba slediti char * s samimi.

499
00:37:56,000 --> 00:38:00,000
Ne želimo, da bi kopirali velikosti - glava bajti.

500
00:38:00,000 --> 00:38:03,000
Želimo, da bi kopirali velikosti - glava char * s,

501
00:38:03,000 --> 00:38:11,000
tako da bomo to pomnožimo z sizeof (char *).

502
00:38:11,000 --> 00:38:17,000
Enako tukaj, vodja * sizeof (char *).

503
00:38:17,000 --> 00:38:24,000
>> [Študent] Kaj pa [neslišno]?

504
00:38:24,000 --> 00:38:26,000
To tukaj?

505
00:38:26,000 --> 00:38:28,000
[Študent] No, spodaj, da je velikost - glava.

506
00:38:28,000 --> 00:38:30,000
[Rob B.] Ta tukaj?

507
00:38:30,000 --> 00:38:32,000
Kazalec aritmetično.

508
00:38:32,000 --> 00:38:35,000
Kako kazalec aritmetična bo to delovalo, je

509
00:38:35,000 --> 00:38:40,000
samodejno pomnoži z velikostjo tipa, da imamo opravka.

510
00:38:40,000 --> 00:38:46,000
Tako kot tukaj, novo + (velikost - glava)

511
00:38:46,000 --> 00:38:56,000
je popolnoma enaka in nove [velikost glave -]

512
00:38:56,000 --> 00:39:00,000
do pričakujemo, da bo delovala pravilno,

513
00:39:00,000 --> 00:39:04,000
saj če imamo opravka z int array, nato pa ne bomo indeks z int-

514
00:39:04,000 --> 00:39:07,000
ali če je od velikosti 5 in želite, 4. element, potem indeks Into the

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

516
00:39:10,000 --> 00:39:14,000
Vi ne-[4] * velikost notr.

517
00:39:14,000 --> 00:39:21,000
To je samodejno ročaji in tem primeru

518
00:39:21,000 --> 00:39:29,000
je dobesedno enako, tako da nosilec sintaksa

519
00:39:29,000 --> 00:39:34,000
se le, da bo treba pretvoriti v to, takoj ko zbiranje.

520
00:39:34,000 --> 00:39:38,000
To je nekaj, kar morate biti pozorni, da

521
00:39:38,000 --> 00:39:42,000
ko dodajate velikost - glava

522
00:39:42,000 --> 00:39:45,000
dodajate ne en bajt.

523
00:39:45,000 --> 00:39:53,000
Dodajate 1 char *, ki je lahko eno bajtov ali karkoli.

524
00:39:53,000 --> 00:39:56,000
>> Druga vprašanja?

525
00:39:56,000 --> 00:40:04,000
Ok, dequeue se bo lažje.

526
00:40:04,000 --> 00:40:11,000
Dal ti bom malo za izvedbo.

527
00:40:11,000 --> 00:40:18,000
Oh, in mislim, da je to ista situacija, v kateri

528
00:40:18,000 --> 00:40:21,000
kaj enqueue primeru, če bomo enqueuing nično,

529
00:40:21,000 --> 00:40:24,000
Morda želimo ravnati, morda ne bomo.

530
00:40:24,000 --> 00:40:27,000
Tega ne bomo še enkrat tukaj, ampak enako kot naš dimnik primeru.

531
00:40:27,000 --> 00:40:34,000
Če bomo enqueue nično, bi radi, da ga ne upoštevajo.

532
00:40:34,000 --> 00:40:40,000
Vsakdo ima nekaj kode, da lahko potegnili gor?

533
00:40:40,000 --> 00:40:45,000
[Študent] Imam samo dequeue.

534
00:40:45,000 --> 00:40:56,000
Različica 2 je, da se, v redu.

535
00:40:56,000 --> 00:40:59,000
Hočeš, da pojasni?

536
00:40:59,000 --> 00:41:01,000
[Študent] Najprej se prepričajte, da je nekaj v čakalni vrsti

537
00:41:01,000 --> 00:41:07,000
in da se velikost se bo po 1.

538
00:41:07,000 --> 00:41:11,000
Kar morate storiti, da se potem vrnete glavo

539
00:41:11,000 --> 00:41:13,000
in premaknite glavo 1.

540
00:41:13,000 --> 00:41:19,000
Ok, tako da je kotna primeru moramo upoštevati. Ja.

541
00:41:19,000 --> 00:41:24,000
[Študent] Če je vaša glava na zadnji element,

542
00:41:24,000 --> 00:41:26,000
potem ne želite glave s točko zunaj polja.

543
00:41:26,000 --> 00:41:29,000
>> Ja, to čimprej glavo zadela konec našega niza,

544
00:41:29,000 --> 00:41:35,000
ko smo dequeue bi naša glava modded nazaj na 0.

545
00:41:35,000 --> 00:41:40,000
Na žalost ne moremo storiti v enem koraku.

546
00:41:40,000 --> 00:41:44,000
Mislim, da je tako, kot sem verjetno določi, da je

547
00:41:44,000 --> 00:41:52,000
To se bo char *, kar smo se vračajo,

548
00:41:52,000 --> 00:41:55,000
ne glede na vaše ime spremenljivke želi biti.

549
00:41:55,000 --> 00:42:02,000
Potem želimo mod glavo po naših sposobnosti

550
00:42:02,000 --> 00:42:10,000
in se nato vrne ret.

551
00:42:10,000 --> 00:42:14,000
Veliko ljudi tukaj, ki bi jo lahko naredil,

552
00:42:14,000 --> 00:42:19,000
To je primer-boš videl, če ljudje glavo

553
00:42:19,000 --> 00:42:29,000
večja od zmogljivosti, ne z glavo - zmogljivosti.

554
00:42:29,000 --> 00:42:36,000
In to je samo tisto, kar delajo okoli mod je.

555
00:42:36,000 --> 00:42:41,000
Vodja mod = zmogljivost veliko čistejši

556
00:42:41,000 --> 00:42:51,000
za zavijanje okoli glave, kot če bi nad glavo zmogljivosti - zmogljivosti.

557
00:42:51,000 --> 00:42:56,000
>> Vprašanja?

558
00:42:56,000 --> 00:43:02,000
Ok, zadnja stvar, ki smo jo zapustili naš povezani seznam.

559
00:43:02,000 --> 00:43:07,000
Vi se lahko uporabijo za nekatere povezano vedenje seznama, če si

560
00:43:07,000 --> 00:43:11,000
povezane sezname v svoje hash tabele, če si razpršene tabele.

561
00:43:11,000 --> 00:43:15,000
Toplo priporočam početje razpršene tabele.

562
00:43:15,000 --> 00:43:17,000
Morda ste že opravili Trie,

563
00:43:17,000 --> 00:43:23,000
vendar poskusih težje.

564
00:43:23,000 --> 00:43:27,000
V teoriji, oni asimptotično bolje.

565
00:43:27,000 --> 00:43:30,000
Ampak samo poglej na veliko tablo,

566
00:43:30,000 --> 00:43:35,000
in poskuša nikoli bolje, in zasedejo več pomnilnika.

567
00:43:35,000 --> 00:43:43,000
Vse o poskuša konča pa slabši za več dela.

568
00:43:43,000 --> 00:43:49,000
To je tisto, kar je rešitev, David Malan je vedno

569
00:43:49,000 --> 00:43:56,000
Je vedno prispevkov njegovo Trie rešitev, in poglejmo, kjer trenutno je.

570
00:43:56,000 --> 00:44:00,000
Kaj je bil po David J?

571
00:44:00,000 --> 00:44:06,000
Je # 18, tako da ni strašno slabo,

572
00:44:06,000 --> 00:44:09,000
in to se dogaja, da je eden izmed najboljših poskuša si lahko zamislite

573
00:44:09,000 --> 00:44:17,000
ali eden izmed najboljših poskuša iz Trie.

574
00:44:17,000 --> 00:44:23,000
Je to sploh ni njegova prvotna rešitev?

575
00:44:23,000 --> 00:44:29,000
Počutim se, kot Trie rešitve ponavadi bolj v tem območju uporabe RAM.

576
00:44:29,000 --> 00:44:33,000
>> Pojdi do samega vrha in RAM je v posameznih številk.

577
00:44:33,000 --> 00:44:36,000
Pojdi nazaj na dnu, nato pa že lahko videli poskuša

578
00:44:36,000 --> 00:44:41,000
kje si dobil absolutno ogromno RAM navada,

579
00:44:41,000 --> 00:44:45,000
in poskuša težje.

580
00:44:45,000 --> 00:44:53,000
Ni povsem vredno, vendar izobraževalno izkušnjo, če si eno.

581
00:44:53,000 --> 00:44:56,000
Zadnja stvar, ki je naš povezani seznam,

582
00:44:56,000 --> 00:45:04,000
in te tri stvari, dimniki, kolon in povezani seznami,

583
00:45:04,000 --> 00:45:09,000
prihodnja stvar, ki jo kdaj naredil na področju računalništva

584
00:45:09,000 --> 00:45:12,000
Predvidevam, da ste se seznanijo s temi stvarmi.

585
00:45:12,000 --> 00:45:19,000
So le tako temeljnega pomena za vse.

586
00:45:19,000 --> 00:45:25,000
>> Povezane sezname, in tu smo posamično povezani seznam se bo naša izvedba.

587
00:45:25,000 --> 00:45:34,000
Kaj posamič povezani pomeni v nasprotju z dvojno povezani? Da.

588
00:45:34,000 --> 00:45:37,000
[Študent] To samo kaže na naslednji kazalec namesto na kazalcev,

589
00:45:37,000 --> 00:45:39,000
kot tisti pred njega in 1 po njem.

590
00:45:39,000 --> 00:45:44,000
Ja, tako v obliki slike, kaj sem naredil?

591
00:45:44,000 --> 00:45:48,000
Imam dve stvari. Imam sliko in sliko.

592
00:45:48,000 --> 00:45:51,000
V obliki slike, naši posamično povezani seznam,

593
00:45:51,000 --> 00:45:57,000
neizogibno, imamo nekakšen kazalec na čelu našega seznama

594
00:45:57,000 --> 00:46:02,000
in nato v našem seznamu, imamo samo namig,

595
00:46:02,000 --> 00:46:05,000
in morda to kaže na null.

596
00:46:05,000 --> 00:46:08,000
To bo vaša tipična risba progo povezan seznam.

597
00:46:08,000 --> 00:46:14,000
Dvojno povezani seznam, lahko greš nazaj.

598
00:46:14,000 --> 00:46:19,000
Če dam vse vozlišča na seznamu, potem lahko nujno priti do

599
00:46:19,000 --> 00:46:23,000
katero koli drugo vozlišče v seznam, če je dvojno povezani seznam.

600
00:46:23,000 --> 00:46:27,000
Ampak, če boste dobili tretjo vozlišča v seznamu in je posamezno povezani seznam,

601
00:46:27,000 --> 00:46:30,000
Zagotovo ne boste nikoli prišli do prvega in drugega vozlišča.

602
00:46:30,000 --> 00:46:34,000
In tam koristi in škodo za in en očiten 1

603
00:46:34,000 --> 00:46:42,000
je lahko zasedejo več velikosti in boste morali slediti, kje se te stvari so zdaj kaže.

604
00:46:42,000 --> 00:46:49,000
Ampak samo skrbi posamezno povezana.

605
00:46:49,000 --> 00:46:53,000
>> Nekaj ​​stvari, ki jih boš moral izvajati.

606
00:46:53,000 --> 00:47:00,000
Vaš typedef struct vozlišče, int i: struct vozlišče * naslednji; vozlišče.

607
00:47:00,000 --> 00:47:09,000
To typedef se sežge v vaših glavah.

608
00:47:09,000 --> 00:47:14,000
Quiz 1 se rad dal typedef za povezano vozlišče seznama,

609
00:47:14,000 --> 00:47:18,000
in bi morali imeti možnost, da takoj Škrabotine, ki določa

610
00:47:18,000 --> 00:47:22,000
ne da bi sploh razmišljal o tem.

611
00:47:22,000 --> 00:47:27,000
Mislim, da nekaj vprašanj, zakaj moramo dograditi tukaj?

612
00:47:27,000 --> 00:47:32,000
Zakaj ne moremo reči, vozlišče *?

613
00:47:32,000 --> 00:47:35,000
[Študent] [neslišno]

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

615
00:47:38,000 --> 00:47:44,000
Edina stvar, ki opredeljuje vozlišče kot stvar

616
00:47:44,000 --> 00:47:47,000
je typedef sama.

617
00:47:47,000 --> 00:47:55,000
Toda od te točke, ko smo nekako razčlenjevanjem po tej definiciji struct vozlišča,

618
00:47:55,000 --> 00:48:01,000
nismo končali naš typedef še posebej zato, ker je typedef ni končal,

619
00:48:01,000 --> 00:48:05,000
Vozel ne obstaja.

620
00:48:05,000 --> 00:48:12,000
Ampak struct vozlišče počne, in to vozlišče tukaj,

621
00:48:12,000 --> 00:48:14,000
To bi se lahko imenuje tudi kaj drugega.

622
00:48:14,000 --> 00:48:16,000
To bi lahko imenovali n.

623
00:48:16,000 --> 00:48:19,000
To bi lahko imenovali povezani seznam vozlišče.

624
00:48:19,000 --> 00:48:21,000
To bi lahko imenovali ničesar.

625
00:48:21,000 --> 00:48:26,000
Ampak to struct vozlišče je treba uporabiti isto, kot to struct vozlišče.

626
00:48:26,000 --> 00:48:29,000
Kaj praviš temu je tudi tukaj,

627
00:48:29,000 --> 00:48:32,000
ter da upošteva tudi drugo točko tega vprašanja

628
00:48:32,000 --> 00:48:37,000
zato, veliko krat, ko vidiš konstrukti in typedefs za konstrukti,

629
00:48:37,000 --> 00:48:42,000
boste videli anonimnih konstrukti, kjer boste videli typedef struct,

630
00:48:42,000 --> 00:48:47,000
Izvajanje struct, slovar, ali karkoli.

631
00:48:47,000 --> 00:48:51,000
>> Zakaj tu moramo povedati vozlišče?

632
00:48:51,000 --> 00:48:54,000
Zakaj ne more biti anonimno struct?

633
00:48:54,000 --> 00:48:56,000
To je skoraj enak odgovor.

634
00:48:56,000 --> 00:48:58,000
[Študent] Moraš se nanašajo nanj v struct.

635
00:48:58,000 --> 00:49:04,000
Ja, v struct, morate sklicevati na struct sama.

636
00:49:04,000 --> 00:49:10,000
Če ne bi struct ime, če je anonimna struct, se ne more sklicevati na to.

637
00:49:10,000 --> 00:49:17,000
In nenazadnje, to bi morali biti nekoliko enostavnejši,

638
00:49:17,000 --> 00:49:20,000
in naj vam pomagajo uresničiti, če ste zapisuješ

639
00:49:20,000 --> 00:49:24,000
da delaš nekaj narobe, če te vrste stvari niso smiselne.

640
00:49:24,000 --> 00:49:28,000
In nenazadnje, zakaj se je to moralo biti struct vozlišče *?

641
00:49:28,000 --> 00:49:34,000
Zakaj ne more biti samo struct vozlišče naslednji?

642
00:49:34,000 --> 00:49:37,000
[Študent] Kazalec na naslednji struct.

643
00:49:37,000 --> 00:49:39,000
To je neizogibno, kaj želimo.

644
00:49:39,000 --> 00:49:42,000
Zakaj je ne bi bilo mogoče struct node naslednji?

645
00:49:42,000 --> 00:49:50,000
Zakaj je moral biti struct vozlišče * naslednji? Ja.

646
00:49:50,000 --> 00:49:53,000
[Študent] To je kot neskončno zanko.

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

648
00:49:55,000 --> 00:49:57,000
[Študent] bo vse v enem.

649
00:49:57,000 --> 00:50:02,000
Ja, samo pomislite, kako bi naredili velikosti ali kaj podobnega.

650
00:50:02,000 --> 00:50:08,000
Velikost struct je v bistvu + ali - nekateri vzorec tu ali tam.

651
00:50:08,000 --> 00:50:15,000
To je v bistvu dogaja, da je vsota velikosti stvari v struct.

652
00:50:15,000 --> 00:50:18,000
To tukaj, ne da bi spremenili ničesar, velikost bo enostavno.

653
00:50:18,000 --> 00:50:24,000
Velikost vozlišča struct se bo velikost i velikosti + za naslednjo.

654
00:50:24,000 --> 00:50:27,000
Velikost i se bo 4. Velikost prihodnje se bo 4.

655
00:50:27,000 --> 00:50:30,000
Velikost vozlišča struct se bo 8.

656
00:50:30,000 --> 00:50:34,000
Če ne bomo imeli *, misli dolžina tipa,

657
00:50:34,000 --> 00:50:37,000
potem sizeof (i) se bo 4.

658
00:50:37,000 --> 00:50:43,000
Velikost vozlišča struct Naslednji se bo velikost i + velikost vozlišča struct dostavo

659
00:50:43,000 --> 00:50:46,000
+ Velikost + i velikosti vozlišča struct dostavo.

660
00:50:46,000 --> 00:50:55,000
To bi bilo neskončno rekurzija vozlišč.

661
00:50:55,000 --> 00:51:00,000
To je razlog, zakaj je to, kako se stvari morajo biti.

662
00:51:00,000 --> 00:51:03,000
>> Še enkrat, zagotovo zapomnili, da

663
00:51:03,000 --> 00:51:06,000
ali vsaj razumem dovolj, da bi mogli

664
00:51:06,000 --> 00:51:12,000
Razlog skozi tisto, kar naj bi izgledal.

665
00:51:12,000 --> 00:51:14,000
Stvari, ki jih boste želeli izvesti.

666
00:51:14,000 --> 00:51:18,000
Če dolžina seznama,

667
00:51:18,000 --> 00:51:21,000
da bi lahko goljufija in pri sebi

668
00:51:21,000 --> 00:51:24,000
svetovni dolžine ali kaj podobnega, ampak ne boš naredil.

669
00:51:24,000 --> 00:51:28,000
Mi bomo za štetje dolžine seznama.

670
00:51:28,000 --> 00:51:34,000
Imamo vsebuje, tako da je v bistvu kot iskanje,

671
00:51:34,000 --> 00:51:41,000
tako da imamo povezan seznam celih da vidim, če je to celo v povezanem seznamu.

672
00:51:41,000 --> 00:51:44,000
Prepend gre za vnos na začetku seznama.

673
00:51:44,000 --> 00:51:46,000
Pripni se dogaja, da vstavite konec.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted bo vstavite v razvrščeni mesto na seznamu.

675
00:51:53,000 --> 00:52:01,000
Insert_sorted nekako predpostavlja, da nikoli ne uporablja pripnite ali dodate v slabih načinov.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted ko ste izvajanju insert_sorted-

677
00:52:09,000 --> 00:52:13,000
recimo, da imamo povezani seznam.

678
00:52:13,000 --> 00:52:18,000
To je tisto, kar trenutno izgleda, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
Želim vstaviti 3, tako dolgo, kot je ta seznam že sama urejen,

680
00:52:24,000 --> 00:52:27,000
to je enostavno najti, kje 3 spada.

681
00:52:27,000 --> 00:52:29,000
Začnem v 2.

682
00:52:29,000 --> 00:52:32,000
Ok, 3 je večje od 2, zato želim, da se dogaja.

683
00:52:32,000 --> 00:52:35,000
Oh, 4 je prevelika, zato vem, 3 je šel v med 2 in 4,

684
00:52:35,000 --> 00:52:39,000
in moram popraviti napotke in vse te stvari.

685
00:52:39,000 --> 00:52:43,000
Ampak, če ne bi nujno uporabiti insert_sorted,

686
00:52:43,000 --> 00:52:50,000
kot recimo, da sem pripnite 6,

687
00:52:50,000 --> 00:52:55,000
potem moj povezani seznam bo postal to.

688
00:52:55,000 --> 00:53:01,000
Zdaj nima smisla, tako da za insert_sorted, lahko samo prevzeti

689
00:53:01,000 --> 00:53:04,000
da je seznam urejen, čeprav obstajajo postopki

690
00:53:04,000 --> 00:53:09,000
ki lahko povzroči, da se ne sortirajo in to je to.

691
00:53:09,000 --> 00:53:20,000
Poiščite pomoč insert-tako tiste, ki so glavne stvari, ki jih boste morali izvajati.

692
00:53:20,000 --> 00:53:24,000
>> Za zdaj, vzemite minuto za to dolžino in vsebuje

693
00:53:24,000 --> 00:53:30,000
in bi tisti relativno hitro.

694
00:53:41,000 --> 00:53:48,000
Približuje zapiranje časa, tako da ima kdo kaj za dolžino ali vsebuje?

695
00:53:48,000 --> 00:53:50,000
Oni bodo skoraj identični.

696
00:53:50,000 --> 00:53:57,000
[Študent] Dolžina.

697
00:53:57,000 --> 00:54:01,000
Poglejmo, revizijo.

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

699
00:54:12,000 --> 00:54:15,000
Hočeš, da pojasni?

700
00:54:15,000 --> 00:54:21,000
[Študent] sem ustvariti kazalec vozlišče in ga zažene na prvi, ki je naša globalna spremenljivka,

701
00:54:21,000 --> 00:54:27,000
in potem sem preveriti, da vidim, če je nična, da mi ne bi dobili SEG napako in vrne 0, če je to res.

702
00:54:27,000 --> 00:54:34,000
Sicer pa mislim, zanka preko sledenja celo v

703
00:54:34,000 --> 00:54:38,000
kolikokrat sem pogledali naslednji element seznama

704
00:54:38,000 --> 00:54:43,000
in v isti operaciji prirastek tudi do tega dejansko element,

705
00:54:43,000 --> 00:54:47,000
in potem sem nenehno narediti pregled, da preveri, če je nična,

706
00:54:47,000 --> 00:54:56,000
in če je nična, potem pa prekine in samo vrne število elementov sem dostopa.

707
00:54:56,000 --> 00:55:01,000
>> [Rob B.] Ima kdo kakršne koli pripombe na karkoli?

708
00:55:01,000 --> 00:55:06,000
To izgleda v redu pravilnost pametno.

709
00:55:06,000 --> 00:55:10,000
[Študent] Ne verjamem, da boste morali vozlišče == null.

710
00:55:10,000 --> 00:55:13,000
Ja, če je vozlišče == null return 0.

711
00:55:13,000 --> 00:55:18,000
Ampak, če vozlišče == null, potem je to, oh, je pravilnost vprašanje.

712
00:55:18,000 --> 00:55:23,000
To je bila samo ti i vrača, vendar to ni v obsegu sedaj.

713
00:55:23,000 --> 00:55:30,000
Potrebuješ samo int i, tako da i = 0.

714
00:55:30,000 --> 00:55:34,000
Ampak, če vozlišče nič, potem pa sem se še vedno dogaja, da je 0,

715
00:55:34,000 --> 00:55:39,000
in bomo vrnili 0, tako da je ta zadeva enaka.

716
00:55:39,000 --> 00:55:48,000
Še ena skupna stvar je, da bo izjavo

717
00:55:48,000 --> 00:55:51,000
za notranje vozlišče za zanko.

718
00:55:51,000 --> 00:55:54,000
Lahko bi rekli, oh, ne.

719
00:55:54,000 --> 00:55:56,000
Naj ostane kot je ta.

720
00:55:56,000 --> 00:55:59,000
Jaz bi verjetno dal int i = 0 tukaj

721
00:55:59,000 --> 00:56:05,000
potem vozlišče vozlišče * = prva tukaj.

722
00:56:05,000 --> 00:56:11,000
In to je verjetno, kako-kako se znebiti tega zdaj.

723
00:56:11,000 --> 00:56:14,000
To je verjetno, kako bi jaz napisal.

724
00:56:14,000 --> 00:56:21,000
Lahko tudi gledaš na to, kot je ta.

725
00:56:21,000 --> 00:56:25,000
To za konstrukcijo zanke tukaj

726
00:56:25,000 --> 00:56:30,000
bi morali biti skoraj tako naravno, da vas kot za int i = 0

727
00:56:30,000 --> 00:56:33,000
i je manj kot dolžino niza, i + +.

728
00:56:33,000 --> 00:56:38,000
Če je to, kako izbirate preko matrike, to je, kako si izbirate prek povezanega seznama.

729
00:56:38,000 --> 00:56:45,000
>> To bi moralo biti nekaj običajnega na neki točki.

730
00:56:45,000 --> 00:56:50,000
S tem v mislih, bo to skoraj isto stvar.

731
00:56:50,000 --> 00:56:57,000
Vi boste želeli ponoviti čez povezan seznam.

732
00:56:57,000 --> 00:57:02,000
Če je vozlišče, nimam pojma, kaj se imenuje vrednost.

733
00:57:02,000 --> 00:57:04,000
I vozlišča.

734
00:57:04,000 --> 00:57:15,000
Če je vrednost v tem vozlišču = i return true, in to je to.

735
00:57:15,000 --> 00:57:18,000
Obvestilo, da je edini način, da smo se kdaj vrne false

736
00:57:18,000 --> 00:57:23,000
Ponovil je, če smo v celotnem povezan seznam in se nikoli več vrnili res,

737
00:57:23,000 --> 00:57:29,000
tako da je tisto, kar to počne.

738
00:57:29,000 --> 00:57:36,000
Kot opomba, verjetno ne bomo dobili dodati ali pripnite.

739
00:57:36,000 --> 00:57:39,000
>> Hitro zadnje note.

740
00:57:39,000 --> 00:57:52,000
Če vidite statični ključno besedo, tako recimo statični int count = 0,

741
00:57:52,000 --> 00:57:56,000
potem ne štejejo + +, lahko v bistvu mislim, da je globalna spremenljivka,

742
00:57:56,000 --> 00:58:00,000
čeprav sem rekel, da to ni, kako bomo pri izvajanju dolžino.

743
00:58:00,000 --> 00:58:06,000
To delam tukaj in nato prešteti + +.

744
00:58:06,000 --> 00:58:11,000
Vsak način, da lahko vstopijo v našo vozlišče povezano seznama smo povečevanje našega štetja.

745
00:58:11,000 --> 00:58:15,000
Bistvo je to, kar statična ključna beseda pomeni.

746
00:58:15,000 --> 00:58:20,000
Če sem imel int count = 0, da bi redno stara globalna spremenljivka.

747
00:58:20,000 --> 00:58:25,000
Kaj statični int Število pomeni, da je globalna spremenljivka za to datoteko.

748
00:58:25,000 --> 00:58:28,000
Nemogoče je, da za nekatere druge datoteke,

749
00:58:28,000 --> 00:58:34,000
rad pomislim pset 5, če ste začeli.

750
00:58:34,000 --> 00:58:39,000
Imate tako speller.c in imate dictionary.c,

751
00:58:39,000 --> 00:58:42,000
in če si razglasi stvar globalno, potem pa ničesar speller.c

752
00:58:42,000 --> 00:58:45,000
mogoče dostopati v dictionary.c in obratno.

753
00:58:45,000 --> 00:58:48,000
Globalne spremenljivke so dostopne vse datoteke. C,

754
00:58:48,000 --> 00:58:54,000
vendar statične spremenljivke so dostopne le znotraj same datoteke,

755
00:58:54,000 --> 00:59:01,000
tako znotraj črkovalnik, UV dictionary.c,

756
00:59:01,000 --> 00:59:06,000
To je nekako, kako bi izjavljam svoj spremenljivka za velikost mojega niza

757
00:59:06,000 --> 00:59:10,000
ali velikost mojega števila besed v slovarju.

758
00:59:10,000 --> 00:59:15,000
Ker ne želim, da razglasi, da je globalno spremenljivko, da vsakdo, ki ima dostop do,

759
00:59:15,000 --> 00:59:18,000
Res samo briga za moje namene.

760
00:59:18,000 --> 00:59:21,000
>> Dobra stvar je tudi to ime cele trčenje stvari.

761
00:59:21,000 --> 00:59:27,000
Če nekatere druge datoteke poskuša uporabiti globalno spremenljivko, imenovano count, gredo stvari zelo, zelo narobe,

762
00:59:27,000 --> 00:59:33,000
tako da je to lepo ohranja stvari varno, in samo lahko dostopate do njega,

763
00:59:33,000 --> 00:59:38,000
in ne more nihče drug, in če nekdo izjavi globalno spremenljivko, imenovano count,

764
00:59:38,000 --> 00:59:43,000
potem to ne bo vplivalo na statično spremenljivko, imenovano count.

765
00:59:43,000 --> 00:59:47,000
To je tisto, kar je statična. To je datoteka globalna spremenljivka.

766
00:59:47,000 --> 00:59:52,000
>> Vprašanja o tem?

767
00:59:52,000 --> 00:59:59,000
Vse je pripravljeno. Adijo.

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