1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [§ 6] [Mer komfortabelt]

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

3
00:00:04,000 --> 00:00:09,000
[Dette er CS50.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> Vi kan dra til vår del av spørsmålene.

5
00:00:11,000 --> 00:00:17,000
Jeg sendte URL for plass før.

6
00:00:17,000 --> 00:00:22,000
Begynnelsen av den delen av spørsmålene si-

7
00:00:22,000 --> 00:00:26,000
tilsynelatende Jeg er ikke helt unsick-er en veldig enkelt spørsmål

8
00:00:26,000 --> 00:00:28,000
av akkurat hva som er Valgrind?

9
00:00:28,000 --> 00:00:30,000
Hva gjør Valgrind?

10
00:00:30,000 --> 00:00:34,000
Noen ønsker å si hva Valgrind gjør?

11
00:00:34,000 --> 00:00:36,000
[Student] Sjekker minnelekkasjer.

12
00:00:36,000 --> 00:00:41,000
Ja, er Valgrind en generell minne brikke.

13
00:00:41,000 --> 00:00:44,000
Det, i slutten, forteller deg om du har noen minnelekkasjer,

14
00:00:44,000 --> 00:00:49,000
som er det meste hva vi bruker den til, fordi hvis du ønsker å

15
00:00:49,000 --> 00:00:54,000
gjøre det bra i oppgavesettet eller hvis du ønsker å

16
00:00:54,000 --> 00:00:59,000
få på the Big Board, må du ha noen minnelekkasjer overhodet,

17
00:00:59,000 --> 00:01:01,000
og i tilfelle du har en minnelekkasje som du ikke kan finne,

18
00:01:01,000 --> 00:01:04,000
også huske på at når du åpner en fil

19
00:01:04,000 --> 00:01:07,000
og hvis du ikke lukke den, det er en minnelekkasje.

20
00:01:07,000 --> 00:01:10,000
>> Mange mennesker leter etter noen node at de ikke frigjør

21
00:01:10,000 --> 00:01:15,000
når du egentlig har de ikke lukke ordboken i den aller første skritt.

22
00:01:15,000 --> 00:01:19,000
Den forteller deg også om du har noen ugyldig leser eller skriver,

23
00:01:19,000 --> 00:01:22,000
som betyr at hvis du prøver og sette en verdi

24
00:01:22,000 --> 00:01:26,000
det er utover slutten av haugen, og det ikke skjer SEG feil

25
00:01:26,000 --> 00:01:30,000
men Valgrind fanger det, som du ikke bør faktisk være å skrive det,

26
00:01:30,000 --> 00:01:33,000
og så du definitivt ikke bør ha noen av dem heller.

27
00:01:33,000 --> 00:01:38,000
Hvordan bruker du Valgrind?

28
00:01:38,000 --> 00:01:42,000
Hvordan bruker du Valgrind?

29
00:01:42,000 --> 00:01:45,000
>> Det er et generelt spørsmål av

30
00:01:45,000 --> 00:01:49,000
slags kjøre den og se på resultatet.

31
00:01:49,000 --> 00:01:51,000
Utgangen er overveldende mange ganger.

32
00:01:51,000 --> 00:01:54,000
Det er også morsomt feil der hvis du har noen fryktelig galt ting

33
00:01:54,000 --> 00:01:59,000
skjer i en loop, så vil det til slutt si: "Altfor mange feil.

34
00:01:59,000 --> 00:02:03,000
Jeg kommer til å slutte å telle nå. "

35
00:02:03,000 --> 00:02:08,000
Det er i utgangspunktet tekstlig resultat som du må analysere.

36
00:02:08,000 --> 00:02:13,000
Til slutt, vil den fortelle deg noen minnelekkasjer som du har,

37
00:02:13,000 --> 00:02:16,000
hvor mange blokker, som kan være nyttig fordi

38
00:02:16,000 --> 00:02:20,000
Hvis det er ett kvartal unfreed, så er det som regel enklere å finne

39
00:02:20,000 --> 00:02:23,000
enn 1000 blokker unfreed.

40
00:02:23,000 --> 00:02:26,000
1000 blokker unfreed betyr sannsynligvis at du ikke frigjør

41
00:02:26,000 --> 00:02:30,000
dine koblede lister hensiktsmessig eller noe.

42
00:02:30,000 --> 00:02:32,000
Det er Valgrind.

43
00:02:32,000 --> 00:02:35,000
>> Nå har vi vår del av spørsmålene,

44
00:02:35,000 --> 00:02:38,000
som du ikke trenger å laste ned.

45
00:02:38,000 --> 00:02:41,000
Du kan klikke på navnet mitt og trekke dem opp i verdensrommet.

46
00:02:41,000 --> 00:02:44,000
Nå klikker du på meg.

47
00:02:44,000 --> 00:02:46,000
Revisjon 1 vil være stack, som vi gjør først.

48
00:02:46,000 --> 00:02:55,000
Revisjon 2 vil være kø, og Revisjon 3 vil være enkeltvis lenket liste.

49
00:02:55,000 --> 00:02:58,000
Starter med stacken.

50
00:02:58,000 --> 00:03:02,000
Som det står her, er en stabel en av de mest grunnleggende,

51
00:03:02,000 --> 00:03:07,000
grunnleggende datastrukturer i datavitenskap.

52
00:03:07,000 --> 00:03:11,000
Den svært prototypiske eksempel er

53
00:03:11,000 --> 00:03:13,000
bunken av skuffer i matsalen.

54
00:03:13,000 --> 00:03:16,000
Det er utgangspunktet når du blir introdusert til en stabel,

55
00:03:16,000 --> 00:03:20,000
noen kommer til å si: "Å, som en stabel av skuffene."

56
00:03:20,000 --> 00:03:22,000
Du stable skuffene opp.

57
00:03:22,000 --> 00:03:24,000
Så når du går å trekke en skuff,

58
00:03:24,000 --> 00:03:31,000
den første skuffen som begynner å bli trukket er den siste som ble satt på stakken.

59
00:03:31,000 --> 00:03:34,000
Bunken også-som det står her-

60
00:03:34,000 --> 00:03:37,000
vi har segmentet av minnet som kalles bunken.

61
00:03:37,000 --> 00:03:40,000
Og hvorfor er det kalt stabelen?

62
00:03:40,000 --> 00:03:42,000
>> Fordi som en stabel datastruktur,

63
00:03:42,000 --> 00:03:46,000
det skyver og spretter stack rammer på stakken,

64
00:03:46,000 --> 00:03:53,000
hvor stack rammer er som en bestemt oppfordring til en funksjon.

65
00:03:53,000 --> 00:03:57,000
Og som en stabel, vil du alltid ha for å gå tilbake

66
00:03:57,000 --> 00:04:03,000
fra en funksjon samtale før du kan komme ned i lavere stack rammer igjen.

67
00:04:03,000 --> 00:04:08,000
Du kan ikke ha hoved samtale Foo samtale bar og bar tilbake til hovedsiden direkte.

68
00:04:08,000 --> 00:04:14,000
Det er alltid fikk til å følge riktig stabelen presser og spratt.

69
00:04:14,000 --> 00:04:18,000
De to operasjoner, som jeg sa, er push og pop.

70
00:04:18,000 --> 00:04:20,000
De er universelle vilkår.

71
00:04:20,000 --> 00:04:26,000
Du bør vite push og pop i form av stabler uansett hva.

72
00:04:26,000 --> 00:04:28,000
Vi får se køer er litt annerledes.

73
00:04:28,000 --> 00:04:32,000
Det gjør egentlig ikke har et universelt begrep, men push og pop er universelle for stabler.

74
00:04:32,000 --> 00:04:34,000
Push er akkurat satt på stakken.

75
00:04:34,000 --> 00:04:37,000
Pop er ta av stabelen.

76
00:04:37,000 --> 00:04:43,000
Og vi ser her har vi vår typedef struct stabelen,

77
00:04:43,000 --> 00:04:46,000
så vi har røye ** strenger.

78
00:04:46,000 --> 00:04:51,000
Ikke bli redd av noen **.

79
00:04:51,000 --> 00:04:54,000
Dette kommer til å ende opp som en rekke strenger

80
00:04:54,000 --> 00:04:58,000
eller en rekke pekere til tegn, der

81
00:04:58,000 --> 00:05:00,000
pekere til tegn tendens til å være strenger.

82
00:05:00,000 --> 00:05:05,000
Det trenger ikke å være strenger, men her, de kommer til å være strenger.

83
00:05:05,000 --> 00:05:08,000
>> Vi har en rekke strenger.

84
00:05:08,000 --> 00:05:14,000
Vi har en størrelse, som representerer hvor mange elementer er for tiden på stakken,

85
00:05:14,000 --> 00:05:19,000
og så har vi kapasitet, som er hvor mange elementer kan være på stakken.

86
00:05:19,000 --> 00:05:22,000
Kapasiteten skal begynne som noe større enn 1,

87
00:05:22,000 --> 00:05:27,000
men størrelsen kommer til å starte som 0.

88
00:05:27,000 --> 00:05:36,000
Nå er det i utgangspunktet tre forskjellige måter du kan tenke på en stabel.

89
00:05:36,000 --> 00:05:39,000
Vel, det er nok mer, men de to viktigste måtene er

90
00:05:39,000 --> 00:05:43,000
du kan implementere det ved hjelp av en matrise, eller du kan implementere det ved hjelp av en lenket liste.

91
00:05:43,000 --> 00:05:48,000
Koplede listene slags trivielt å lage stabler fra.

92
00:05:48,000 --> 00:05:51,000
Det er veldig enkelt å lage en stabel med koblede lister,

93
00:05:51,000 --> 00:05:55,000
så her, vi kommer til å lage en stack bruke matriser,

94
00:05:55,000 --> 00:05:59,000
og deretter bruke matriser, er det også to måter du kan tenke på det.

95
00:05:59,000 --> 00:06:01,000
Før, da jeg sa at vi har en kapasitet på stabelen,

96
00:06:01,000 --> 00:06:04,000
slik at vi kan passe et element på stakken.

97
00:06:04,000 --> 00:06:09,000
>> Den ene måten det kunne skje er så snart du treffer 10 elementer, så er du ferdig.

98
00:06:09,000 --> 00:06:13,000
Du kanskje vet at det er en øvre grense på 10 ting i verden

99
00:06:13,000 --> 00:06:16,000
at du aldri har mer enn 10 ting på stabelen din,

100
00:06:16,000 --> 00:06:20,000
i så fall kan du ha en øvre grense på størrelsen av stabelen din.

101
00:06:20,000 --> 00:06:23,000
Eller du kan ha din stabelen ha ubegrenset,

102
00:06:23,000 --> 00:06:27,000
men hvis du gjør en matrise, betyr det at hver eneste gang du treffer 10 elementer,

103
00:06:27,000 --> 00:06:29,000
da er du nødt til å vokse til 20 elementer, og når du treffer 20 elementer,

104
00:06:29,000 --> 00:06:33,000
du er nødt til å vokse rekke til 30 elementer eller 40 elementer.

105
00:06:33,000 --> 00:06:37,000
Du kommer til å trenge å øke kapasiteten, som er hva vi skal gjøre her.

106
00:06:37,000 --> 00:06:40,000
Hver eneste gang vi kommer til maksimal størrelse på stacken,

107
00:06:40,000 --> 00:06:46,000
når vi skyver noe annet igjen, vi kommer til å trenge for å øke kapasiteten.

108
00:06:46,000 --> 00:06:50,000
Her har vi presse erklært som bool push (char * str).

109
00:06:50,000 --> 00:06:54,000
Char * str er strengen som vi presser på stakken,

110
00:06:54,000 --> 00:06:58,000
og bool sier bare om vi lyktes eller mislyktes.

111
00:06:58,000 --> 00:07:00,000
>> Hvordan kan vi mislykkes?

112
00:07:00,000 --> 00:07:04,000
Hva er den eneste omstendighet at du kan tenke på

113
00:07:04,000 --> 00:07:07,000
der vi trenger å gå tilbake falsk?

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

115
00:07:09,000 --> 00:07:12,000
[Student] Hvis den er full, og vi bruker en avgrenset gjennomføring.

116
00:07:12,000 --> 00:07:17,000
Ja, så hvordan definerer-han vi svarte

117
00:07:17,000 --> 00:07:23,000
hvis den er full, og vi bruker en avgrenset gjennomføring.

118
00:07:23,000 --> 00:07:26,000
Da vil vi definitivt return false.

119
00:07:26,000 --> 00:07:31,000
Så snart vi traff 10 ting i matrisen, kan vi ikke passer 11, så vi return false.

120
00:07:31,000 --> 00:07:32,000
Hva om det er ubegrenset? Ja.

121
00:07:32,000 --> 00:07:38,000
Hvis du ikke kan utvide array for noen grunn.

122
00:07:38,000 --> 00:07:43,000
Ja, så minnet en begrenset ressurs,

123
00:07:43,000 --> 00:07:51,000
og til slutt, hvis vi holder skyve ting på stabelen igjen og igjen,

124
00:07:51,000 --> 00:07:54,000
vi kommer til å prøve og tildele en større utvalg for å passe

125
00:07:54,000 --> 00:07:59,000
større kapasitet, og malloc eller hva vi bruker kommer til å returnere falsk.

126
00:07:59,000 --> 00:08:02,000
Vel, vil malloc tilbake null.

127
00:08:02,000 --> 00:08:05,000
>> Husk at hver eneste gang du ringer malloc, bør du sjekke for å se om det

128
00:08:05,000 --> 00:08:12,000
returnerer null eller annet som er en korrekt fradrag.

129
00:08:12,000 --> 00:08:17,000
Siden vi ønsker å ha en ubegrenset stabelen,

130
00:08:17,000 --> 00:08:21,000
det eneste tilfellet vi kommer til å komme tilbake falske er hvis vi prøver å

131
00:08:21,000 --> 00:08:26,000
øke kapasiteten og malloc eller hva returnerer false.

132
00:08:26,000 --> 00:08:30,000
Så pop tar ingen argumenter,

133
00:08:30,000 --> 00:08:37,000
og den returnerer streng som er på toppen av stabelen.

134
00:08:37,000 --> 00:08:41,000
Uansett ble sist presset på stakken er det pop er tilbake,

135
00:08:41,000 --> 00:08:44,000
og det fjerner også det fra stabelen.

136
00:08:44,000 --> 00:08:50,000
Og legg merke til at den returnerer null hvis det ikke er noe på stakken.

137
00:08:50,000 --> 00:08:53,000
Det er alltid mulig at bunken er tom.

138
00:08:53,000 --> 00:08:55,000
I Java, hvis du er vant til det, eller andre språk,

139
00:08:55,000 --> 00:09:01,000
prøver å stikke fra en tom stabelen kan føre et unntak eller noe.

140
00:09:01,000 --> 00:09:09,000
>> Men i C, er null slags mye av tilfellene hvordan vi håndterer disse problemene.

141
00:09:09,000 --> 00:09:13,000
Retur null er hvordan vi skal markere at bunken var tom.

142
00:09:13,000 --> 00:09:16,000
Vi har gitt kode som vil teste stabelen funksjonalitet,

143
00:09:16,000 --> 00:09:19,000
implementere presse og pop.

144
00:09:19,000 --> 00:09:23,000
Dette vil ikke være mye kode.

145
00:09:23,000 --> 00:09:40,000
Jeg vil-faktisk, før vi gjør det, hint, hint-

146
00:09:40,000 --> 00:09:44,000
hvis du ikke har sett det, er malloc ikke den eneste funksjonen

147
00:09:44,000 --> 00:09:47,000
som tildeler minne på haugen for deg.

148
00:09:47,000 --> 00:09:51,000
Det er en familie av Alloc funksjoner.

149
00:09:51,000 --> 00:09:53,000
Den første er malloc, som du er vant til.

150
00:09:53,000 --> 00:09:56,000
Så er det calloc, som gjør det samme som malloc,

151
00:09:56,000 --> 00:09:59,000
men det vil null alt ut for deg.

152
00:09:59,000 --> 00:10:04,000
Hvis du noensinne har ønsket å sette alt til null etter mallocing noe

153
00:10:04,000 --> 00:10:06,000
du skal ha bare brukt calloc i første omgang i stedet for å skrive

154
00:10:06,000 --> 00:10:09,000
en for loop å nullstille hele blokken av minnet.

155
00:10:09,000 --> 00:10:15,000
>> RealLOC er som malloc og har en rekke spesielle tilfeller,

156
00:10:15,000 --> 00:10:19,000
men innerst inne hva RealLOC gjør er

157
00:10:19,000 --> 00:10:24,000
det tar en peker som allerede hadde fått tildelt.

158
00:10:24,000 --> 00:10:27,000
RealLOC er funksjonen du ønsker å betale oppmerksomhet til her.

159
00:10:27,000 --> 00:10:31,000
Det tar en peker som allerede hadde blitt returnert fra malloc.

160
00:10:31,000 --> 00:10:35,000
La oss si du ber om fra malloc en pekepinn på 10 bytes.

161
00:10:35,000 --> 00:10:38,000
Du senere innser du ønsket 20 byte,

162
00:10:38,000 --> 00:10:42,000
så du kaller RealLOC på at pekeren med 20 byte,

163
00:10:42,000 --> 00:10:47,000
og RealLOC vil automatisk kopiere over alt for deg.

164
00:10:47,000 --> 00:10:51,000
Hvis du nettopp har ringt malloc igjen, som jeg har en blokk med 10 byte.

165
00:10:51,000 --> 00:10:53,000
Nå trenger jeg en blokk med 20 byte,

166
00:10:53,000 --> 00:10:58,000
så hvis jeg malloc 20 bytes, så jeg må manuelt kopiere over de 10 bytes fra det første

167
00:10:58,000 --> 00:11:01,000
inn i andre ting og deretter gratis det første.

168
00:11:01,000 --> 00:11:04,000
RealLOC vil håndtere det for deg.

169
00:11:04,000 --> 00:11:11,000
>> Legg merke til signaturen skal være void *,

170
00:11:11,000 --> 00:11:15,000
som bare returnere en peker til minneblokk,

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

172
00:11:17,000 --> 00:11:22,000
Du kan tenke på void * som et generisk peker.

173
00:11:22,000 --> 00:11:27,000
Vanligvis du aldri avtale med void *,

174
00:11:27,000 --> 00:11:30,000
men malloc returnerer et tomrom *, og da er det bare brukt som

175
00:11:30,000 --> 00:11:34,000
Dette er faktisk kommer til å bli en char *.

176
00:11:34,000 --> 00:11:37,000
Den forrige void * som hadde blitt returnert av malloc

177
00:11:37,000 --> 00:11:41,000
Nå skal sendes til RealLOC, og deretter størrelse

178
00:11:41,000 --> 00:11:49,000
er det nye antallet byte du ønsker å fordele, slik at den nye kapasiteten.

179
00:11:49,000 --> 00:11:57,000
Jeg skal gi deg et par minutter, og gjøre det i vårt område.

180
00:11:57,000 --> 00:12:02,000
Start med Revisjon 1.

181
00:12:16,000 --> 00:12:21,000
Jeg vil stoppe deg etter forhåpentligvis om nok tid til å gjennomføre push,

182
00:12:21,000 --> 00:12:24,000
og så skal jeg gi deg en annen pause for å gjøre pop.

183
00:12:24,000 --> 00:12:27,000
Men det er egentlig ikke så mye kode i det hele tatt.

184
00:12:27,000 --> 00:12:35,000
Den mest kode er trolig den voksende ting, utvide kapasiteten.

185
00:12:35,000 --> 00:12:39,000
Ok, ikke noe press for å bli helt ferdig,

186
00:12:39,000 --> 00:12:47,000
men så lenge du føler at du er på rett vei, det er bra.

187
00:12:47,000 --> 00:12:53,000
>> Har noen noen kode de føler seg komfortabel med meg trekke opp?

188
00:12:53,000 --> 00:12:59,000
Ja, jeg vil, men har noen noen kode jeg kan trekke opp?

189
00:12:59,000 --> 00:13:05,000
Ok, du kan starte, lagre det, uansett hva det er?

190
00:13:05,000 --> 00:13:09,000
Jeg har alltid glemmer det skrittet.

191
00:13:09,000 --> 00:13:15,000
Ok, ser på push,

192
00:13:15,000 --> 00:13:18,000
vil du forklare din kode?

193
00:13:18,000 --> 00:13:24,000
[Student] Først av alt, økte jeg størrelsen.

194
00:13:24,000 --> 00:13:28,000
Jeg tror kanskje jeg bør ha som-uansett, økte jeg størrelsen,

195
00:13:28,000 --> 00:13:31,000
og jeg se om det er mindre enn kapasiteten.

196
00:13:31,000 --> 00:13:36,000
Og hvis det er mindre enn kapasiteten, legger jeg til tabellen som vi allerede har.

197
00:13:36,000 --> 00:13:42,000
Og hvis det ikke er det, multiplisere jeg kapasiteten med 2,

198
00:13:42,000 --> 00:13:50,000
og jeg omdisponere strenger array til noe med en større kapasitet størrelse nå.

199
00:13:50,000 --> 00:13:55,000
Og så hvis det mislykkes, jeg sier brukeren og return false,

200
00:13:55,000 --> 00:14:04,000
og hvis det er greit, så jeg satte strengen i det nye stedet.

201
00:14:04,000 --> 00:14:07,000
>> [Rob B.] også merke til at vi brukte en fin bitvis operatør her

202
00:14:07,000 --> 00:14:09,000
å multiplisere med 2.

203
00:14:09,000 --> 00:14:11,000
Husk at venstre shift alltid kommer til å bli multiplisert med 2.

204
00:14:11,000 --> 00:14:15,000
Høyre shift er delt på 2 så lenge du husker at det betyr

205
00:14:15,000 --> 00:14:18,000
divideres med 2 som i et heltall deles med 2..

206
00:14:18,000 --> 00:14:20,000
Det kan avkorte en 1 her eller der.

207
00:14:20,000 --> 00:14:26,000
Men skift igjen av en alltid kommer til å bli multiplisert med 2,

208
00:14:26,000 --> 00:14:32,000
med mindre du overflow grensene for heltall, og da det ikke vil være.

209
00:14:32,000 --> 00:14:34,000
En side kommentar.

210
00:14:34,000 --> 00:14:39,000
Jeg liker å gjøre-dette ikke kommer til å endre koding noen måte,

211
00:14:39,000 --> 00:14:48,000
men jeg liker å gjøre noe som dette.

212
00:14:48,000 --> 00:14:51,000
Det faktisk kommer til å gjøre det litt lenger.

213
00:15:04,000 --> 00:15:08,000
Kanskje dette er ikke den perfekte saken for å vise dette,

214
00:15:08,000 --> 00:15:14,000
men jeg liker å segmentere det i disse blokkene av-

215
00:15:14,000 --> 00:15:17,000
OK, hvis dette hvis skjer, så jeg kommer til å gjøre noe,

216
00:15:17,000 --> 00:15:19,000
og deretter funksjonen er ferdig.

217
00:15:19,000 --> 00:15:22,000
Jeg trenger ikke å deretter bla mine øyne hele veien ned funksjonen

218
00:15:22,000 --> 00:15:25,000
å se hva som skjer etter annet.

219
00:15:25,000 --> 00:15:27,000
Det er hvis dette hvis skjer, så jeg bare tilbake.

220
00:15:27,000 --> 00:15:30,000
Det har også den fine fordelen av alt utover dette

221
00:15:30,000 --> 00:15:33,000
er nå flyttet til venstre en gang.

222
00:15:33,000 --> 00:15:40,000
Jeg trenger ikke lenger å-hvis du noen gang i nærheten latterlig lange linjer,

223
00:15:40,000 --> 00:15:45,000
deretter de 4 byte kan hjelpe, og også mer igjen noe er,

224
00:15:45,000 --> 00:15:48,000
jo mindre overveldet du føle hvis liker-okay, jeg må huske

225
00:15:48,000 --> 00:15:53,000
Jeg er for tiden på en stund sløyfe inne i en annen inne i en for-løkke.

226
00:15:53,000 --> 00:15:58,000
Hvor du kan gjøre denne avkastningen umiddelbart, jeg typen som.

227
00:15:58,000 --> 00:16:05,000
Det er helt valgfritt, og ikke forventet på noen måte.

228
00:16:05,000 --> 00:16:12,000
>> [Student] Bør det være en størrelse - i fail tilstand?

229
00:16:12,000 --> 00:16:19,000
Fail tilstand her er vi ikke klarte å RealLOC, så ja.

230
00:16:19,000 --> 00:16:22,000
Legg merke til hvordan i fail tilstand, formodentlig,

231
00:16:22,000 --> 00:16:26,000
med mindre vi gratis ting senere, vi alltid kommer til å mislykkes

232
00:16:26,000 --> 00:16:29,000
uansett hvor mange ganger vi prøver å presse noe.

233
00:16:29,000 --> 00:16:32,000
Hvis vi holder skyve, holder vi økes størrelse,

234
00:16:32,000 --> 00:16:36,000
selv om vi ikke setter noe på bunken.

235
00:16:36,000 --> 00:16:39,000
Vanligvis vi ikke inkrementere størrelse inntil

236
00:16:39,000 --> 00:16:43,000
etter at vi har lykkes sette det på stakken.

237
00:16:43,000 --> 00:16:50,000
Vi ville gjøre det, sier, enten her og her.

238
00:16:50,000 --> 00:16:56,000
Og da i stedet for å si s.size ≤ kapasitet, er det mindre enn kapasiteten,

239
00:16:56,000 --> 00:17:01,000
bare fordi vi flyttet hvor alt var.

240
00:17:01,000 --> 00:17:07,000
>> Og husk, det eneste stedet vi kunne muligens return false

241
00:17:07,000 --> 00:17:14,000
er her, hvor RealLOC returnerte null,

242
00:17:14,000 --> 00:17:19,000
og hvis du tilfeldigvis å huske standard feil,

243
00:17:19,000 --> 00:17:22,000
kanskje du kan vurdere dette et tilfelle hvor du ønsker å skrive ut en standard feil,

244
00:17:22,000 --> 00:17:26,000
så fprintf stderr i stedet for bare å skrive ut direkte til standard ut.

245
00:17:26,000 --> 00:17:31,000
Igjen, det er ikke en forventning, men hvis det er en feil,

246
00:17:31,000 --> 00:17:41,000
skriver printf, bør du kanskje ønsker å gjøre det ut til standard feil i stedet for standard ut.

247
00:17:41,000 --> 00:17:44,000
>> Alle som har noe annet å merke? Ja.

248
00:17:44,000 --> 00:17:47,000
[Student] Kan du går over [uhørlig]?

249
00:17:47,000 --> 00:17:55,000
[Rob B.] Ja, selve binariness av det eller hva det er?

250
00:17:55,000 --> 00:17:57,000
[Student] Så du multipliserer det med 2?

251
00:17:57,000 --> 00:17:59,000
[Rob B.] Yeah, i utgangspunktet.

252
00:17:59,000 --> 00:18:11,000
I binær land, har vi alltid vårt sett av sifre.

253
00:18:11,000 --> 00:18:22,000
Skiftende denne venstre med 1 utgangspunktet setter den her på høyre side.

254
00:18:22,000 --> 00:18:25,000
Tilbake til dette, bare huske at alt i binær

255
00:18:25,000 --> 00:18:28,000
er en potens av 2, slik at dette representerer 2 til 0,

256
00:18:28,000 --> 00:18:30,000
denne 2 til 1, denne 2 til 2.

257
00:18:30,000 --> 00:18:33,000
Ved å sette en 0 til høyre side nå, vi bare skifte alt over.

258
00:18:33,000 --> 00:18:38,000
Det pleide å være 2 til 0 er nå 2 til 1, er 2 til 2.

259
00:18:38,000 --> 00:18:41,000
Høyre side som vi satt

260
00:18:41,000 --> 00:18:44,000
nødvendigvis kommer til å være 0,

261
00:18:44,000 --> 00:18:46,000
som er fornuftig.

262
00:18:46,000 --> 00:18:49,000
Hvis du noen gang multiplisere et tall med 2, er det ikke kommer til å ende opp rart,

263
00:18:49,000 --> 00:18:54,000
så 2 til 0 stedet skal være 0,

264
00:18:54,000 --> 00:18:59,000
og dette er hva jeg halv advart om før er hvis du klarer å skifte

265
00:18:59,000 --> 00:19:01,000
utover antallet av biter i et heltall,

266
00:19:01,000 --> 00:19:04,000
så dette en kommer til å ende opp med å gå av.

267
00:19:04,000 --> 00:19:10,000
Det er den eneste bekymring hvis du tilfeldigvis skal håndtere virkelig stor kapasitet.

268
00:19:10,000 --> 00:19:15,000
Men på det tidspunktet, så du arbeider med en rekke av milliarder av ting,

269
00:19:15,000 --> 00:19:25,000
som kanskje ikke passer inn i minnet uansett.

270
00:19:25,000 --> 00:19:31,000
>> Nå kan vi komme til pop, som er enda enklere.

271
00:19:31,000 --> 00:19:36,000
Du kan gjøre det som om du tilfeldigvis komme en hel haug,

272
00:19:36,000 --> 00:19:38,000
og nå er du på halv kapasitet igjen.

273
00:19:38,000 --> 00:19:42,000
Du kan RealLOC å krympe mengden minne du har,

274
00:19:42,000 --> 00:19:47,000
men du trenger ikke å bekymre deg for det, er så den eneste RealLOC saken kommer til å bli

275
00:19:47,000 --> 00:19:50,000
voksende minne, aldri krymper minne,

276
00:19:50,000 --> 00:19:59,000
som kommer til å gjøre pop super lett.

277
00:19:59,000 --> 00:20:02,000
Nå køer, som kommer til å være som stabler,

278
00:20:02,000 --> 00:20:06,000
men den rekkefølgen du tar ting ut er reversert.

279
00:20:06,000 --> 00:20:10,000
Den prototypiske eksempel på en kø er en linje,

280
00:20:10,000 --> 00:20:12,000
så jeg antar at hvis du var engelsk, ville jeg ha sagt

281
00:20:12,000 --> 00:20:17,000
en prototypiske eksempel på en kø er en kø.

282
00:20:17,000 --> 00:20:22,000
Så som en linje, hvis du er den første personen i linje,

283
00:20:22,000 --> 00:20:24,000
du forventer å være den første personen ut av linjen.

284
00:20:24,000 --> 00:20:31,000
Hvis du er den siste personen i linje, skal du være den siste personen service.

285
00:20:31,000 --> 00:20:35,000
Vi kaller det FIFO mønster, mens stakken var LIFO mønster.

286
00:20:35,000 --> 00:20:40,000
Disse ordene er ganske universelle.

287
00:20:40,000 --> 00:20:46,000
>> Liker stabler og i motsetning matriser, køer vanligvis ikke tillate tilgang til elementer i midten.

288
00:20:46,000 --> 00:20:50,000
Her, en stabel, har vi push og pop.

289
00:20:50,000 --> 00:20:54,000
Her skjer vi å ha kalt dem Enqueue og dequeue.

290
00:20:54,000 --> 00:20:58,000
Jeg har også hørt dem kalt skift og unshift.

291
00:20:58,000 --> 00:21:02,000
Jeg har hørt folk si push og pop til også å gjelde køer.

292
00:21:02,000 --> 00:21:05,000
Jeg har hørt sette inn, fjerne,

293
00:21:05,000 --> 00:21:11,000
så presse og pop, hvis du snakker om stabler, er du presser og spratt.

294
00:21:11,000 --> 00:21:16,000
Hvis du snakker om køer, kan du plukke de ordene du vil bruke

295
00:21:16,000 --> 00:21:23,000
for innsetting og fjerning, og det er ingen enighet om hva det skal bli kalt.

296
00:21:23,000 --> 00:21:27,000
Men her har vi Enqueue og dequeue.

297
00:21:27,000 --> 00:21:37,000
Nå ser struct nesten identisk med stabelen struct.

298
00:21:37,000 --> 00:21:40,000
Men vi må holde styr på hodet.

299
00:21:40,000 --> 00:21:44,000
Jeg antar det står her nede, men hvorfor trenger vi hodet?

300
00:21:53,000 --> 00:21:57,000
Prototypene er i utgangspunktet identisk med presse og pop.

301
00:21:57,000 --> 00:21:59,000
Du kan tenke på det som push og pop.

302
00:21:59,000 --> 00:22:08,000
Den eneste forskjellen er pop er retur-i stedet for den siste, er det tilbake den første.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, eller noe.

304
00:22:12,000 --> 00:22:14,000
Og her er starten.

305
00:22:14,000 --> 00:22:17,000
Vår køen er helt full, så det er fire elementer i den.

306
00:22:17,000 --> 00:22:21,000
Slutten av køen vår er nå 2,

307
00:22:21,000 --> 00:22:24,000
og nå går vi å sette noe annet.

308
00:22:24,000 --> 00:22:29,000
>> Når vi ønsker å sette inn at noe annet, hva vi gjorde for stabelen versjon

309
00:22:29,000 --> 00:22:36,000
er vi utvidet vår blokk med minne.

310
00:22:36,000 --> 00:22:40,000
Hva er problemet med dette?

311
00:22:40,000 --> 00:22:45,000
[Student] Du flytter to.

312
00:22:45,000 --> 00:22:51,000
Det jeg sa tidligere om slutten av køen,

313
00:22:51,000 --> 00:22:57,000
Dette rimer ikke at vi starter på 1,

314
00:22:57,000 --> 00:23:01,000
så vi ønsker å dequeue 1, så dequeue 3, så dequeue 4,

315
00:23:01,000 --> 00:23:05,000
Deretter dequeue 2, deretter dequeue denne.

316
00:23:05,000 --> 00:23:08,000
Vi kan ikke bruke RealLOC nå,

317
00:23:08,000 --> 00:23:11,000
eller i det minste, må du bruke RealLOC på en annen måte.

318
00:23:11,000 --> 00:23:15,000
Men du sannsynligvis ikke bør bare bruke RealLOC.

319
00:23:15,000 --> 00:23:18,000
Du er nødt til å manuelt kopiere minne.

320
00:23:18,000 --> 00:23:21,000
>> Det er to funksjoner for å kopiere minne.

321
00:23:21,000 --> 00:23:25,000
Det er memcopy og memmove.

322
00:23:25,000 --> 00:23:29,000
Jeg er for tiden leser mannen sidene for å se hvilken du skal ønske å bruke.

323
00:23:29,000 --> 00:23:35,000
Ok, memcopy, er forskjellen

324
00:23:35,000 --> 00:23:38,000
at memcopy og memmove, man håndterer saken riktig

325
00:23:38,000 --> 00:23:41,000
hvor du kopierer inn i et område som skjer for å overlappe regionen

326
00:23:41,000 --> 00:23:46,000
du kopierer fra.

327
00:23:46,000 --> 00:23:50,000
Memcopy ikke håndterer det. Memmove gjør.

328
00:23:50,000 --> 00:23:59,000
Du kan tenke på problemet som-

329
00:23:59,000 --> 00:24:09,000
la oss si jeg ønsker å kopiere denne fyren,

330
00:24:09,000 --> 00:24:13,000
disse fire til denne fyren.

331
00:24:13,000 --> 00:24:16,000
Til slutt, hva matrisen skal se ut

332
00:24:16,000 --> 00:24:26,000
Etter at kopieringen er 2, 1, 2, 1, 3, 4, og deretter noen ting på slutten.

333
00:24:26,000 --> 00:24:29,000
Men dette er avhengig av rekkefølgen i hvilken vi faktisk kopiere,

334
00:24:29,000 --> 00:24:32,000
siden hvis vi ikke anser det faktum at regionen vi kopierer inn

335
00:24:32,000 --> 00:24:35,000
overlapper den vi kopierer fra,

336
00:24:35,000 --> 00:24:46,000
så vi kan gjøre som start her, kopiere to i stedet vi ønsker å gå,

337
00:24:46,000 --> 00:24:52,000
deretter flytte våre pekere fremover.

338
00:24:52,000 --> 00:24:56,000
>> Nå skal vi være her og her, og nå ønsker vi å kopiere

339
00:24:56,000 --> 00:25:04,000
denne fyren over denne fyren og flytte våre pekere fremover.

340
00:25:04,000 --> 00:25:07,000
Hva vi kommer til å ende opp med å få er 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
i stedet for den aktuelle 2, 1, 2, 1, 3, 4, fordi

342
00:25:10,000 --> 00:25:15,000
2, 1 overvurdere den opprinnelige 3, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove håndterer det riktig.

344
00:25:19,000 --> 00:25:23,000
I dette tilfellet, i utgangspunktet bare alltid bruke memmove

345
00:25:23,000 --> 00:25:26,000
fordi den håndterer det riktig.

346
00:25:26,000 --> 00:25:29,000
Det vanligvis ikke utfører noe verre.

347
00:25:29,000 --> 00:25:32,000
Ideen er stedet for å starte fra begynnelsen og kopiere denne måten

348
00:25:32,000 --> 00:25:35,000
som vi nettopp gjorde her, starter det fra slutten og kopierer inn,

349
00:25:35,000 --> 00:25:38,000
og i så fall, kan du aldri ha et problem.

350
00:25:38,000 --> 00:25:40,000
Det er ingen ytelse tapt.

351
00:25:40,000 --> 00:25:47,000
Bruk alltid memmove. Aldri bekymre memcopy.

352
00:25:47,000 --> 00:25:51,000
Og det er der du er nødt til å separat memmove

353
00:25:51,000 --> 00:26:01,000
innpakket rundt delen av køen.

354
00:26:01,000 --> 00:26:04,000
Ingen grunn til bekymring dersom ikke helt ferdig.

355
00:26:04,000 --> 00:26:10,000
Dette er vanskeligere enn stack, push, og pop.

356
00:26:10,000 --> 00:26:15,000
>> Alle som har noen kode vi kunne jobbe med?

357
00:26:15,000 --> 00:26:21,000
Selv om helt ufullstendig?

358
00:26:21,000 --> 00:26:23,000
[Student] Ja, det er helt ufullstendig, skjønt.

359
00:26:23,000 --> 00:26:27,000
Helt ufullstendig er greit så lenge vi-kan du lagre revisjon?

360
00:26:27,000 --> 00:26:32,000
Jeg glemmer at hver eneste gang.

361
00:26:32,000 --> 00:26:39,000
Ok, ignorerer hva som skjer når vi trenger å endre størrelsen ting.

362
00:26:39,000 --> 00:26:42,000
Fullstendig ignorere resize.

363
00:26:42,000 --> 00:26:49,000
Forklar denne koden.

364
00:26:49,000 --> 00:26:54,000
Jeg sjekker først hvis størrelsen er mindre enn den kopi først av alt

365
00:26:54,000 --> 00:27:01,000
og så etter det, jeg setter-jeg ta hodet + størrelse,

366
00:27:01,000 --> 00:27:05,000
og jeg sørge for at det brytes rundt kapasiteten for tabellen,

367
00:27:05,000 --> 00:27:08,000
og jeg setter den nye strengen på den posisjonen.

368
00:27:08,000 --> 00:27:12,000
Så jeg øke størrelsen og returnere true.

369
00:27:12,000 --> 00:27:22,000
>> [Rob B.] Dette er definitivt en av de tilfellene der du kommer til å ønske å bruke mod.

370
00:27:22,000 --> 00:27:25,000
Enhver form for tilfelle der du har innpakning rundt, hvis du tror innpakning rundt,

371
00:27:25,000 --> 00:27:29,000
den umiddelbare tanke bør være mod.

372
00:27:29,000 --> 00:27:36,000
Som en rask optimalisering / gjøre koden en linje kortere,

373
00:27:36,000 --> 00:27:42,000
du merker at linjen umiddelbart etter dette

374
00:27:42,000 --> 00:27:53,000
er bare størrelse + +, så du flette det inn denne linjen, størrelse + +.

375
00:27:53,000 --> 00:27:58,000
Nå her nede, har vi saken

376
00:27:58,000 --> 00:28:01,000
hvor vi ikke har nok minne,

377
00:28:01,000 --> 00:28:05,000
så vi øker vår kapasitet med 2.

378
00:28:05,000 --> 00:28:09,000
Jeg antar du kan ha det samme problemet her, men vi kan ignorere det nå,

379
00:28:09,000 --> 00:28:13,000
der hvis du ikke klarte å øke kapasiteten,

380
00:28:13,000 --> 00:28:18,000
så du kommer til å ønske å redusere kapasiteten med 2 igjen.

381
00:28:18,000 --> 00:28:24,000
En annen liten notis er akkurat som du kan gjøre + =,

382
00:28:24,000 --> 00:28:30,000
du kan også gjøre << =.

383
00:28:30,000 --> 00:28:43,000
Nesten alt kan gå før lik, + =, | =, & =, << =.

384
00:28:43,000 --> 00:28:52,000
Char * nye er vår nye blokk med minne.

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

386
00:28:55,000 --> 00:29:02,000
>> Hva synes folk om hvilken type vår nye blokk med minne?

387
00:29:02,000 --> 00:29:06,000
[Student] Det bør være char **.

388
00:29:06,000 --> 00:29:12,000
Tenker tilbake til struct vår her oppe,

389
00:29:12,000 --> 00:29:14,000
strenger er det vi omfordele.

390
00:29:14,000 --> 00:29:21,000
Vi gjør en hel ny dynamisk lagring for elementene i køen.

391
00:29:21,000 --> 00:29:25,000
Hva vi kommer til å bli tildeling av strenger er det vi mallocing akkurat nå,

392
00:29:25,000 --> 00:29:30,000
og så ny kommer til å bli en røye. **

393
00:29:30,000 --> 00:29:34,000
Det kommer til å bli en rekke strenger.

394
00:29:34,000 --> 00:29:38,000
Så hva er tilfellet der vi kommer til å returnere falsk?

395
00:29:38,000 --> 00:29:41,000
[Student] Bør vi gjøre char *?

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

397
00:29:44,000 --> 00:29:46,000
[Student] Hva var det?

398
00:29:46,000 --> 00:29:49,000
[Rob B.] Vi ønsket å gjøre størrelsen på char * fordi vi ikke lenger er-

399
00:29:49,000 --> 00:29:53,000
dette ville faktisk være et veldig stort problem fordi sizeof (char) ville være en.

400
00:29:53,000 --> 00:29:55,000
Sizeof char * kommer til å være 4,

401
00:29:55,000 --> 00:29:58,000
så mange ganger når du arbeider med ints,

402
00:29:58,000 --> 00:30:01,000
du har en tendens til å komme unna med det fordi størrelsen på int og størrelse på int *

403
00:30:01,000 --> 00:30:04,000
på en 32-bit system kommer til å være det samme.

404
00:30:04,000 --> 00:30:09,000
Men her, sizeof (char) og sizeof (char *) skal nå være det samme.

405
00:30:09,000 --> 00:30:15,000
>> Hva er forholdet hvor vi return false?

406
00:30:15,000 --> 00:30:17,000
[Student] Nytt er null.

407
00:30:17,000 --> 00:30:23,000
Ja, dersom ny er null, returnerer vi false,

408
00:30:23,000 --> 00:30:34,000
og jeg kommer til å kaste ned her-

409
00:30:34,000 --> 00:30:37,000
[Student] [uhørlig]

410
00:30:37,000 --> 00:30:39,000
[Rob B.] Yeah, dette er greit.

411
00:30:39,000 --> 00:30:46,000
Du kan enten gjøre to ganger kapasiteten eller kapasitet skift 1 og deretter bare sette den ned her eller hva.

412
00:30:46,000 --> 00:30:52,000
Vi vil gjøre det som vi hadde det.

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

414
00:30:56,000 --> 00:31:08,000
Og du aldri kommer til å måtte bekymre deg for å miste en plass

415
00:31:08,000 --> 00:31:12,000
fordi du forlot forskjøvet med 1, slik at en plass er nødvendigvis en 0,

416
00:31:12,000 --> 00:31:16,000
så rett skiftende med 1, er du fortsatt kommer til å være i orden.

417
00:31:16,000 --> 00:31:19,000
[Student] Trenger du å gjøre det før retur?

418
00:31:19,000 --> 00:31:29,000
[Rob B.] Ja, gjør dette absolutt ingen mening.

419
00:31:29,000 --> 00:31:36,000
>> Nå antar vi kommer til å ende opp tilbake true til slutten.

420
00:31:36,000 --> 00:31:39,000
Måten vi kommer til å gjøre disse memmoves,

421
00:31:39,000 --> 00:31:45,000
Vi må være forsiktig med hvordan vi gjør det.

422
00:31:45,000 --> 00:31:50,000
Har noen noen forslag til hvordan vi gjør dem?

423
00:32:17,000 --> 00:32:21,000
Her er vår start.

424
00:32:21,000 --> 00:32:28,000
Uunngåelig, ønsker vi å starte på begynnelsen igjen

425
00:32:28,000 --> 00:32:35,000
og kopiere ting i fra det, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
Hvordan gjør man det?

427
00:32:41,000 --> 00:32:52,000
Først må jeg se på mannen siden for memmove igjen.

428
00:32:52,000 --> 00:32:57,000
Memmove, er rekkefølgen som argumentene alltid viktig.

429
00:32:57,000 --> 00:33:01,000
Vi ønsker vår destinasjon først, kilde andre, størrelse tredje.

430
00:33:01,000 --> 00:33:06,000
Det er mange funksjoner som reverserer kilde og destinasjon.

431
00:33:06,000 --> 00:33:11,000
Destination, kilde tendens til å være konsekvent noe.

432
00:33:17,000 --> 00:33:21,000
Flytte, hva er det tilbake?

433
00:33:21,000 --> 00:33:27,000
Den returnerer en peker til bestemmelsesstedet, uansett grunn du kanskje ønsker det.

434
00:33:27,000 --> 00:33:32,000
Jeg kan bilde lese den, men vi ønsker å flytte inn vår destinasjon.

435
00:33:32,000 --> 00:33:35,000
>> Hva er vår destinasjon kommer til å bli?

436
00:33:35,000 --> 00:33:37,000
[Student] Ny.

437
00:33:37,000 --> 00:33:39,000
[Rob B.] Ja, og hvor er vi kopierer fra?

438
00:33:39,000 --> 00:33:43,000
Det første vi kopierer dette er 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
Hva er-dette 1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
Hva er adressen til dette 1?

441
00:33:55,000 --> 00:33:58,000
Hva er adressen til den 1?

442
00:33:58,000 --> 00:34:01,000
[Student] [uhørlig]

443
00:34:01,000 --> 00:34:03,000
[Rob B.] Leder + adressen til den første element.

444
00:34:03,000 --> 00:34:05,000
Hvordan får vi det første elementet i matrisen?

445
00:34:05,000 --> 00:34:10,000
[Student] kø.

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

447
00:34:15,000 --> 00:34:20,000
Husk, her er vårt hode en.

448
00:34:20,000 --> 00:34:24,000
Stoppe. Jeg tror det er magisk-

449
00:34:24,000 --> 00:34:29,000
Her er vårt hode en. Jeg kommer til å endre min farge også.

450
00:34:29,000 --> 00:34:36,000
Og her er strenger.

451
00:34:36,000 --> 00:34:41,000
Dette kan vi enten skrive det som vi gjorde over her

452
00:34:41,000 --> 00:34:43,000
med hode + q.strings.

453
00:34:43,000 --> 00:34:51,000
Mange mennesker også skrive det og q.strings [hodet].

454
00:34:51,000 --> 00:34:55,000
Dette er egentlig ikke noe mindre effektiv.

455
00:34:55,000 --> 00:34:58,000
Du kan tenke på det som du dereferencing det og så får adressen,

456
00:34:58,000 --> 00:35:04,000
men kompilatoren skal oversette det til hva vi hadde før uansett, q.strings + hode.

457
00:35:04,000 --> 00:35:06,000
Uansett du ønsker å tenke på det.

458
00:35:06,000 --> 00:35:11,000
>> Og hvor mange byte vi ønsker å kopiere?

459
00:35:11,000 --> 00:35:15,000
[Student] Kapasitet - hodet.

460
00:35:15,000 --> 00:35:18,000
Kapasitet - hodet.

461
00:35:18,000 --> 00:35:21,000
Og så kan du alltid skrive ut et eksempel

462
00:35:21,000 --> 00:35:23,000
å finne ut om det er riktig.

463
00:35:23,000 --> 00:35:26,000
[Student] Det må deles med 2 da.

464
00:35:26,000 --> 00:35:30,000
Ja, så jeg antar at vi kunne bruke størrelse.

465
00:35:30,000 --> 00:35:35,000
Vi har fortsatt størrelse being-

466
00:35:35,000 --> 00:35:39,000
hjelp av størrelse, har vi størrelse lik 4.

467
00:35:39,000 --> 00:35:42,000
Vår størrelse er 4. Vår leder er en.

468
00:35:42,000 --> 00:35:46,000
Vi ønsker å kopiere disse tre elementene.

469
00:35:46,000 --> 00:35:54,000
Det er sunn fornuft kontrollere at størrelsen - hodet er riktig 3.

470
00:35:54,000 --> 00:35:58,000
Og kommer tilbake hit, som vi sa før,

471
00:35:58,000 --> 00:36:00,000
hvis vi brukte kapasitet, så vi måtte dele med 2

472
00:36:00,000 --> 00:36:04,000
fordi vi allerede har vokst vår kapasitet, så i stedet, vi kommer til å bruke størrelse.

473
00:36:11,000 --> 00:36:13,000
At kopier den delen.

474
00:36:13,000 --> 00:36:18,000
Nå må vi kopiere den andre delen, den delen som er igjen av starten.

475
00:36:18,000 --> 00:36:28,000
>> Det kommer til å memmove inn hvilken posisjon?

476
00:36:28,000 --> 00:36:32,000
[Student] Plus størrelse - hodet.

477
00:36:32,000 --> 00:36:38,000
Ja, så vi har allerede kopiert i størrelse - head bytes,

478
00:36:38,000 --> 00:36:43,000
og så hvor vi ønsker å kopiere de resterende bytes er nytt

479
00:36:43,000 --> 00:36:48,000
og deretter størrelse minus-vel, antall byte vi allerede har kopiert i.

480
00:36:48,000 --> 00:36:52,000
Og deretter hvor vi kopierer fra?

481
00:36:52,000 --> 00:36:54,000
[Student] 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
Vi kan enten gjøre og q.strings [0].

484
00:37:02,000 --> 00:37:05,000
Dette er betydelig mindre vanlig enn dette.

485
00:37:05,000 --> 00:37:14,000
Hvis det bare kommer til å være 0, så vil du pleier å se q.strings.

486
00:37:14,000 --> 00:37:16,000
Det er der vi kopierer fra.

487
00:37:16,000 --> 00:37:18,000
Hvor mange byte har vi igjen å kopiere? >> [Student] 10.

488
00:37:18,000 --> 00:37:20,000
Høyre.

489
00:37:20,000 --> 00:37:25,000
[Student] Har vi å formere 5 - 10 ganger størrelsen på byte eller noe?

490
00:37:25,000 --> 00:37:30,000
Ja, så dette er hvor-hva er det vi kopiering?

491
00:37:30,000 --> 00:37:32,000
[Student] [uhørlig]

492
00:37:32,000 --> 00:37:34,000
Hva er den type ting vi kopierer?

493
00:37:34,000 --> 00:37:36,000
[Student] [uhørlig]

494
00:37:36,000 --> 00:37:41,000
Ja, så char * s som vi kopierer, vet vi ikke hvor de kommer fra.

495
00:37:41,000 --> 00:37:47,000
Vel, hvor de peker til, som strengene, ender vi opp med å skyve den på køen

496
00:37:47,000 --> 00:37:49,000
eller enqueuing på køen.

497
00:37:49,000 --> 00:37:51,000
Hvor de kommer fra, aner vi ikke.

498
00:37:51,000 --> 00:37:56,000
Vi trenger bare å holde styr på char * s selv.

499
00:37:56,000 --> 00:38:00,000
Vi ønsker ikke å kopiere størrelse - head bytes.

500
00:38:00,000 --> 00:38:03,000
Vi ønsker å kopiere størrelse - head char * s,

501
00:38:03,000 --> 00:38:11,000
så vi kommer til å mangedoble dette ved sizeof (char *).

502
00:38:11,000 --> 00:38:17,000
Samme her nede, hodet * sizeof (char *).

503
00:38:17,000 --> 00:38:24,000
>> [Student] Hva med [uhørlig]?

504
00:38:24,000 --> 00:38:26,000
Dette her?

505
00:38:26,000 --> 00:38:28,000
[Student] Nei, under det, størrelsen - hodet.

506
00:38:28,000 --> 00:38:30,000
[Rob B.] Denne retten her?

507
00:38:30,000 --> 00:38:32,000
Peker aritmetikk.

508
00:38:32,000 --> 00:38:35,000
Hvordan pekeren aritmetiske kommer til å fungere er

509
00:38:35,000 --> 00:38:40,000
det multipliserer automatisk av størrelsen av den type som vi har å gjøre med.

510
00:38:40,000 --> 00:38:46,000
Akkurat som over her, nye + (størrelse - hode)

511
00:38:46,000 --> 00:38:56,000
er nøyaktig tilsvarer & nye [size - head]

512
00:38:56,000 --> 00:39:00,000
før vi forventer at det vil fungere riktig,

513
00:39:00,000 --> 00:39:04,000
siden hvis vi arbeider med en int array, så vi ikke indeksen med int-

514
00:39:04,000 --> 00:39:07,000
eller om det er av størrelse på 5 og du vil at fjerde element, så vi indeksen i

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

516
00:39:10,000 --> 00:39:14,000
Du må få [4] * størrelsen på int.

517
00:39:14,000 --> 00:39:21,000
Som håndterer det automatisk, og dette tilfellet

518
00:39:21,000 --> 00:39:29,000
er bokstavelig tilsvarende, slik at braketten syntaksen

519
00:39:29,000 --> 00:39:34,000
er bare kommer til å bli konvertert til dette så snart du kompilere.

520
00:39:34,000 --> 00:39:38,000
Det er noe du må være forsiktig med at

521
00:39:38,000 --> 00:39:42,000
når du legger størrelse - head

522
00:39:42,000 --> 00:39:45,000
du legger ikke en byte.

523
00:39:45,000 --> 00:39:53,000
Du legger en char *, som kan være en byte eller hva.

524
00:39:53,000 --> 00:39:56,000
>> Andre spørsmål?

525
00:39:56,000 --> 00:40:04,000
Ok, dequeue kommer til å bli lettere.

526
00:40:04,000 --> 00:40:11,000
Jeg skal gi deg et minutt å gjennomføre.

527
00:40:11,000 --> 00:40:18,000
Oh, og jeg tror dette er den samme situasjonen der

528
00:40:18,000 --> 00:40:21,000
hva Enqueue tilfelle, hvis vi enqueuing null,

529
00:40:21,000 --> 00:40:24,000
kanskje vi ønsker å håndtere det, kanskje vi ikke.

530
00:40:24,000 --> 00:40:27,000
Vi vil ikke gjøre det igjen her, men samme som vår stack saken.

531
00:40:27,000 --> 00:40:34,000
Hvis vi Enqueue null, kanskje vi ønsker å se bort fra det.

532
00:40:34,000 --> 00:40:40,000
Noen har noen kode jeg kan trekke opp?

533
00:40:40,000 --> 00:40:45,000
[Student] Jeg må bare dequeue.

534
00:40:45,000 --> 00:40:56,000
Versjon 2 er at-okay.

535
00:40:56,000 --> 00:40:59,000
Du ønsker å forklare?

536
00:40:59,000 --> 00:41:01,000
[Student] Først må du sikker på at det er noe i køen

537
00:41:01,000 --> 00:41:07,000
og at størrelsen går ned 1.

538
00:41:07,000 --> 00:41:11,000
Du trenger å gjøre det, og du returnere hodet

539
00:41:11,000 --> 00:41:13,000
og deretter bevege hodet opp en.

540
00:41:13,000 --> 00:41:19,000
Ok, så det er et hjørne tilfelle vi må vurdere. Ja.

541
00:41:19,000 --> 00:41:24,000
[Student] Hvis hodet er på det siste elementet,

542
00:41:24,000 --> 00:41:26,000
så du ikke vil hodet til å peke utenfor tabellen.

543
00:41:26,000 --> 00:41:29,000
>> Ja, slik at så snart hodet treffer slutten av matrisen vår,

544
00:41:29,000 --> 00:41:35,000
når vi dequeue, bør vår hodet modded tilbake til 0.

545
00:41:35,000 --> 00:41:40,000
Dessverre kan vi ikke gjøre det i ett trinn.

546
00:41:40,000 --> 00:41:44,000
Jeg antar slik jeg ville trolig fikse det er

547
00:41:44,000 --> 00:41:52,000
dette kommer til å bli en char *, hva vi er tilbake,

548
00:41:52,000 --> 00:41:55,000
uansett variabelnavn ønsker å være.

549
00:41:55,000 --> 00:42:02,000
Så vi ønsker å mod hodet av kapasiteten vår

550
00:42:02,000 --> 00:42:10,000
og deretter tilbake ret.

551
00:42:10,000 --> 00:42:14,000
En masse folk her de kan gjøre,

552
00:42:14,000 --> 00:42:19,000
dette er tilfelle for-vil du se folk gjøre hvis hodet

553
00:42:19,000 --> 00:42:29,000
er større enn kapasiteten, gjør hodet - kapasitet.

554
00:42:29,000 --> 00:42:36,000
Og det er bare å jobbe rundt hva mod er.

555
00:42:36,000 --> 00:42:41,000
Hode mod = kapasiteten er mye renere

556
00:42:41,000 --> 00:42:51,000
av en innpakning rundt enn om hodet større enn kapasiteten hodet - kapasitet.

557
00:42:51,000 --> 00:42:56,000
>> Spørsmål?

558
00:42:56,000 --> 00:43:02,000
Ok, er det siste vi har forlatt vår lenket liste.

559
00:43:02,000 --> 00:43:07,000
Du kan bli brukt til noen av lenket liste oppførsel hvis du gjorde

560
00:43:07,000 --> 00:43:11,000
knyttet lister i dine hash tabeller, hvis du gjorde en hash table.

561
00:43:11,000 --> 00:43:15,000
Jeg anbefaler på det sterkeste å gjøre en hash table.

562
00:43:15,000 --> 00:43:17,000
Du har kanskje allerede gjort en trie,

563
00:43:17,000 --> 00:43:23,000
men prøver er vanskeligere.

564
00:43:23,000 --> 00:43:27,000
I teorien er de asymptotisk bedre.

565
00:43:27,000 --> 00:43:30,000
Men bare se på det store bord,

566
00:43:30,000 --> 00:43:35,000
og prøver aldri gjøre det bedre, og de tar opp mer minne.

567
00:43:35,000 --> 00:43:43,000
Alt prøver om ender opp med å bli verre for mer arbeid.

568
00:43:43,000 --> 00:43:49,000
Det er hva David Malan løsning alltid er

569
00:43:49,000 --> 00:43:56,000
er han alltid innlegg hans trie løsning, og la oss se hvor han nå er.

570
00:43:56,000 --> 00:44:00,000
Hva var han under, David J?

571
00:44:00,000 --> 00:44:06,000
Han er nr. 18, så det er ikke veldig dårlig,

572
00:44:06,000 --> 00:44:09,000
og det kommer til å bli en av de beste prøver du kan tenke på

573
00:44:09,000 --> 00:44:17,000
eller en av de beste prøver av en trie.

574
00:44:17,000 --> 00:44:23,000
Er det ikke engang hans opprinnelige løsningen?

575
00:44:23,000 --> 00:44:29,000
Jeg føler at Trie løsninger har en tendens til å være mer i dette området av RAM-bruk.

576
00:44:29,000 --> 00:44:33,000
>> Gå ned til toppen, og RAM-bruk er i enkelttall.

577
00:44:33,000 --> 00:44:36,000
Gå ned mot bunnen, og deretter begynne å se prøver

578
00:44:36,000 --> 00:44:41,000
hvor du får helt enormt RAM-bruk,

579
00:44:41,000 --> 00:44:45,000
og prøver er vanskeligere.

580
00:44:45,000 --> 00:44:53,000
Ikke helt verdt det, men en pedagogisk opplevelse hvis du gjorde en.

581
00:44:53,000 --> 00:44:56,000
Det siste er vår lenket liste,

582
00:44:56,000 --> 00:45:04,000
og disse tre tingene, stabler, køer, og koblede lister,

583
00:45:04,000 --> 00:45:09,000
eventuell fremtidig ting du aldri gjøre i informatikk

584
00:45:09,000 --> 00:45:12,000
vil anta at du har kjennskap til disse tingene.

585
00:45:12,000 --> 00:45:19,000
De er bare så grunnleggende for alt.

586
00:45:19,000 --> 00:45:25,000
>> Knyttet lister, og her har vi en enkeltvis lenket liste kommer til å være vår gjennomføring.

587
00:45:25,000 --> 00:45:34,000
Hva betyr enkeltvis knyttet betyr i motsetning til dobbelt knyttet? Ja.

588
00:45:34,000 --> 00:45:37,000
[Student] Det peker bare til den neste pekeren snarere enn til markørene,

589
00:45:37,000 --> 00:45:39,000
som den forut den og den ene etter den.

590
00:45:39,000 --> 00:45:44,000
Ja, så i bildeformat, hva gjorde jeg nettopp?

591
00:45:44,000 --> 00:45:48,000
Jeg har to ting. Jeg har bilde og bilde.

592
00:45:48,000 --> 00:45:51,000
I bildeformat, våre enkeltvis knyttet lister,

593
00:45:51,000 --> 00:45:57,000
uunngåelig, har vi en slags pekepinn på hodet av vår liste,

594
00:45:57,000 --> 00:46:02,000
og deretter innen vår liste, vi må bare pekere,

595
00:46:02,000 --> 00:46:05,000
og kanskje dette peker til null.

596
00:46:05,000 --> 00:46:08,000
Det kommer til å være typisk tegning av en enkeltvis lenket liste.

597
00:46:08,000 --> 00:46:14,000
En dobbelt lenket liste, kan du gå bakover.

598
00:46:14,000 --> 00:46:19,000
Hvis jeg gir deg noen node i listen, så kan du nødvendigvis komme til

599
00:46:19,000 --> 00:46:23,000
enhver annen node i listen hvis det er en dobbelt lenket liste.

600
00:46:23,000 --> 00:46:27,000
Men hvis jeg får du den tredje node i listen, og det er en enkeltvis lenket liste,

601
00:46:27,000 --> 00:46:30,000
ingen måte du noen gang kommer til å få til den første og andre noder.

602
00:46:30,000 --> 00:46:34,000
Og det er fordeler og detriments, og en åpenbar en

603
00:46:34,000 --> 00:46:42,000
er å ta deg opp mer størrelse, og du må holde styr på hvor disse tingene peker nå.

604
00:46:42,000 --> 00:46:49,000
Men vi bare bryr seg om enkeltvis sammen.

605
00:46:49,000 --> 00:46:53,000
>> Et par ting vi er nødt til å gjennomføre.

606
00:46:53,000 --> 00:47:00,000
Din typedef struct node, int i: struct node * neste; node.

607
00:47:00,000 --> 00:47:09,000
Det typedef skal brennes inn i dine tanker.

608
00:47:09,000 --> 00:47:14,000
Quiz 1 bør gjerne gi en typedef av en lenket liste node,

609
00:47:14,000 --> 00:47:18,000
og du bør være i stand til umiddelbart rable det ned

610
00:47:18,000 --> 00:47:22,000
uten engang å tenke på det.

611
00:47:22,000 --> 00:47:27,000
Jeg antar et par spørsmål, hvorfor vi trenger struct her?

612
00:47:27,000 --> 00:47:32,000
Hvorfor kan ikke vi si node *?

613
00:47:32,000 --> 00:47:35,000
[Student] [uhørlig]

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

615
00:47:38,000 --> 00:47:44,000
Det eneste som definerer en node som en ting

616
00:47:44,000 --> 00:47:47,000
er typedef selv.

617
00:47:47,000 --> 00:47:55,000
Men som av dette punktet, når vi er slags parsing gjennom denne struct node definisjon,

618
00:47:55,000 --> 00:48:01,000
Vi er ikke ferdig vår typedef ennå, så da typedef ikke er ferdig,

619
00:48:01,000 --> 00:48:05,000
node finnes ikke.

620
00:48:05,000 --> 00:48:12,000
Men struct node gjør, denne noden og her,

621
00:48:12,000 --> 00:48:14,000
dette kan også bli kalt noe annet.

622
00:48:14,000 --> 00:48:16,000
Dette kan kalles n.

623
00:48:16,000 --> 00:48:19,000
Det kan bli kalt lenket liste node.

624
00:48:19,000 --> 00:48:21,000
Det kan kalles noe.

625
00:48:21,000 --> 00:48:26,000
Men dette struct node trenger å bli kalt det samme som denne struct node.

626
00:48:26,000 --> 00:48:29,000
Hva du kaller dette å også være her,

627
00:48:29,000 --> 00:48:32,000
og slik at besvarer også det andre punktet av spørsmålet

628
00:48:32,000 --> 00:48:37,000
som er grunnen til-en rekke ganger når du ser structs og typedefs av structs,

629
00:48:37,000 --> 00:48:42,000
vil du se anonyme structs der du bare se typedef struct,

630
00:48:42,000 --> 00:48:47,000
gjennomføring av struct, ordbok, eller hva.

631
00:48:47,000 --> 00:48:51,000
>> Hvorfor her trenger vi å si node?

632
00:48:51,000 --> 00:48:54,000
Hvorfor kan det ikke være en anonym struct?

633
00:48:54,000 --> 00:48:56,000
Det er nesten det samme svaret.

634
00:48:56,000 --> 00:48:58,000
[Student] Du må referere til det i struct.

635
00:48:58,000 --> 00:49:04,000
Ja, i struct, må du referere til struct seg selv.

636
00:49:04,000 --> 00:49:10,000
Hvis du ikke gi struct et navn, hvis det er en anonym struct, kan du ikke se det.

637
00:49:10,000 --> 00:49:17,000
Og sist men ikke minst disse bør alle være litt grei,

638
00:49:17,000 --> 00:49:20,000
og de skal hjelpe deg å realisere hvis du skriver dette ned

639
00:49:20,000 --> 00:49:24,000
at du gjør noe galt hvis disse slags ting ikke gir mening.

640
00:49:24,000 --> 00:49:28,000
Sist men ikke minst, hvorfor dette måtte være struct node *?

641
00:49:28,000 --> 00:49:34,000
Hvorfor kan det ikke bare være struct node neste?

642
00:49:34,000 --> 00:49:37,000
[Student] Peker til neste struct.

643
00:49:37,000 --> 00:49:39,000
Det er uunngåelig hva vi ønsker.

644
00:49:39,000 --> 00:49:42,000
Hvorfor kan det aldri bli struct node neste?

645
00:49:42,000 --> 00:49:50,000
Hvorfor må det være struct node * neste? Ja.

646
00:49:50,000 --> 00:49:53,000
[Student] Det er som en uendelig loop.

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

648
00:49:55,000 --> 00:49:57,000
[Student] Det ville alle være i ett.

649
00:49:57,000 --> 00:50:02,000
Ja, bare tenk på hvordan vi ville gjøre størrelsen på eller noe.

650
00:50:02,000 --> 00:50:08,000
Størrelsen på en struct er i utgangspunktet + eller - noe mønster her eller der.

651
00:50:08,000 --> 00:50:15,000
Det er i utgangspunktet kommer til å være summen av størrelsen på ting i struct.

652
00:50:15,000 --> 00:50:18,000
Dette her, uten å endre noe, er størrelsen kommer til å bli lett.

653
00:50:18,000 --> 00:50:24,000
Størrelsen på struct node kommer til å være størrelsen på i + størrelse neste.

654
00:50:24,000 --> 00:50:27,000
Størrelsen jeg kommer til å være 4. Størrelsen neste kommer til å være 4.

655
00:50:27,000 --> 00:50:30,000
Størrelsen på struct node skal være 8.

656
00:50:30,000 --> 00:50:34,000
Hvis vi ikke har *, tenker på sizeof,

657
00:50:34,000 --> 00:50:37,000
deretter sizeof (i) skal være 4.

658
00:50:37,000 --> 00:50:43,000
Størrelsen på struct node neste kommer til å bli størrelsen på i + størrelse struct node neste

659
00:50:43,000 --> 00:50:46,000
+ Størrelse i + størrelse struct node neste.

660
00:50:46,000 --> 00:50:55,000
Det ville være en uendelig rekursjon av noder.

661
00:50:55,000 --> 00:51:00,000
Dette er grunnen til at dette er hvordan ting må være.

662
00:51:00,000 --> 00:51:03,000
>> Igjen, definitivt huske at

663
00:51:03,000 --> 00:51:06,000
eller i det minste forstår det nok at du kan være i stand til å

664
00:51:06,000 --> 00:51:12,000
Årsaken gjennom hva det skal se ut.

665
00:51:12,000 --> 00:51:14,000
De tingene vi kommer til å ønske å gjennomføre.

666
00:51:14,000 --> 00:51:18,000
Hvis lengden på listen-

667
00:51:18,000 --> 00:51:21,000
du kan jukse og holde rundt en

668
00:51:21,000 --> 00:51:24,000
global lengde eller noe, men vi kommer ikke til å gjøre det.

669
00:51:24,000 --> 00:51:28,000
Vi skal telle lengden av listen.

670
00:51:28,000 --> 00:51:34,000
Vi har inneholder, så det er i utgangspunktet som et søk,

671
00:51:34,000 --> 00:51:41,000
så vi har en lenket liste av heltall for å se om dette heltall er i lenket liste.

672
00:51:41,000 --> 00:51:44,000
Prepend skal sette på begynnelsen av listen.

673
00:51:44,000 --> 00:51:46,000
Tilføy skal sette på slutten.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted kommer til å sette inn i den sorterte posisjon i listen.

675
00:51:53,000 --> 00:52:01,000
Insert_sorted slags forutsetter at du aldri har brukt foranstilte eller legge på dårlige veier.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted når du implementere insert_sorted-

677
00:52:09,000 --> 00:52:13,000
la oss si at vi har vår lenket liste.

678
00:52:13,000 --> 00:52:18,000
Dette er hva det øyeblikket ser ut, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
Jeg ønsker å sette 3, så så lenge selve lista allerede sortert,

680
00:52:24,000 --> 00:52:27,000
det er lett å finne hvor tre hører hjemme.

681
00:52:27,000 --> 00:52:29,000
Jeg starter på 2.

682
00:52:29,000 --> 00:52:32,000
Ok, er 3 større enn 2, så jeg ønsker å holde det gående.

683
00:52:32,000 --> 00:52:35,000
Oh, er 4 for stor, så jeg vet 3 kommer til å gå i mellom 2 og 4,

684
00:52:35,000 --> 00:52:39,000
og jeg må fikse pekere og alt det der.

685
00:52:39,000 --> 00:52:43,000
Men hvis vi ikke strengt bruke insert_sorted,

686
00:52:43,000 --> 00:52:50,000
liker la oss bare si at jeg foranstille 6,

687
00:52:50,000 --> 00:52:55,000
da min lenket liste kommer til å bli det.

688
00:52:55,000 --> 00:53:01,000
Det gjør nå ingen mening, så for insert_sorted, kan du bare anta

689
00:53:01,000 --> 00:53:04,000
at listen er sortert, selv om virksomheten består

690
00:53:04,000 --> 00:53:09,000
som kan føre til at det ikke skal sorteres, og det er det.

691
00:53:09,000 --> 00:53:20,000
Finn en nyttig innsats-så de er de viktigste tingene du nødt til å gjennomføre.

692
00:53:20,000 --> 00:53:24,000
>> For nå, ta et minutt å gjøre lengde og inneholder,

693
00:53:24,000 --> 00:53:30,000
og de bør være relativt rask.

694
00:53:41,000 --> 00:53:48,000
Nærmer stengetid, slik at alle har noe for lengde eller inneholder?

695
00:53:48,000 --> 00:53:50,000
De kommer til å være nesten identiske.

696
00:53:50,000 --> 00:53:57,000
[Student] Lengde.

697
00:53:57,000 --> 00:54:01,000
La oss se, revisjon.

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

699
00:54:12,000 --> 00:54:15,000
Du ønsker å forklare?

700
00:54:15,000 --> 00:54:21,000
[Student] jeg bare lage en peker node og initialisere den til først, som er vår globale variable,

701
00:54:21,000 --> 00:54:27,000
og da jeg sjekke for å se om det er null, så jeg ikke får en SEG feil og returnere 0 hvis det er tilfelle.

702
00:54:27,000 --> 00:54:34,000
Ellers har jeg sløyfe, holde styr på i heltall

703
00:54:34,000 --> 00:54:38,000
hvor mange ganger jeg har hentet det neste elementet i listen

704
00:54:38,000 --> 00:54:43,000
og i samme trinn operasjonen også videre at selve elementet,

705
00:54:43,000 --> 00:54:47,000
og da jeg kontinuerlig gjøre sjekk for å se om det er null,

706
00:54:47,000 --> 00:54:56,000
og hvis det er null, så det avbryter og bare returnerer antall elementer jeg har tilgang til.

707
00:54:56,000 --> 00:55:01,000
>> [Rob B.] Har noen noen kommentarer til noe?

708
00:55:01,000 --> 00:55:06,000
Dette ser bra korrekthet klok.

709
00:55:06,000 --> 00:55:10,000
[Student] Jeg tror ikke du trenger noden == null.

710
00:55:10,000 --> 00:55:13,000
Ja, så hvis node == null return 0.

711
00:55:13,000 --> 00:55:18,000
Men hvis node == null deretter dette-oh, det er en riktigheten problem.

712
00:55:18,000 --> 00:55:23,000
Det var bare du returnerer jeg, men det er ikke i omfang akkurat nå.

713
00:55:23,000 --> 00:55:30,000
Du trenger bare int i, så jeg = 0.

714
00:55:30,000 --> 00:55:34,000
Men hvis node er null, så jeg er fortsatt kommer til å være 0,

715
00:55:34,000 --> 00:55:39,000
og vi kommer til å returnere 0, så denne saken er identiske.

716
00:55:39,000 --> 00:55:48,000
En annen vanlig ting er å holde erklæringen

717
00:55:48,000 --> 00:55:51,000
av node innsiden av for løkke.

718
00:55:51,000 --> 00:55:54,000
Du kan si-oh, nei.

719
00:55:54,000 --> 00:55:56,000
La oss holde det som dette.

720
00:55:56,000 --> 00:55:59,000
Jeg ville trolig sette int i = 0 her,

721
00:55:59,000 --> 00:56:05,000
deretter node * node = første her.

722
00:56:05,000 --> 00:56:11,000
Og dette er trolig hvordan-bli kvitt dette nå.

723
00:56:11,000 --> 00:56:14,000
Dette er trolig hvordan jeg ville ha skrevet det.

724
00:56:14,000 --> 00:56:21,000
Du kan også utseende på det som dette.

725
00:56:21,000 --> 00:56:25,000
Dette for loop struktur her

726
00:56:25,000 --> 00:56:30,000
bør være nesten like naturlig for deg som for int i = 0

727
00:56:30,000 --> 00:56:33,000
i er mindre enn lengden av array i + +.

728
00:56:33,000 --> 00:56:38,000
Hvis det er slik du iterere over en matrise, er dette hvordan du iterere over en lenket liste.

729
00:56:38,000 --> 00:56:45,000
>> Dette bør være andre natur på enkelte punkt.

730
00:56:45,000 --> 00:56:50,000
Med det i tankene, dette kommer til å være nesten det samme.

731
00:56:50,000 --> 00:56:57,000
Du kommer til å ønske å iterere over en lenket liste.

732
00:56:57,000 --> 00:57:02,000
Hvis node-Jeg har ingen anelse om hva verdien kalles.

733
00:57:02,000 --> 00:57:04,000
Node jeg.

734
00:57:04,000 --> 00:57:15,000
Hvis verdien på det node = jeg kommer tilbake sant, og det er det.

735
00:57:15,000 --> 00:57:18,000
Legg merke til at den eneste måten vi noen gang tilbake false

736
00:57:18,000 --> 00:57:23,000
er hvis vi iterere over hele lenket liste og aldri returnere true,

737
00:57:23,000 --> 00:57:29,000
så det er hva dette betyr.

738
00:57:29,000 --> 00:57:36,000
Som en side notat-vi sannsynligvis ikke vil komme til å legge til eller foranstille.

739
00:57:36,000 --> 00:57:39,000
>> Rask siste notat.

740
00:57:39,000 --> 00:57:52,000
Hvis du ser den statiske nøkkelordet, så la oss si static int count = 0,

741
00:57:52,000 --> 00:57:56,000
så vi teller + +, kan du i utgangspunktet tenker på det som en global variabel,

742
00:57:56,000 --> 00:58:00,000
selv om jeg sa dette er ikke hvordan vi skal gjennomføre lengde.

743
00:58:00,000 --> 00:58:06,000
Jeg gjør dette her, og så telle + +.

744
00:58:06,000 --> 00:58:11,000
Noen måte vi kan skrive en node i vår lenket liste vi inkrementering vår teller.

745
00:58:11,000 --> 00:58:15,000
Poenget med dette er hva den statiske nøkkelordet betyr.

746
00:58:15,000 --> 00:58:20,000
Hvis jeg bare hadde int count = 0 som ville være en vanlig gammel global variabel.

747
00:58:20,000 --> 00:58:25,000
Hva static int count betyr at det er en global variabel for denne filen.

748
00:58:25,000 --> 00:58:28,000
Det er umulig for en annen fil,

749
00:58:28,000 --> 00:58:34,000
liker tenke på pset 5, hvis du har startet.

750
00:58:34,000 --> 00:58:39,000
Du har både speller.c, og du har dictionary.c,

751
00:58:39,000 --> 00:58:42,000
og hvis du bare erklære en ting global, så noe i speller.c

752
00:58:42,000 --> 00:58:45,000
kan nås i dictionary.c og vice versa.

753
00:58:45,000 --> 00:58:48,000
Globale variabler er tilgjengelig for alle. C-fil,

754
00:58:48,000 --> 00:58:54,000
men statiske variabler er bare tilgjengelig fra selve filen,

755
00:58:54,000 --> 00:59:01,000
så innsiden av stavekontroll eller innsiden av dictionary.c,

756
00:59:01,000 --> 00:59:06,000
dette er slags hvordan jeg ville erklære min variabel for størrelsen på matrisen min

757
00:59:06,000 --> 00:59:10,000
eller størrelsen på min antall ord i ordboken.

758
00:59:10,000 --> 00:59:15,000
Siden jeg ikke ønsker å erklære en global variabel som alle har tilgang til,

759
00:59:15,000 --> 00:59:18,000
Jeg bare bryr seg om det for min egne formål.

760
00:59:18,000 --> 00:59:21,000
>> Den gode ting om dette er også hele navnet kollisjon ting.

761
00:59:21,000 --> 00:59:27,000
Hvis noen andre filen prøver å bruke en global variabel kalt teller, ting går veldig, veldig galt,

762
00:59:27,000 --> 00:59:33,000
så dette holder pent ting sikkert, og bare du kan få tilgang til den,

763
00:59:33,000 --> 00:59:38,000
og ingen andre kan, og hvis noen andre erklærer en global variabel kalt teller,

764
00:59:38,000 --> 00:59:43,000
da det ikke vil forstyrre din statisk variabel kalt teller.

765
00:59:43,000 --> 00:59:47,000
Det er det statiske er. Det er en fil global variabel.

766
00:59:47,000 --> 00:59:52,000
>> Spørsmål om noe?

767
00:59:52,000 --> 00:59:59,000
Alle sett. Bye.

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