1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [§ 3] [mindre komfortable]

2
00:00:03,000 --> 00:00:05,000
>> [Nate Hardison] [Harvard University]

3
00:00:05,000 --> 00:00:08,000
>> [Dette er CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Greit, la oss komme i gang.

5
00:00:10,000 --> 00:00:13,000
Velkommen til uke 4 i CS50.

6
00:00:13,000 --> 00:00:19,000
Hvis dere åpner opp en nettleser og åpne opp pset 3,

7
00:00:19,000 --> 00:00:23,000
Rykke ut med CS50, vi kommer til å begynne å gå

8
00:00:23,000 --> 00:00:26,000
gjennom den delen av spørsmålene der.

9
00:00:26,000 --> 00:00:32,000
Akkurat som forrige uke, vil vi arbeide i CS50 Spaces,

10
00:00:32,000 --> 00:00:35,000
hvis du vil også trekke det opp så godt,

11
00:00:35,000 --> 00:00:43,000
og hvis du går videre og gå til denne linken som jeg har fått her oppe på toppen.

12
00:00:43,000 --> 00:00:45,000
Det er på tide å komme i gang.

13
00:00:45,000 --> 00:00:51,000
Vi har fått vår lille hi programmet her. Ingenting gale.

14
00:00:51,000 --> 00:00:55,000
En av de første tingene jeg ønsker å gjøre med dere i dag er å gå over noen løsninger

15
00:00:55,000 --> 00:00:58,000
til Problem Set 1, type eksempel løsninger,

16
00:00:58,000 --> 00:01:03,000
bare så du kan få en følelse for hva slags kode ansatte skriver,

17
00:01:03,000 --> 00:01:07,000
hva slags kode andre studenter skriver,

18
00:01:07,000 --> 00:01:10,000
og må ta deg en titt på det fordi jeg vet det er rart

19
00:01:10,000 --> 00:01:14,000
når du sender en løsning på et problem sett og få kommentarer

20
00:01:14,000 --> 00:01:18,000
på din egen versjon, men noen ganger er det nyttig å se hvordan andre mennesker gjorde det,

21
00:01:18,000 --> 00:01:22,000
særlig de som er hyggelig ser.

22
00:01:22,000 --> 00:01:27,000
For det meste, ble jeg virkelig imponert over løsningene som dere produsert.

23
00:01:27,000 --> 00:01:31,000
Jeg har ennå ikke begynt å se på problemet ditt Set 2s, men hvis de er noe som den første,

24
00:01:31,000 --> 00:01:34,000
det betyr ingenting, men gode ting.

25
00:01:34,000 --> 00:01:40,000
>> Hvis du ser på mine revisjoner, la oss starte helt nede på Revisjon 1,

26
00:01:40,000 --> 00:01:47,000
og vi kommer til å ta en rask titt på en Mario løsning.

27
00:01:47,000 --> 00:01:54,000
Hvis du trekker dette opp, disse programmene som vi skal presentere er riktige.

28
00:01:54,000 --> 00:01:56,000
Det var ikke korrekthet problemer med disse problemene, men snarere

29
00:01:56,000 --> 00:01:59,000
Vi ønsker å snakke litt om de forskjellige utforming

30
00:01:59,000 --> 00:02:03,000
som ble brukt her.

31
00:02:03,000 --> 00:02:08,000
En av de tingene som var interessant om løsningen

32
00:02:08,000 --> 00:02:11,000
er at det brukes denne nye konstruksjon kalt pund definere,

33
00:02:11,000 --> 00:02:15,000
noen ganger også referert til som en hash definere.

34
00:02:15,000 --> 00:02:18,000
La meg zoome inn på det her.

35
00:02:18,000 --> 00:02:24,000
En # define kan du gi navn til disse tallene i programmet.

36
00:02:24,000 --> 00:02:28,000
I dette tilfellet, den maksimale høyde av en pyramide i Mario

37
00:02:28,000 --> 00:02:34,000
ble 23 og heller enn å sette 23 i min kode-

38
00:02:34,000 --> 00:02:37,000
Vi vil referere til det som vanskelig koding 23 -

39
00:02:37,000 --> 00:02:43,000
stedet gir dette navnet MAX_HEIGHT til det nummeret,

40
00:02:43,000 --> 00:02:48,000
slik at her nede i min do-mens loop

41
00:02:48,000 --> 00:02:51,000
du kan faktisk se MAX_HEIGHT

42
00:02:51,000 --> 00:02:55,000
stedet for å sette nummer 23 i.

43
00:02:55,000 --> 00:02:57,000
[Student] Hva er fordelen med å gjøre det?

44
00:02:57,000 --> 00:02:59,000
Det er et stort spørsmål.

45
00:02:59,000 --> 00:03:03,000
En er lesbarheten.

46
00:03:03,000 --> 00:03:08,000
En fordel med å bruke dette # define er lesbarheten.

47
00:03:08,000 --> 00:03:11,000
Når jeg leser denne koden, kan jeg se hva som skjer.

48
00:03:11,000 --> 00:03:15,000
>> Jeg kan se i denne tilstanden her som vi tester

49
00:03:15,000 --> 00:03:19,000
for høyden blir <0, som vi kunne ha også definert

50
00:03:19,000 --> 00:03:22,000
å være en minimumshøyde eller min høyde.

51
00:03:22,000 --> 00:03:25,000
Den andre fordelen er at jeg kan da lese resten av linjen for å se

52
00:03:25,000 --> 00:03:30,000
at vi også sjekke for å være sikker på at høyden ikke er større enn maks høyde,

53
00:03:30,000 --> 00:03:35,000
fordi vi kommer til å fortsette mens høyden er større enn maks høyde.

54
00:03:35,000 --> 00:03:40,000
Den andre fordelen er-hvis jeg zoome ut litt her-

55
00:03:40,000 --> 00:03:49,000
hvis jeg kjører dette programmet og kjører jeg det, si, med 23 akkurat nå,

56
00:03:49,000 --> 00:03:52,000
det vil skrive ut alle 23 p bare sånn.

57
00:03:52,000 --> 00:03:54,000
Men si jeg ønsket å endre maks høyde,

58
00:03:54,000 --> 00:03:57,000
og nå vil jeg begrense den maksimale høyden pyramidene

59
00:03:57,000 --> 00:04:06,000
å være bare si-mann, som var funky.

60
00:04:06,000 --> 00:04:14,000
# Include <stdio.h>, # define MAX_HEIGHT,

61
00:04:14,000 --> 00:04:18,000
og la oss si at vi ønsket å sette den lik 10.

62
00:04:18,000 --> 00:04:22,000
Nå på dette punktet, var alt jeg hadde å gjøre endre den i dette ett sted.

63
00:04:22,000 --> 00:04:27,000
Jeg kan rekompilere koden, og nå hvis jeg prøver og skrive 12,

64
00:04:27,000 --> 00:04:30,000
det vil be meg igjen.

65
00:04:30,000 --> 00:04:33,000
I dette tilfellet er vi bare bruker MAX_HEIGHT gang.

66
00:04:33,000 --> 00:04:37,000
Det er ikke så stor av en hassle å gå i

67
00:04:37,000 --> 00:04:40,000
og endre den i mens loop hvis du må.

68
00:04:40,000 --> 00:04:44,000
Men i programmer der du refererer samme magiske tallet

69
00:04:44,000 --> 00:04:47,000
om og om igjen, denne # define mekanismen er veldig praktisk

70
00:04:47,000 --> 00:04:52,000
fordi du bare endre det en gang på toppen av filen-det er typisk der du setter dem-

71
00:04:52,000 --> 00:04:57,000
og endringen siler gjennom resten av filen.

72
00:04:57,000 --> 00:05:02,000
>> Andre ting jeg ønsket å merke seg i denne oppgaven som jeg trodde så veldig fin,

73
00:05:02,000 --> 00:05:05,000
var navngiving av variablene.

74
00:05:05,000 --> 00:05:14,000
Du ser her at vi har fått heltall variabler kalles rad og såkalte høyde.

75
00:05:14,000 --> 00:05:20,000
Mellomrom, hasher, hjelper det gjøre koden litt mer lesbar,

76
00:05:20,000 --> 00:05:25,000
gjør det litt mer forståelig hva som faktisk skjer.

77
00:05:25,000 --> 00:05:31,000
Dette er i motsetning til ved hjelp, si, tilfeldige bokstaver

78
00:05:31,000 --> 00:05:35,000
eller bare gobbledygook helt.

79
00:05:35,000 --> 00:05:39,000
En siste ting jeg vil påpeke er at i for looper,

80
00:05:39,000 --> 00:05:45,000
ofte disse iterator variabler, disse tellere som du bruker i din for looper,

81
00:05:45,000 --> 00:05:51,000
det er standard og konvensjonelle å starte dem med enten i og deretter j og deretter k

82
00:05:51,000 --> 00:05:54,000
og går videre derfra hvis du trenger flere variabler,

83
00:05:54,000 --> 00:05:56,000
og dette er bare en konvensjon.

84
00:05:56,000 --> 00:05:58,000
Det er mange konvensjoner.

85
00:05:58,000 --> 00:06:00,000
Det avhenger av programmeringsspråk du bruker.

86
00:06:00,000 --> 00:06:04,000
Men i C, vi vanligvis begynne med jeg.

87
00:06:04,000 --> 00:06:08,000
Det gjør ikke fornuftig å bruke, sier a eller b

88
00:06:08,000 --> 00:06:13,000
avhengig av situasjonen.

89
00:06:13,000 --> 00:06:15,000
Det er det for denne.

90
00:06:15,000 --> 00:06:25,000
Hvis du nå trekker opp Revisjon 2, vil du se en annen Mario,

91
00:06:25,000 --> 00:06:29,000
og dette er lik den andre en som vi nettopp så,

92
00:06:29,000 --> 00:06:32,000
men det gjør noe slags cool.

93
00:06:32,000 --> 00:06:38,000
Hvis vi ser på denne delen her inne i indre for loop,

94
00:06:38,000 --> 00:06:44,000
de bruker noen sprø jakt syntaks her rett i denne linjen.

95
00:06:44,000 --> 00:06:47,000
Dette kalles en trefoldig operatøren.

96
00:06:47,000 --> 00:06:53,000
Det er en hvis andre setningen kondenseres til en linje.

97
00:06:53,000 --> 00:06:57,000
Tilstanden er denne delen i parentes.

98
00:06:57,000 --> 00:07:05,000
Det er samme som å si hvis j <høyde - i - 1.

99
00:07:05,000 --> 00:07:10,000
Og hva innholdet i den hvis blokken ville være er plass

100
00:07:10,000 --> 00:07:16,000
og deretter innholdet av hva den ellers ville være er denne #.

101
00:07:16,000 --> 00:07:20,000
Det er i hovedsak tildele en plass til denne variabelen.

102
00:07:20,000 --> 00:07:24,000
Det å sette en plass i innholdet i blokken variabel,

103
00:07:24,000 --> 00:07:29,000
hvis denne betingelsen er oppfylt, og hvis tilstanden ikke er oppfylt,

104
00:07:29,000 --> 00:07:32,000
da blokken variable får denne #.

105
00:07:32,000 --> 00:07:37,000
Og så, selvfølgelig, i stedet for å bygge opp en hel streng

106
00:07:37,000 --> 00:07:43,000
og skrive alt ut på slutten denne løsningen skrives det ut ett tegn om gangen.

107
00:07:43,000 --> 00:07:48,000
Ganske kult.

108
00:07:48,000 --> 00:07:53,000
>> Et annet par ting å se på. Vi vil gå videre til grådige.

109
00:07:53,000 --> 00:07:58,000
Hvis vi nå ser på grådige, denne første løsningen

110
00:07:58,000 --> 00:08:00,000
bruker disse # definerer ganske mye.

111
00:08:00,000 --> 00:08:06,000
Vi har fått en konstant definert for hver av de ulike tallene i dette programmet.

112
00:08:06,000 --> 00:08:12,000
Vi har fått en for cent per dollar, en for kvartalene, dimes, nickels, og penninger,

113
00:08:12,000 --> 00:08:15,000
og nå hvis vi bla ned og lese koden,

114
00:08:15,000 --> 00:08:22,000
Vi kan se en standard gjør-mens loop utskrift alt ut.

115
00:08:22,000 --> 00:08:25,000
Slags crux av dette problemet ble innser at

116
00:08:25,000 --> 00:08:29,000
du trengte å konvertere flottøren som du leser i fra brukeren til et heltall

117
00:08:29,000 --> 00:08:32,000
nøyaktig gjøre regnestykket, og dette er fordi

118
00:08:32,000 --> 00:08:36,000
med flyttall, som vi snakket om i foredraget kort,

119
00:08:36,000 --> 00:08:41,000
det er ikke mulig å nøyaktig representere hver enkelt verdi på tallinja

120
00:08:41,000 --> 00:08:47,000
fordi det er uendelig mange verdier mellom 3 og si, 3,1 enda.

121
00:08:47,000 --> 00:08:54,000
Du kan ha 3.01 og 3.001 og 3.0001, og du kan holde det gående.

122
00:08:54,000 --> 00:09:00,000
Det viser seg når du arbeider med penger, du ofte vil konvertere den

123
00:09:00,000 --> 00:09:05,000
inn heltall format, slik at du ikke mister pennies og den slags ting.

124
00:09:05,000 --> 00:09:09,000
Gjør det og avrunding var nøkkelen.

125
00:09:09,000 --> 00:09:14,000
Denne løsningen brukes en perfekt grei, stor algoritme,

126
00:09:14,000 --> 00:09:17,000
som dekrementeres antall cent igjen, først av kvartalene,

127
00:09:17,000 --> 00:09:19,000
deretter ved dimes, deretter ved nickels, så av pennies,

128
00:09:19,000 --> 00:09:24,000
og legge til antall mynter hver gang.

129
00:09:24,000 --> 00:09:31,000
>> En annen løsning som vi vil se, som jeg zoome ut og gå til Revisjon 4,

130
00:09:31,000 --> 00:09:40,000
hadde en veldig lignende begynnelsen, men i stedet brukt div og mod

131
00:09:40,000 --> 00:09:44,000
rett over her for å beregne antall cent.

132
00:09:44,000 --> 00:09:50,000
Dette, er det antall kvartal lik antall cent dividert 25,

133
00:09:50,000 --> 00:09:53,000
og grunnen til dette fungerer er fordi vi gjør heltallsdivisjon,

134
00:09:53,000 --> 00:09:58,000
så det er forkaster enhver rest.

135
00:09:58,000 --> 00:10:02,000
[Student] Har vi å kommentere søket?

136
00:10:02,000 --> 00:10:05,000
Det avhenger egentlig.

137
00:10:05,000 --> 00:10:08,000
[Student] Du kommenterer mer enn kode her.

138
00:10:08,000 --> 00:10:16,000
Ja, og så er det en haug med varierende filosofier på dette.

139
00:10:16,000 --> 00:10:21,000
Min personlige filosofi er at koden er virkelig sannheten,

140
00:10:21,000 --> 00:10:24,000
som koden din er hva som faktisk er oppfylt på datamaskinen,

141
00:10:24,000 --> 00:10:29,000
og slik at koden skal være så lesbar som mulig for å ikke kreve så mange kommentarer.

142
00:10:29,000 --> 00:10:33,000
Når det er sagt, når du gjør ting som er slags vanskelig matematisk

143
00:10:33,000 --> 00:10:38,000
eller algoritmer, er det godt å kommentere de, slik at du kan

144
00:10:38,000 --> 00:10:43,000
legge til en ekstra dimensjon, et ekstra lag til den som leser koden din.

145
00:10:43,000 --> 00:10:49,000
I disse løsningene, ofte er de kommentert mer tungt bare fordi

146
00:10:49,000 --> 00:10:52,000
vi ønsker å være i stand til å distribuere dem, og har folk plukke dem opp

147
00:10:52,000 --> 00:10:56,000
og lese dem ganske enkelt.

148
00:10:56,000 --> 00:11:05,000
Men definitivt, jeg er enig at dette er tung.

149
00:11:05,000 --> 00:11:07,000
[Student] Men når du er i tvil, gå tyngre?

150
00:11:07,000 --> 00:11:10,000
Når du er i tvil, gå tyngre.

151
00:11:10,000 --> 00:11:17,000
Noen mennesker vil noen ganger si return 0 eller noe sånt.

152
00:11:17,000 --> 00:11:20,000
Jeg tror det er en latterlig kommentar.

153
00:11:20,000 --> 00:11:22,000
Klart det er det som skjer.

154
00:11:22,000 --> 00:11:25,000
Jeg trenger ikke engelsk for å fortelle meg det.

155
00:11:25,000 --> 00:11:28,000
Noen ganger vil folk skrive ting som "kthxbai!"

156
00:11:28,000 --> 00:11:32,000
Det er slags søt, men også ikke-

157
00:11:32,000 --> 00:11:35,000
som ikke gjør forskjell mellom kommentering poeng eller ikke.

158
00:11:35,000 --> 00:11:41,000
Slike kommentarer er bare ha, ha.

159
00:11:41,000 --> 00:11:43,000
Cool.

160
00:11:43,000 --> 00:11:48,000
>> På dette punktet, la oss begynne å jobbe på oppgavesettet § 3 spørsmål.

161
00:11:48,000 --> 00:11:52,000
Hvis dere trekke dette opp igjen,

162
00:11:52,000 --> 00:11:55,000
som med forrige uke, vi kommer ikke til å se shorts i denne delen.

163
00:11:55,000 --> 00:12:00,000
Vi skal la dere gjøre det på din egen tid og snakke om spørsmålene.

164
00:12:00,000 --> 00:12:05,000
Men nå i denne delen skal vi bruke litt mer tid

165
00:12:05,000 --> 00:12:11,000
snakker om mindre av koding grunnleggende

166
00:12:11,000 --> 00:12:15,000
som vi gjorde i forrige uke, og i stedet, vi kommer til å fokusere mer på

167
00:12:15,000 --> 00:12:22,000
litt mer av teorien, så snakker om binære søk og deretter sortere.

168
00:12:22,000 --> 00:12:27,000
Fra de av dere som har fulgt med forelesningen,

169
00:12:27,000 --> 00:12:30,000
kan noen gi meg en oppsummering av hva forskjellen er

170
00:12:30,000 --> 00:12:35,000
mellom binære søk og lineær søk?

171
00:12:35,000 --> 00:12:37,000
Hva skjer? Sure.

172
00:12:37,000 --> 00:12:42,000
Lineære søker blant alle element i den sorterte listen

173
00:12:42,000 --> 00:12:45,000
en etter en etter en etter en etter en,

174
00:12:45,000 --> 00:12:50,000
og binære søk deler listen i to grupper,

175
00:12:50,000 --> 00:12:57,000
Sjekker om tastene verdi som du søker etter er større eller mindre enn midtpunktet verdi

176
00:12:57,000 --> 00:13:00,000
at du nettopp har funnet, og hvis det er mindre enn, går det med den nederste listen

177
00:13:00,000 --> 00:13:03,000
og deretter deler det igjen, gjør det samme funksjon

178
00:13:03,000 --> 00:13:07,000
helt ned til den finner midtpunktet til å være lik selve verdien.

179
00:13:07,000 --> 00:13:10,000
Høyre.

180
00:13:10,000 --> 00:13:12,000
>> Hvorfor bryr vi oss?

181
00:13:12,000 --> 00:13:20,000
Hvorfor snakker vi om binære søk versus lineær søk?

182
00:13:20,000 --> 00:13:22,000
Ja.

183
00:13:22,000 --> 00:13:24,000
Binary er mye raskere, så hvis du doble størrelsen på problemet

184
00:13:24,000 --> 00:13:27,000
det tar ett trinn i stedet for dobbelt så mange.

185
00:13:27,000 --> 00:13:29,000
Akkurat.

186
00:13:29,000 --> 00:13:31,000
Det er et godt svar.

187
00:13:31,000 --> 00:13:36,000
Lineær søk er veldig mye sjekker ett element om gangen,

188
00:13:36,000 --> 00:13:39,000
og som vi så på den aller første dagen av foredrag

189
00:13:39,000 --> 00:13:42,000
da David gikk gjennom hans telefonboken eksempel

190
00:13:42,000 --> 00:13:45,000
og dratt ut én side av telefonen bok om gangen

191
00:13:45,000 --> 00:13:47,000
og holdt gjør at over og over og over igjen,

192
00:13:47,000 --> 00:13:51,000
det kommer til å ta ham veldig lang tid å finne noen i telefonboken,

193
00:13:51,000 --> 00:13:55,000
med mindre, selvfølgelig, ble han leter etter noen helt i begynnelsen av alfabetet.

194
00:13:55,000 --> 00:14:00,000
Med binær søk, kan du gå mye raskere,

195
00:14:00,000 --> 00:14:05,000
og det er ikke bare dobbelt så rask eller tre ganger så rask eller 4 ganger så fort.

196
00:14:05,000 --> 00:14:13,000
Men problemet blir mindre og mindre og mindre mye raskere.

197
00:14:13,000 --> 00:14:17,000
For å illustrere dette, vil vi begynne å snakke om hva som skjer

198
00:14:17,000 --> 00:14:21,000
når vi skriver binære søk.

199
00:14:21,000 --> 00:14:27,000
Problemet på hånden er at hvis jeg har en rekke tall,

200
00:14:27,000 --> 00:14:40,000
si, 1, 2, 3, 5, 7, 23, 45, 78, 12323,

201
00:14:40,000 --> 00:14:47,000
og deretter 9 med et tonn 0s etter det,

202
00:14:47,000 --> 00:14:52,000
vi ønsker å være i stand til å finne ut veldig raskt hva som er i

203
00:14:52,000 --> 00:14:57,000
Denne rekken av tall.

204
00:14:57,000 --> 00:15:00,000
Jeg vet dette virker litt dumt og litt contrived,

205
00:15:00,000 --> 00:15:02,000
fordi akkurat nå er det.

206
00:15:02,000 --> 00:15:05,000
Vi har en matrise som ikke har veldig mange elementer i den,

207
00:15:05,000 --> 00:15:08,000
og hvis jeg spør en av dere til å finne ut hvorvidt

208
00:15:08,000 --> 00:15:11,000
23 er i matrisen, kan du gjøre det ganske raskt

209
00:15:11,000 --> 00:15:16,000
bare ved skotter på dette og fortelle meg ja eller nei.

210
00:15:16,000 --> 00:15:20,000
Den analoge å vurdere er tenk om dette var, sier

211
00:15:20,000 --> 00:15:27,000
et Excel-regneark med 10.000 rader, 20.000 rader.

212
00:15:27,000 --> 00:15:31,000
Selvfølgelig kan du gjøre kommandoen F eller kontroll F og se noe opp.

213
00:15:31,000 --> 00:15:33,000
Du kan også bruke filtre og søk ting,

214
00:15:33,000 --> 00:15:37,000
men hvis du måtte se gjennom denne filen linje for linje for linje,

215
00:15:37,000 --> 00:15:40,000
det vil ta deg lang tid å finne den.

216
00:15:40,000 --> 00:15:42,000
Det er typen som i telefonboken eksempel, også der

217
00:15:42,000 --> 00:15:44,000
ingen ser gjennom en telefonbok én side om gangen.

218
00:15:44,000 --> 00:15:47,000
Vanligvis, åpner de den til midten,

219
00:15:47,000 --> 00:15:50,000
eller i tilfelle av en rekke telefon bøker og ordbøker hvor

220
00:15:50,000 --> 00:15:54,000
du faktisk har det tastet på den første bokstaven,

221
00:15:54,000 --> 00:16:01,000
du slå til det første brevet og åpne og begynne å gå gjennom det.

222
00:16:01,000 --> 00:16:03,000
>> Minner meg om navnet ditt igjen. >> Sam.

223
00:16:03,000 --> 00:16:05,000
Sam.

224
00:16:05,000 --> 00:16:11,000
Som Sam sa, er at lineær søkeprosessen kommer til å bli veldig treg,

225
00:16:11,000 --> 00:16:15,000
og i stedet med binære søk, er måten dette fungerer som

226
00:16:15,000 --> 00:16:21,000
hver gang vi går gjennom en gjentakelse av vår søke algoritme,

227
00:16:21,000 --> 00:16:27,000
vi kommer til å dele listen i to, i hovedsak,

228
00:16:27,000 --> 00:16:33,000
i to mindre lister.

229
00:16:33,000 --> 00:16:39,000
Og så på neste iterasjon av loopen, vil vi dele det på nytt

230
00:16:39,000 --> 00:16:44,000
i andre mindre lister.

231
00:16:44,000 --> 00:16:48,000
Som du kan se, holder problemet blir mindre og mindre

232
00:16:48,000 --> 00:16:55,000
fordi vi holder kaste halvparten av listen hver eneste gang.

233
00:16:55,000 --> 00:16:59,000
Hvordan fungerer dette forkast arbeid?

234
00:16:59,000 --> 00:17:05,000
Akkurat som en påminnelse, hva vi skal gjøre hvis vi var en datamaskin

235
00:17:05,000 --> 00:17:11,000
og vi var, sier, søker etter nummer 5 i denne listen

236
00:17:11,000 --> 00:17:15,000
er at vi vil plukke et tall i midten.

237
00:17:15,000 --> 00:17:26,000
I midten av denne listen, fordi det er en, to, tre, fire, fem, seks, syv, åtte, ni, 10 tall,

238
00:17:26,000 --> 00:17:32,000
vi vil velge nummeret enten på 4. plass eller på 5th posisjon,

239
00:17:32,000 --> 00:17:38,000
og vi vil kalle det midt på vår liste.

240
00:17:38,000 --> 00:17:42,000
Plukk nummer i midten.

241
00:17:42,000 --> 00:17:51,000
Deretter, akkurat som Sam sagt, vil vi teste for å se om det nummeret er lik

242
00:17:51,000 --> 00:17:59,000
til nummeret som vi ønsker å få eller våre ønsket nummer.

243
00:17:59,000 --> 00:18:06,000
Hvis det er lik, så vi har funnet det. Vi vinner.

244
00:18:06,000 --> 00:18:12,000
Hvis det ikke er like, så er det et par tilfeller.

245
00:18:12,000 --> 00:18:15,000
De to tilfellene er enten antallet må være større enn antallet vi ser på,

246
00:18:15,000 --> 00:18:19,000
eller det er mindre enn.

247
00:18:19,000 --> 00:18:25,000
Hvis den er større, flytter vi til høyre.

248
00:18:25,000 --> 00:18:33,000
Og hvis det er mindre, beveger vi oss til venstre.

249
00:18:33,000 --> 00:18:41,000
Og da vi gjenta hele prosessen på nytt

250
00:18:41,000 --> 00:18:48,000
på høyre halvdel eller venstre halvdel av listen.

251
00:18:48,000 --> 00:18:51,000
>> Det første problemet i dagens delen er å finne ut

252
00:18:51,000 --> 00:18:55,000
hvordan vi kan faktisk begynne å uttrykke dette i C-kode.

253
00:18:55,000 --> 00:18:58,000
Vi har fått pseudokode her.

254
00:18:58,000 --> 00:19:04,000
Hva vi vil begynne å gjøre er jeg trekke opp en splitter ny plass,

255
00:19:04,000 --> 00:19:09,000
lagre denne revisjonen, slik at vi har disse notatene for senere,

256
00:19:09,000 --> 00:19:20,000
vi vil slette alt dette, og deretter kopiere og lime inn fra oppgavesettet

257
00:19:20,000 --> 00:19:26,000
denne informasjonen i våre områder, og forhåpentligvis dette ikke bryte.

258
00:19:26,000 --> 00:19:28,000
Perfekt.

259
00:19:28,000 --> 00:19:33,000
Hvis dere alle gjør det, kopiere og lime inn denne koden på ny plass,

260
00:19:33,000 --> 00:19:43,000
inn et blankt.

261
00:19:43,000 --> 00:19:47,000
La oss prøve Daniel. Hvis du kompilere og kjøre dette programmet, virker det?

262
00:19:47,000 --> 00:19:49,000
Nei >> Hva er det å si?

263
00:19:49,000 --> 00:19:53,000
Det sier kontrollen når slutten av ikke-void funksjon.

264
00:19:53,000 --> 00:19:55,000
Ja, så la meg prøve å kjøre den.

265
00:19:55,000 --> 00:19:59,000
Har dere sett dette før? Vet du hva dette betyr?

266
00:19:59,000 --> 00:20:01,000
Ok, la oss dissekere dette litt.

267
00:20:01,000 --> 00:20:10,000
Det sier at file.c på linje 9, kolonne 1 har vi en feil, akkurat som du sa,

268
00:20:10,000 --> 00:20:16,000
og det står at det er stammer fra advarsel om feil og returtypen advarsel.

269
00:20:16,000 --> 00:20:18,000
Det ser ut som noe som skjer med avkastningen type, som er fornuftig.

270
00:20:18,000 --> 00:20:21,000
Vi har et ikke-void funksjon, som betyr at vi har en funksjon

271
00:20:21,000 --> 00:20:24,000
som returnerer ikke ugyldig.

272
00:20:24,000 --> 00:20:27,000
En ugyldig funksjon er en som ser slik ut:

273
00:20:27,000 --> 00:20:35,000
void foo (), og det er ugyldig fordi returtypen er ugyldig,

274
00:20:35,000 --> 00:20:38,000
noe som betyr at hvis vi hadde noe her

275
00:20:38,000 --> 00:20:45,000
som avkastning 1, vil vi få en kompilator feil for dette.

276
00:20:45,000 --> 00:20:49,000
Vi har imidlertid en ikke-void funksjon.

277
00:20:49,000 --> 00:20:51,000
Våre ikke-void funksjon i dette tilfelle er vårt søkefunksjon

278
00:20:51,000 --> 00:20:56,000
fordi den har en avkastning type bool.

279
00:20:56,000 --> 00:20:59,000
Når det er å si at kontrollen når slutten av en ikke-void funksjon,

280
00:20:59,000 --> 00:21:02,000
det er fordi søket ikke har en avkastning uttalelse.

281
00:21:02,000 --> 00:21:04,000
Det er ikke returnerer noe av typen bool.

282
00:21:04,000 --> 00:21:09,000
>> Vi kan fikse det, og hva tror dere

283
00:21:09,000 --> 00:21:13,000
søk skal returneres som standard?

284
00:21:13,000 --> 00:21:16,000
Hva bør være standard returverdien søk?

285
00:21:16,000 --> 00:21:19,000
Fordi det er det vi kan sette på slutten.

286
00:21:19,000 --> 00:21:21,000
Charlotte, har du noen-?

287
00:21:21,000 --> 00:21:23,000
Sant eller usant? >> Sant eller usant.

288
00:21:23,000 --> 00:21:26,000
Hvilken?

289
00:21:26,000 --> 00:21:28,000
False. Jeg vet ikke.

290
00:21:28,000 --> 00:21:30,000
Falsk? La oss prøve det.

291
00:21:30,000 --> 00:21:32,000
Hvorfor sier du return false? Det er stor intuisjon.

292
00:21:32,000 --> 00:21:35,000
[Charlotte] Jeg vet ikke.

293
00:21:35,000 --> 00:21:39,000
Vi kommer til å returnere falsk i dette tilfellet, fordi dette vil være vår standard

294
00:21:39,000 --> 00:21:44,000
hvis noen grunn listen er tom eller nålen

295
00:21:44,000 --> 00:21:46,000
at vi leter etter finnes ikke.

296
00:21:46,000 --> 00:21:50,000
Så helt til slutt, hvis vi ikke return true tidligere i denne funksjonen,

297
00:21:50,000 --> 00:21:55,000
Vi vet alltid at denne funksjonen vil si nope, det er ikke i tabellen.

298
00:21:55,000 --> 00:21:58,000
Det er ikke i høystakken.

299
00:21:58,000 --> 00:22:03,000
Nå hvis vi kompilere og kjøre den, la meg lagre dette så vi kan dra det opp.

300
00:22:03,000 --> 00:22:08,000
Nå hvis vi kompilere og kjøre programmet vårt, bygger det.

301
00:22:08,000 --> 00:22:12,000
Vi får vår lille spørsmål.

302
00:22:12,000 --> 00:22:20,000
Hvis jeg treffer 4-uh-oh.

303
00:22:20,000 --> 00:22:25,000
Det gjorde ikke skrive ut noe. Det ser ut som alt endte bra.

304
00:22:25,000 --> 00:22:35,000
Vi er nødt til å fylle dette i.

305
00:22:35,000 --> 00:22:39,000
Vi snakket om algoritmen i pseudokode litt siden.

306
00:22:39,000 --> 00:22:44,000
La meg se, lagre dette,

307
00:22:44,000 --> 00:22:49,000
og jeg vil trekke det algoritmen opp igjen.

308
00:22:49,000 --> 00:22:51,000
La oss treffer denne fyren. Nope.

309
00:22:51,000 --> 00:22:58,000
Det er det.

310
00:22:58,000 --> 00:23:03,000
Hvordan gjør vi dette?

311
00:23:03,000 --> 00:23:11,000
Hva ville være en god strategi for å starte på denne koden?

312
00:23:11,000 --> 00:23:16,000
Du må velge et tall i midten.

313
00:23:16,000 --> 00:23:23,000
Hvordan plukke vi et nummer i midten av en matrise?

314
00:23:23,000 --> 00:23:25,000
Noen forslag?

315
00:23:25,000 --> 00:23:27,000
[Student] strlen delt på to.

316
00:23:27,000 --> 00:23:32,000
Strlen delt på to. Det er en stor en.

317
00:23:32,000 --> 00:23:35,000
Strlen arbeider med spesielle typer matriser.

318
00:23:35,000 --> 00:23:38,000
Hva slags arrays?

319
00:23:38,000 --> 00:23:44,000
String arrays, karakter matriser.

320
00:23:44,000 --> 00:23:48,000
Det er det samme slags konsept som vi vil bruke,

321
00:23:48,000 --> 00:23:52,000
men vi kan ikke bruke strlen fordi vi ikke har en rekke tegn.

322
00:23:52,000 --> 00:23:55,000
Vi har en rekke ints.

323
00:23:55,000 --> 00:23:58,000
Men hva får strlen for oss?

324
00:23:58,000 --> 00:24:01,000
Vet du hva det blir for oss?

325
00:24:01,000 --> 00:24:03,000
[Student] strlen får oss lengden.

326
00:24:03,000 --> 00:24:05,000
Akkurat, får det oss lengden.

327
00:24:05,000 --> 00:24:09,000
Strlen får lengden på matrisen for oss.

328
00:24:09,000 --> 00:24:14,000
>> Hvordan får vi det i vår binære søk programmet?

329
00:24:14,000 --> 00:24:18,000
Hvordan ville du få lengden av en matrise?

330
00:24:18,000 --> 00:24:20,000
[Student] strlen?

331
00:24:20,000 --> 00:24:25,000
Du kan få lengden på en riktig formatert C string array med strlen.

332
00:24:25,000 --> 00:24:31,000
Problemet er imidlertid at vi ikke har en streng array.

333
00:24:31,000 --> 00:24:36,000
Hvis vi ser tilbake på denne koden, har vi denne heltall array.

334
00:24:36,000 --> 00:24:38,000
Hvordan vet vi hvor lenge det er?

335
00:24:38,000 --> 00:24:44,000
[Student] Er det en tilsvarende en for endepunkt, som int l eller noe?

336
00:24:44,000 --> 00:24:49,000
Det viser seg at det faktisk ikke er det, og det på en måte, er dette

337
00:24:49,000 --> 00:24:52,000
en av de tingene det er bare godt å vite om C,

338
00:24:52,000 --> 00:24:57,000
at det er ingen måte å få lengden av en matrise

339
00:24:57,000 --> 00:24:59,000
hvis alt jeg gir deg er tabellen.

340
00:24:59,000 --> 00:25:02,000
Grunnen til at det fungerer med strenger, grunnen strlen verk,

341
00:25:02,000 --> 00:25:06,000
er fordi hvis en streng er riktig formatert,

342
00:25:06,000 --> 00:25:12,000
det vil ha den spesielle \ 0 tegn på slutten.

343
00:25:12,000 --> 00:25:16,000
>> Du kan også forestille seg hvis du har en feil formatert streng

344
00:25:16,000 --> 00:25:20,000
og det er ingen \ 0 tegn der, så hele greia virker ikke.

345
00:25:20,000 --> 00:25:22,000
[Student] Kan du legge til \ 0?

346
00:25:22,000 --> 00:25:24,000
Vi kunne i dette tilfellet.

347
00:25:24,000 --> 00:25:29,000
Vi kunne legge til noen slags \ 0

348
00:25:29,000 --> 00:25:33,000
eller noen form for betegner karakter og deretter bruke det.

349
00:25:33,000 --> 00:25:36,000
Men det er ikke helt til å fungere

350
00:25:36,000 --> 00:25:40,000
fordi \ 0 er for en char attraksjon,

351
00:25:40,000 --> 00:25:43,000
og her har vi ints.

352
00:25:43,000 --> 00:25:46,000
Den andre tingen er hvis vi skulle bruke en spesiell verdi

353
00:25:46,000 --> 00:25:49,000
som -1 å markere slutten av en matrise

354
00:25:49,000 --> 00:25:54,000
så vi aldri kunne lagre en -1 i våre heltall arrays.

355
00:25:54,000 --> 00:25:56,000
Vi ville bli sittende fast.

356
00:25:56,000 --> 00:26:00,000
Det viser seg at den eneste måten å få lengden

357
00:26:00,000 --> 00:26:03,000
av en rekke i C er å faktisk huske det

358
00:26:03,000 --> 00:26:08,000
når du setter den opp og deretter sende den rundt med array

359
00:26:08,000 --> 00:26:14,000
slik at når jeg har en funksjon som kommer til å gjøre noe arbeid

360
00:26:14,000 --> 00:26:18,000
på en rekke heltall eller flyter eller dobler eller hva har du,

361
00:26:18,000 --> 00:26:22,000
Jeg må også gi funksjonen tabellens lengde,

362
00:26:22,000 --> 00:26:26,000
og det er akkurat hva vi har gjort her i søkefunksjonen.

363
00:26:26,000 --> 00:26:30,000
Hvis du ser, hva vi har gjort når vi passerer i array vår her,

364
00:26:30,000 --> 00:26:36,000
vi også passere i lengden, størrelsen.

365
00:26:36,000 --> 00:26:41,000
Det skjer bare det at vi har kalt denne variabelen her,

366
00:26:41,000 --> 00:26:43,000
denne parameteren eller argument.

367
00:26:43,000 --> 00:26:46,000
Dette kalles en funksjon argument liste eller parameter liste,

368
00:26:46,000 --> 00:26:51,000
og disse kalles også argumenter eller parametere.

369
00:26:51,000 --> 00:26:53,000
Folk bruker ulike begreper på ulike tidspunkter.

370
00:26:53,000 --> 00:26:55,000
Jeg har noen ganger utveksle dem selv.

371
00:26:55,000 --> 00:27:00,000
Det bare så skjer at denne variabelen her er oppkalt tilsvarende

372
00:27:00,000 --> 00:27:03,000
til dette # define opp her.

373
00:27:03,000 --> 00:27:06,000
Men de er ikke det samme.

374
00:27:06,000 --> 00:27:11,000
Kapitaliseringen gjør saken.

375
00:27:11,000 --> 00:27:14,000
>> Hvis du ser på hva som skjer her, erklærer vi

376
00:27:14,000 --> 00:27:18,000
vår int array, som vi har kalt tall.

377
00:27:18,000 --> 00:27:23,000
Vi har gitt det vår størrelse, som tilsvarer vår # define opp på toppen.

378
00:27:23,000 --> 00:27:27,000
Det kommer til å være 8.

379
00:27:27,000 --> 00:27:35,000
Og så når vi da kalle vår søkefunksjon der nede,

380
00:27:35,000 --> 00:27:40,000
vi passerer i antall vi ønsker å søke etter, som vi har bedt om det,

381
00:27:40,000 --> 00:27:43,000
fått fra brukeren.

382
00:27:43,000 --> 00:27:46,000
Vi passerer i rekken, dette tall,

383
00:27:46,000 --> 00:27:51,000
og da må vi også passere i størrelsen på tabellen,

384
00:27:51,000 --> 00:27:57,000
og da verdien av størrelse 8 blir lagret

385
00:27:57,000 --> 00:28:01,000
eller sendes til denne heltallsvariabel kalt størrelse.

386
00:28:01,000 --> 00:28:08,000
Vi har størrelsen på matrisen.

387
00:28:08,000 --> 00:28:11,000
Nå går vi tilbake til det vi snakket om tidligere,

388
00:28:11,000 --> 00:28:14,000
Jeg tror Missy tok opp poenget at det vi trengte å gjøre er å få lengden av tabellen

389
00:28:14,000 --> 00:28:20,000
og dele det med 2, og som vil gi oss midtpunktet.

390
00:28:20,000 --> 00:28:22,000
La oss se.

391
00:28:22,000 --> 00:28:25,000
Kan jeg ha noen skrive dette og lagre det i sin stilling?

392
00:28:25,000 --> 00:28:27,000
Hva med Leila?

393
00:28:27,000 --> 00:28:31,000
Kan jeg ha du skrive dette i?

394
00:28:31,000 --> 00:28:35,000
Skriv den første linjen der du tar lengden på rekke og få midtpunktet

395
00:28:35,000 --> 00:28:41,000
og lagre den i en ny variabel.

396
00:28:41,000 --> 00:28:44,000
Jeg skal gi deg et par sekunder. Er du klar?

397
00:28:44,000 --> 00:28:46,000
[Student uhørlig]

398
00:28:46,000 --> 00:28:50,000
Jada, jeg kunne ha deg å beregne midtpunktet

399
00:28:50,000 --> 00:28:55,000
av høystakken rekke inne i søkefunksjonen

400
00:28:55,000 --> 00:29:03,000
bruke lengden av høystakken matrise, som er den størrelse variabel?

401
00:29:03,000 --> 00:29:08,000
Ikke noe vanskelig her.

402
00:29:08,000 --> 00:29:12,000
[Leila] Bare størrelse / 2 og just-

403
00:29:12,000 --> 00:29:17,000
Og lagre den, og traff på Lagre-knappen her oppe på toppen,

404
00:29:17,000 --> 00:29:19,000
og vi vil trekke det opp.

405
00:29:19,000 --> 00:29:22,000
Perfekt.

406
00:29:22,000 --> 00:29:28,000
Det vi går. Awesome.

407
00:29:28,000 --> 00:29:30,000
>> Som er, vil dette kompilere?

408
00:29:30,000 --> 00:29:32,000
[Leila] Nei, det må være høyere.

409
00:29:32,000 --> 00:29:34,000
[Nate] Yeah, så hva trenger vi å gjøre?

410
00:29:34,000 --> 00:29:36,000
[Leila] Like int midtpunktet eller noe.

411
00:29:36,000 --> 00:29:41,000
Awesome. Ja, la oss gjøre det, int midtpunktet = størrelse.

412
00:29:41,000 --> 00:29:44,000
Vil dette kompilere?

413
00:29:44,000 --> 00:29:47,000
La oss slette denne kommentaren og få det ut av veien.

414
00:29:47,000 --> 00:29:50,000
Hva vil ikke kompilere om dette?

415
00:29:50,000 --> 00:29:52,000
Vi gjør ikke noe med heltall,

416
00:29:52,000 --> 00:29:55,000
så vi må skrive det ut eller noe sånt.

417
00:29:55,000 --> 00:29:58,000
Ja, akkurat.

418
00:29:58,000 --> 00:30:00,000
Vi får en ubrukt variabel.

419
00:30:00,000 --> 00:30:02,000
Hva annet er ikke til å fungere om dette?

420
00:30:02,000 --> 00:30:06,000
Jeg tror du sa noe, Sam. Semikolon.

421
00:30:06,000 --> 00:30:08,000
Ja, jeg mangler de semikolon.

422
00:30:08,000 --> 00:30:14,000
Det kommer til å være en konstant ting i løpet av semesteret.

423
00:30:14,000 --> 00:30:17,000
Den siste tingen jeg vil gjøre er jeg skal sette inn mellomrom på hver side

424
00:30:17,000 --> 00:30:23,000
av denne operatør her, siden det er typisk hvordan vi gjør det

425
00:30:23,000 --> 00:30:26,000
i henhold til vår stil guide.

426
00:30:26,000 --> 00:30:29,000
Vi har fått midtpunktet av array vår.

427
00:30:29,000 --> 00:30:32,000
Nå hvis vi husker tilbake til algoritmen vår,

428
00:30:32,000 --> 00:30:37,000
hva var det andre trinnet at vi måtte gjøre når vi har midtpunktet?

429
00:30:37,000 --> 00:30:42,000
[Student] Hvis den er større [hørbar].

430
00:30:42,000 --> 00:30:48,000
Ja, så vi må gjøre noen form for sammenligning, og hva vi sammenligner her?

431
00:30:48,000 --> 00:30:53,000
Du sa at hvis det er større enn. Hva er det i den setningen refererer til?

432
00:30:53,000 --> 00:30:57,000
Nummeret som kommer opp, hvis det er større enn midtpunktet, og deretter gå opp til array?

433
00:30:57,000 --> 00:31:05,000
Nøyaktig, så antallet som kommer opp når vi-

434
00:31:05,000 --> 00:31:10,000
Nålen, så vi sammenligne med nålen,

435
00:31:10,000 --> 00:31:12,000
og hva er vi sammenligne mot nålen?

436
00:31:12,000 --> 00:31:15,000
Fordi nålen er hva vi leter etter.

437
00:31:15,000 --> 00:31:18,000
Vi sammenligner det å komme til midtpunktet.

438
00:31:18,000 --> 00:31:21,000
>> Men gjør det fornuftig å sjekke for å se

439
00:31:21,000 --> 00:31:27,000
hvis p = midtpunktet?

440
00:31:27,000 --> 00:31:32,000
Gjør det fornuftig?

441
00:31:32,000 --> 00:31:35,000
Ikke uenig noen?

442
00:31:35,000 --> 00:31:40,000
La oss gi det et forsøk, hvis (nål == midtpunkt).

443
00:31:40,000 --> 00:31:42,000
[Student] Har printf du fant det.

444
00:31:42,000 --> 00:31:51,000
[Nate] printf ("Vi fant det \ n");

445
00:31:51,000 --> 00:31:56,000
Ellers-Jeg kommer til å begynne å gjøre noe annerledes her.

446
00:31:56,000 --> 00:32:00,000
Jeg kommer til å begynne å sette tannregulering rundt hvis uttalelser hele tiden

447
00:32:00,000 --> 00:32:05,000
bare fordi hvis vi legger flere ting, så

448
00:32:05,000 --> 00:32:07,000
Vi får ikke kompilatorer.

449
00:32:07,000 --> 00:32:09,000
Ja, Sam. Du har et poeng.

450
00:32:09,000 --> 00:32:12,000
Problemet er at midtpunktet representerer en posisjon i matrisen,

451
00:32:12,000 --> 00:32:15,000
men du kan få det til å representere verdien i den posisjonen i matrisen.

452
00:32:15,000 --> 00:32:17,000
Det er et stort poeng.

453
00:32:17,000 --> 00:32:19,000
Visste alle høre hva Sam sa?

454
00:32:19,000 --> 00:32:22,000
Han sa at midtpunktet som er

455
00:32:22,000 --> 00:32:28,000
representerer bare en posisjon i tabellen, men det er ikke den faktiske element i matrisen.

456
00:32:28,000 --> 00:32:30,000
Hvis du tenker på koden som er skrevet akkurat nå,

457
00:32:30,000 --> 00:32:35,000
hvis vi ser på denne tabellen her nede, som har 8 elementer i den,

458
00:32:35,000 --> 00:32:39,000
hva er verdien av midtpunktet kommer til å være i denne funksjonen?

459
00:32:39,000 --> 00:32:41,000
[Student] 4.

460
00:32:41,000 --> 00:32:45,000
[Nate] 4.

461
00:32:45,000 --> 00:32:51,000
Hvis vi ser etter nummer 4 -

462
00:32:51,000 --> 00:32:54,000
og vi kan bare kjøre denne koden og sette litt trist ansikt her

463
00:32:54,000 --> 00:32:58,000
fordi vi ikke fant det-hvis vi kjører denne koden

464
00:32:58,000 --> 00:33:04,000
som er akkurat nå, laster den, bygg, la meg bla nedover,

465
00:33:04,000 --> 00:33:09,000
og hvis vi ser etter nummer 4,

466
00:33:09,000 --> 00:33:18,000
vi fant det, men vi fikk ikke dette til printf ja.

467
00:33:18,000 --> 00:33:23,000
En grunn er at vi ikke kom tilbake sant,

468
00:33:23,000 --> 00:33:26,000
men vi virkelig finne nummeret 4?

469
00:33:26,000 --> 00:33:28,000
Og Sam sier nei.

470
00:33:28,000 --> 00:33:31,000
Hva fant vi?

471
00:33:31,000 --> 00:33:35,000
Vi har virkelig funnet midtpunktet, som hvis vi ser på tabellen her nede,

472
00:33:35,000 --> 00:33:38,000
det kommer til å være element i indeksen 4 som vi ser på,

473
00:33:38,000 --> 00:33:42,000
som er 23.

474
00:33:42,000 --> 00:33:46,000
>> Hvordan gjør vi faktisk får det elementet på midtpunktet

475
00:33:46,000 --> 00:33:48,000
og ikke bare midtpunktet selv?

476
00:33:48,000 --> 00:33:52,000
[Student] Vi ville gå inn røye eller noe?

477
00:33:52,000 --> 00:33:55,000
Hva ville det gjøre, bare ut av nysgjerrighet?

478
00:33:55,000 --> 00:33:57,000
Kan du utdype litt mer?

479
00:33:57,000 --> 00:34:02,000
Du må transformere posisjon inn nummeret,

480
00:34:02,000 --> 00:34:05,000
så du har å gjøre noen forbindelse-Jeg tror det er røye, men det kan ikke være.

481
00:34:05,000 --> 00:34:07,000
Ja, det er et godt poeng.

482
00:34:07,000 --> 00:34:12,000
Vi har gjort mye av dette konvertere posisjoner til chars, disse tegnene,

483
00:34:12,000 --> 00:34:14,000
i de to første oppgavesett.

484
00:34:14,000 --> 00:34:18,000
Det viser seg at her, dette er nesten lik

485
00:34:18,000 --> 00:34:24,000
tilgang til ITH tegnet i en streng, hvis det er fornuftig.

486
00:34:24,000 --> 00:34:30,000
Her ønsker vi å få tilgang til midtpunktet element.

487
00:34:30,000 --> 00:34:34,000
Hvordan gjør vi det?

488
00:34:34,000 --> 00:34:39,000
Kevin, har du noen forslag til hvordan vi kan gjøre det?

489
00:34:39,000 --> 00:34:44,000
Du kan gjøre høystakken, lukket åpen brakett, mid, brakett.

490
00:34:44,000 --> 00:34:46,000
Kan du skrive det for oss?

491
00:34:46,000 --> 00:34:51,000
Lagre det i her, og vi vil trekke det opp.

492
00:34:51,000 --> 00:34:56,000
Vi ser på denne linjen 9,

493
00:34:56,000 --> 00:34:59,000
og vi innser at vi ikke ønsker å sammenligne nålen til midtpunktet,

494
00:34:59,000 --> 00:35:03,000
men i stedet ønsker vi å sammenligne nålen

495
00:35:03,000 --> 00:35:07,000
til elementet i posisjon midtpunktet innenfor vår høystakk array.

496
00:35:07,000 --> 00:35:10,000
Cool.

497
00:35:10,000 --> 00:35:12,000
Det vi går.

498
00:35:12,000 --> 00:35:15,000
Ja, ser det ganske bra, hvis (nål == høystakk [midtpunktet]).

499
00:35:15,000 --> 00:35:18,000
Vi fant det.

500
00:35:18,000 --> 00:35:22,000
Nå hvis vi kjører koden-vi tilbake opp litt-

501
00:35:22,000 --> 00:35:26,000
det kompilerer, det går, og nå hvis vi ser for 4,

502
00:35:26,000 --> 00:35:30,000
Vi fant ikke det fordi vi er nå faktisk får nummer 23.

503
00:35:30,000 --> 00:35:33,000
Vi får verdien 23, og det er det vi sammenligner til p vår.

504
00:35:33,000 --> 00:35:35,000
Men det er bra. Det er et skritt i riktig retning.

505
00:35:35,000 --> 00:35:37,000
>> Det er det vi prøver å gjøre.

506
00:35:37,000 --> 00:35:40,000
Vi prøver ikke å sammenligne nålen mot posisjoner i rekken

507
00:35:40,000 --> 00:35:44,000
men heller mot selve elementene i matrisen.

508
00:35:44,000 --> 00:35:49,000
Hvis vi ser tilbake igjen nå på det neste trinnet i algoritmen vår,

509
00:35:49,000 --> 00:35:51,000
hva er neste steg?

510
00:35:51,000 --> 00:35:57,000
Leila allerede nevnt det kort.

511
00:35:57,000 --> 00:36:00,000
[Student] Sjekk om den er større eller mindre enn, og deretter bestemme hvilken vei å gå.

512
00:36:00,000 --> 00:36:03,000
[Nate] Yeah, ville så hvordan vi gjør det?

513
00:36:03,000 --> 00:36:07,000
Kan du legge på noen-Jeg sparer denne revisjonen,

514
00:36:07,000 --> 00:36:13,000
og hvis du putter i noen linjer som vil gjøre det.

515
00:36:13,000 --> 00:36:15,000
Ja, Charlotte. >> Jeg har et spørsmål.

516
00:36:15,000 --> 00:36:19,000
Burde det ikke være midtpunktet - 1 fordi det første er

517
00:36:19,000 --> 00:36:26,000
det er 0 indeksert, så hvis vi legger 4, det er faktisk ikke tegnet vi leter etter?

518
00:36:26,000 --> 00:36:30,000
Ja, og det andre problemet med det er-

519
00:36:30,000 --> 00:36:35,000
det er en stor fangst, fordi det kommer til å ende opp som skjer muligens

520
00:36:35,000 --> 00:36:42,000
hvis vi holder bevegelse og vi ikke alltid justere i utgangspunktet?

521
00:36:42,000 --> 00:36:46,000
Jeg antar det vi kan ende opp med å gjøre er å prøve å få tilgang til

522
00:36:46,000 --> 00:36:49,000
elementet på den åttende stilling i matrisen,

523
00:36:49,000 --> 00:36:53,000
som i dette tilfellet ikke.

524
00:36:53,000 --> 00:36:56,000
Vi ønsker å gjøre noen form for regnskap for det faktum

525
00:36:56,000 --> 00:36:59,000
at vi har noen null indeksering.

526
00:36:59,000 --> 00:37:05,000
[Charlotte] Beklager, jeg mente midtpunktet - 1 i hakeparenteser.

527
00:37:05,000 --> 00:37:08,000
Vi kan gjøre det.

528
00:37:08,000 --> 00:37:10,000
Vi vil komme tilbake til denne saken i bare litt.

529
00:37:10,000 --> 00:37:13,000
Når vi begynner å komme til den faktiske looping,

530
00:37:13,000 --> 00:37:16,000
det er da vi vil virkelig se dette kommer inn i bildet.

531
00:37:16,000 --> 00:37:21,000
For tiden kan vi gjøre dette, men du er helt rett.

532
00:37:21,000 --> 00:37:28,000
At null indeksering vil ha en effekt som vi trenger å ta hensyn til.

533
00:37:28,000 --> 00:37:30,000
La oss se.

534
00:37:30,000 --> 00:37:34,000
>> Hvordan er større enn og mindre enn-?

535
00:37:34,000 --> 00:37:36,000
[Student] Jeg får hvordan du gjør det større enn og mindre enn en del.

536
00:37:36,000 --> 00:37:41,000
Jeg var ikke sikker på hva du skal skrive ut hvis du finner ut at det er mindre enn høystakken midtpunktet eller større enn.

537
00:37:41,000 --> 00:37:43,000
Her kan jeg redde det I've-

538
00:37:43,000 --> 00:37:47,000
[Nate] Ja, hvis du lagrer det du har, og vi vil trekke det opp.

539
00:37:47,000 --> 00:37:49,000
Det vi går.

540
00:37:49,000 --> 00:37:51,000
[Student] Og jeg setter spørsmålstegn for hva jeg ikke vet.

541
00:37:51,000 --> 00:37:54,000
[Nate] Det ser flott ut.

542
00:37:54,000 --> 00:37:58,000
Her har vi spørsmålstegn fordi vi fortsatt ikke vet

543
00:37:58,000 --> 00:38:06,000
hva vi skal ganske gjøre ennå.

544
00:38:06,000 --> 00:38:12,000
Hva ville vi ønsker å gjøre, oops, vi har noen bukseseler alle funky på oss.

545
00:38:12,000 --> 00:38:15,000
Vi vil rette disse bukseseler.

546
00:38:15,000 --> 00:38:19,000
Det vi går.

547
00:38:19,000 --> 00:38:22,000
Og så hva vi ønsker å gjøre, ifølge algoritmen vår,

548
00:38:22,000 --> 00:38:27,000
hvis vi ikke finne nålen?

549
00:38:27,000 --> 00:38:32,000
Si i saken at nålen er mindre enn hva vi ser på. Kevin.

550
00:38:32,000 --> 00:38:34,000
Bare se på den venstre halvdelen.

551
00:38:34,000 --> 00:38:40,000
Rett, så vil vi sette en kommentar her som sier "se på venstre halvdel."

552
00:38:40,000 --> 00:38:46,000
Og hvis nålen er større enn høystakken på midtpunktet, hva vi ønsker å gjøre?

553
00:38:46,000 --> 00:38:48,000
[Student] Så du ser på høyre halvdel.

554
00:38:48,000 --> 00:38:53,000
Se på høyre halvdel, "se på høyre halvdel."

555
00:38:53,000 --> 00:38:58,000
Not too shabby.

556
00:38:58,000 --> 00:39:05,000
Ok, så på dette punktet, er ting ser ganske bra.

557
00:39:05,000 --> 00:39:13,000
Problemet med koden som er skrevet er hva?

558
00:39:13,000 --> 00:39:15,000
[Student] Du har ikke endepunktene halvdelene.

559
00:39:15,000 --> 00:39:18,000
Høyre, har vi ikke endepunktene halvdelene.

560
00:39:18,000 --> 00:39:20,000
Vi er også bare kommer til å gå gjennom dette en gang.

561
00:39:20,000 --> 00:39:23,000
Vi kommer bare til å se på en midtpunktet.

562
00:39:23,000 --> 00:39:27,000
Enten elementet er der, eller er det ikke.

563
00:39:27,000 --> 00:39:34,000
For å fullføre dette, må vi gjøre noen form for repetisjon.

564
00:39:34,000 --> 00:39:39,000
Vi trenger å terpe før vi finner ut at

565
00:39:39,000 --> 00:39:43,000
enten elementet er der fordi vi har snevret ned og endelig funnet den,

566
00:39:43,000 --> 00:39:46,000
eller det er ikke der fordi vi har sett gjennom alle de tingene

567
00:39:46,000 --> 00:39:52,000
i de aktuelle halvdelene av matrisen og fant at ingenting er der.

568
00:39:52,000 --> 00:39:56,000
>> Når vi har fått denne repetisjonen skjer, hva vi kommer til å bruke?

569
00:39:56,000 --> 00:39:58,000
[Student] En løkke.

570
00:39:58,000 --> 00:40:00,000
Noen slags loop. Ja.

571
00:40:00,000 --> 00:40:03,000
[Student] Kan vi gjøre en gjør-mens loop og få den gjøre det og deretter mens

572
00:40:03,000 --> 00:40:10,000
nålen ikke lik-Jeg er ikke sikker på hvor jeg skulle med det.

573
00:40:10,000 --> 00:40:18,000
Men typen som gjør at så lenge det ikke lik verdien som brukeren input.

574
00:40:18,000 --> 00:40:21,000
Ja, så la oss se, hvordan kan dette skrive seg selv?

575
00:40:21,000 --> 00:40:23,000
Du sa la oss bruke en gjør-mens loop.

576
00:40:23,000 --> 00:40:26,000
Hvor gjør starten?

577
00:40:26,000 --> 00:40:33,000
[Student] Rett etter størrelse / 2.

578
00:40:33,000 --> 00:40:42,000
[Nate] Ok, og hva skal vi gjøre?

579
00:40:42,000 --> 00:40:44,000
Vi vil fylle på stund senere.

580
00:40:44,000 --> 00:40:46,000
Hva skal vi gjøre?

581
00:40:46,000 --> 00:40:49,000
[Student] Ikke ønsker vi å gjøre alle ting har vi i hvis del?

582
00:40:49,000 --> 00:40:52,000
[Nate] Gjør alt dette, flott.

583
00:40:52,000 --> 00:40:55,000
Kopier og lim inn.

584
00:40:55,000 --> 00:40:59,000
Oh, mann.

585
00:40:59,000 --> 00:41:03,000
La oss se om dette fungerer, hvis vi kan kategorien dette over.

586
00:41:03,000 --> 00:41:08,000
Vakker.

587
00:41:08,000 --> 00:41:16,000
Greit, og vi sparer dette så dere har det.

588
00:41:16,000 --> 00:41:21,000
Greit, og vi kommer til å gjøre dette mens-

589
00:41:21,000 --> 00:41:25,000
hva var mens tilstanden du var ute etter?

590
00:41:25,000 --> 00:41:31,000
[Student] Mens nålen ikke lik, så som utropstegn.

591
00:41:31,000 --> 00:41:37,000
Men jeg er ikke sikker på nøyaktig hva det er ennå.

592
00:41:37,000 --> 00:41:39,000
[Nate] Yeah, dette er en måte å gjøre det.

593
00:41:39,000 --> 00:41:41,000
Sam, har du en kommentar?

594
00:41:41,000 --> 00:41:43,000
[Sam] Jeg husket da jeg så på videoer,

595
00:41:43,000 --> 00:41:48,000
Jeg tok en skjermdump av en av-lignende når vi gjorde pseudokode for det,

596
00:41:48,000 --> 00:41:52,000
det var noen sammenheng mellom maks og min.

597
00:41:52,000 --> 00:41:58,000
Jeg tror det var noe sånt som om max er stadig mindre enn min.

598
00:41:58,000 --> 00:42:00,000
Fikk den.

599
00:42:00,000 --> 00:42:04,000
[Sam] Eller som om max er ikke mindre enn min eller noe sånt,

600
00:42:04,000 --> 00:42:06,000
fordi det ville bety at du har søkt alt.

601
00:42:06,000 --> 00:42:13,000
>> Ja, så hva høres det ut som max og min var henviser til?

602
00:42:13,000 --> 00:42:16,000
[Sam] verdier som-heltall som kommer til å endre

603
00:42:16,000 --> 00:42:18,000
i forhold til der vi satt midtpunktet.

604
00:42:18,000 --> 00:42:20,000
Akkurat.

605
00:42:20,000 --> 00:42:24,000
[Sam] På dette tidspunktet, det kommer til [uhørbart] beregne maks og min.

606
00:42:24,000 --> 00:42:29,000
Midtpunkt er dette maks og min idé.

607
00:42:29,000 --> 00:42:35,000
Gjør det fornuftig for folk?

608
00:42:35,000 --> 00:42:39,000
Hvis vi skulle begynne å se på hvordan vi skal gjøre dette iterasjon,

609
00:42:39,000 --> 00:42:43,000
du er helt riktig at vi ønsker å bruke noen form for do-mens loop.

610
00:42:43,000 --> 00:42:49,000
Men jeg antar at hvis vi husker hva som skjer på stedet av denne tabellen

611
00:42:49,000 --> 00:42:53,000
og hva som faktisk skjer-Jeg kommer til å skrive over her-

612
00:42:53,000 --> 00:42:58,000
på den aller første iterasjon av binære søk, har-vi

613
00:42:58,000 --> 00:43:05,000
Jeg kommer til å bruke b og e for å betegne begynnelsen.

614
00:43:05,000 --> 00:43:10,000
Og så skal enden av tabellen vår.

615
00:43:10,000 --> 00:43:14,000
Vi vet at begynnelsen er på 4 rett over her,

616
00:43:14,000 --> 00:43:18,000
og vi vet at slutten er på 108.

617
00:43:18,000 --> 00:43:23,000
Si at vi søker etter nummer 15.

618
00:43:23,000 --> 00:43:27,000
Den første gangen vi gjør dette, som vi så tidligere,

619
00:43:27,000 --> 00:43:30,000
midtpunktet er enten kommer til å være 16 eller 23

620
00:43:30,000 --> 00:43:34,000
avhengig av hvordan vi beregner ting.

621
00:43:34,000 --> 00:43:37,000
Siden jevnt dele i midten ville gi oss denne plassen

622
00:43:37,000 --> 00:43:42,000
mellom 16 og 23, kan vi ikke jevnt dele det

623
00:43:42,000 --> 00:43:47,000
eller dele det og få på en sann midtpunktet.

624
00:43:47,000 --> 00:43:49,000
Vi skal se på 16 år.

625
00:43:49,000 --> 00:43:55,000
Vi vil realisere "Hey, 16> 15 som vi leter etter."

626
00:43:55,000 --> 00:43:59,000
Å deretter se på venstre halvdel av tabellen

627
00:43:59,000 --> 00:44:03,000
hva vi vil ende opp med å gjøre forkaster

628
00:44:03,000 --> 00:44:07,000
hele denne øvre delen

629
00:44:07,000 --> 00:44:16,000
og sier: "Ok, nå vår endepunkt skal være her."

630
00:44:16,000 --> 00:44:22,000
Den neste iterasjon av loop, er vi nå ser på denne tabellen,

631
00:44:22,000 --> 00:44:25,000
effektivt å ha forkastet dette delen fordi nå

632
00:44:25,000 --> 00:44:30,000
hvis vi tar midtpunktet å være forskjellen mellom begynnelsen og slutten,

633
00:44:30,000 --> 00:44:34,000
vi finner vår midtpunktet å være 8,

634
00:44:34,000 --> 00:44:40,000
som vi kan så teste 8 for å se hvor den er i forhold til antall vi leter etter,

635
00:44:40,000 --> 00:44:44,000
15, finner ut at 15 er større,

636
00:44:44,000 --> 00:44:49,000
så vi må flytte til høyre del av listen,

637
00:44:49,000 --> 00:44:51,000
som vi vet, fordi vi er mennesker, og vi kan se det.

638
00:44:51,000 --> 00:44:54,000
Vi vet at den høyre delen kommer til å være der vi finner det,

639
00:44:54,000 --> 00:45:01,000
men datamaskinen ikke vet det, så hva vi vil gjøre er at vi vil faktisk

640
00:45:01,000 --> 00:45:04,000
har dette gå opp, og nå i begynnelsen og slutten

641
00:45:04,000 --> 00:45:11,000
er det samme stedet, så midtpunktet blir det eneste nummeret i listen på det punktet,

642
00:45:11,000 --> 00:45:16,000
som er 15, og vi har funnet det.

643
00:45:16,000 --> 00:45:21,000
Betyr det kaste lys over hvor hele denne max og min notasjon går,

644
00:45:21,000 --> 00:45:24,000
holde orden på endepunktene i tabellen for å finne ut

645
00:45:24,000 --> 00:45:35,000
hvordan å begrense ting ned?

646
00:45:35,000 --> 00:45:42,000
>> Hva ville skje hvis dette ikke var lik 15 nå?

647
00:45:42,000 --> 00:45:52,000
Hva hvis vi var ute etter 15 og i stedet var dette tallet også 16?

648
00:45:52,000 --> 00:45:54,000
Vi vil si, "Å, det er større.

649
00:45:54,000 --> 00:45:57,000
Vi ønsker å gå tilbake til venstre. "

650
00:45:57,000 --> 00:46:01,000
Og vi ville flytte vår e til høyre,

651
00:46:01,000 --> 00:46:06,000
på hvilket punkt har vi et endepunkt som ville være i konflikt.

652
00:46:06,000 --> 00:46:09,000
Det ville ikke være i stand til å søke etter eventuelle flere elementer

653
00:46:09,000 --> 00:46:13,000
fordi nå har vi vår endepunkt og vår startpunkt,

654
00:46:13,000 --> 00:46:16,000
vår max og vår min, er nå snudd.

655
00:46:16,000 --> 00:46:23,000
Vi søker gjennom hele matrisen. Vi kan ikke finne noe.

656
00:46:23,000 --> 00:46:27,000
Det er punktet der vi ønsker å si, "Ok, vi kommer til å stoppe denne algoritmen.

657
00:46:27,000 --> 00:46:34,000
Vi har ikke funnet noe. Vi vet det er ikke her. "

658
00:46:34,000 --> 00:46:36,000
Hvordan dette kommer?

659
00:46:36,000 --> 00:46:40,000
[Student] Hvor nøyaktig slår maskinen slutten?

660
00:46:40,000 --> 00:46:45,000
Hvordan ender til slutt opp før begynnelsen?

661
00:46:45,000 --> 00:46:48,000
Slutten ender opp før begynnelsen

662
00:46:48,000 --> 00:46:54,000
på grunn av det matte som vi kommer til å gjøre hver gang vi gjør dette.

663
00:46:54,000 --> 00:47:00,000
Måten vi bytte er hvis du ser på den aller første gangen vi gjør dette swap

664
00:47:00,000 --> 00:47:03,000
hvor vi har begynnelsen ved 4 og enden

665
00:47:03,000 --> 00:47:13,000
hele veien ned på 108 og vår midtpunktet, sier at 16 -

666
00:47:13,000 --> 00:47:20,000
Jeg kommer til å tilbakestille dette tilbake til 15-hvis vi leter etter de 15,

667
00:47:20,000 --> 00:47:25,000
vi visste at det vi gjorde da vi sjekket 16 og så at det var større

668
00:47:25,000 --> 00:47:28,000
og ønsket å forkaste hele høyre del av listen,

669
00:47:28,000 --> 00:47:36,000
Vi så at det vi ønsket å gjøre er å flytte denne e her.

670
00:47:36,000 --> 00:47:44,000
Effektivt, fikk e flyttet til en før midtpunktet.

671
00:47:44,000 --> 00:47:48,000
Likeledes når vi gjorde dette iterasjon av algoritmen

672
00:47:48,000 --> 00:47:51,000
og midtpunktet var på 8,

673
00:47:51,000 --> 00:47:55,000
Vi fant at 8 <15, så vi ønsket å flytte b

674
00:47:55,000 --> 00:48:00,000
en forbi midtpunktet.

675
00:48:00,000 --> 00:48:07,000
Nå, begynnelsen og enden er begge sammen på denne 15.

676
00:48:07,000 --> 00:48:10,000
>> Hvis vi hadde hatt det slik lete etter en annen verdi, ikke 15,

677
00:48:10,000 --> 00:48:14,000
eller hvis denne 15 hadde i stedet blitt en 16,

678
00:48:14,000 --> 00:48:20,000
vi ville ha funnet ut at e vi ønsker å flytte en før midtpunktet.

679
00:48:20,000 --> 00:48:33,000
Nå e ville være der venda mindre enn b.

680
00:48:33,000 --> 00:48:39,000
La oss gå gjennom hvordan vi faktisk ende opp koding denne algoritmen.

681
00:48:39,000 --> 00:48:44,000
Vi vet at vi ønsker å ha denne midtpunktet beregningen.

682
00:48:44,000 --> 00:48:48,000
Vi vet også at vi ønsker å spore begynnelsen og slutten av tabellen

683
00:48:48,000 --> 00:48:51,000
av vår nåværende utvalg, slik at vi kan finne ut

684
00:48:51,000 --> 00:48:56,000
hvor denne venstre halvdel av listen er og hvor den høyre halvdel av listen er.

685
00:48:56,000 --> 00:49:03,000
Vi gjør det med enten begynner og slutter,

686
00:49:03,000 --> 00:49:07,000
eller vi kan kalle dem min og maks.

687
00:49:07,000 --> 00:49:10,000
Jeg skal bruke begynner og slutter denne gangen.

688
00:49:10,000 --> 00:49:15,000
Når vi begynner, hvis vi ser tilbake på vårt eksempel her nede,

689
00:49:15,000 --> 00:49:20,000
våre begynnelsen ble satt til begynnelsen av tabellen, som naturlig.

690
00:49:20,000 --> 00:49:25,000
Hva indeksen var dette? Hva skal vår begynne bli?

691
00:49:25,000 --> 00:49:27,000
Daniel.

692
00:49:27,000 --> 00:49:30,000
[Daniel] Haystack [0].

693
00:49:30,000 --> 00:49:37,000
[Nate] Yeah, slik at vi kunne sette den lik høystakken [0].

694
00:49:37,000 --> 00:49:40,000
Problemet, er imidlertid at det gir oss ikke posisjonen av det første elementet.

695
00:49:40,000 --> 00:49:45,000
Det gir oss indeksen av det første elementet eller det faktiske verdi på det første posisjon.

696
00:49:45,000 --> 00:49:47,000
[Student] Det vil konvertere til 0,20?

697
00:49:47,000 --> 00:49:52,000
[Nate] Hva dette vil gjøre er-vel, vil det ikke gjøre noe konvertering.

698
00:49:52,000 --> 00:49:56,000
Hva det vil gjøre det vil lagre en 4 i begynne,

699
00:49:56,000 --> 00:49:59,000
og da vil det være vanskelig å foreta sammenlikninger mot begynne

700
00:49:59,000 --> 00:50:03,000
fordi Begin skal disponere verdi på 4,

701
00:50:03,000 --> 00:50:06,000
som er begynnelsen av array vår,

702
00:50:06,000 --> 00:50:08,000
men vi ønsker å spore indeksene i rekken

703
00:50:08,000 --> 00:50:11,000
i motsetning til de verdier.

704
00:50:11,000 --> 00:50:17,000
Vi vil faktisk bruke en 0, sånn.

705
00:50:17,000 --> 00:50:20,000
For enden av tabellen-Charlotte tok dette opp litt tidligere.

706
00:50:20,000 --> 00:50:23,000
Dette er hvor vi tar hensyn til null indeksering.

707
00:50:23,000 --> 00:50:25,000
>> Charlotte, hva er slutten av tabellen?

708
00:50:25,000 --> 00:50:28,000
Hva er indeksen på slutten?

709
00:50:28,000 --> 00:50:30,000
[Charlotte] Størrelse - 1.

710
00:50:30,000 --> 00:50:32,000
Ja, og hvilken størrelse bør vi bruke?

711
00:50:32,000 --> 00:50:35,000
Skal vi bruke egenkapital eller små størrelser?

712
00:50:35,000 --> 00:50:37,000
Egenkapital.

713
00:50:37,000 --> 00:50:42,000
I dette tilfellet kan vi bruke egenkapital.

714
00:50:42,000 --> 00:50:45,000
Hvis vi ønsket at denne funksjonen skal være bærbare

715
00:50:45,000 --> 00:50:48,000
og bruke denne funksjonen i andre programmer,

716
00:50:48,000 --> 00:50:50,000
Vi kan faktisk bruke små størrelse.

717
00:50:50,000 --> 00:50:52,000
Det er greit også.

718
00:50:52,000 --> 00:51:01,000
Men Charlotte er helt riktig at vi ønsker å ha størrelse - 1.

719
00:51:01,000 --> 00:51:03,000
På dette punkt-

720
00:51:03,000 --> 00:51:05,000
[Student] Hvordan har det seg at du kan bruke store størrelse?

721
00:51:05,000 --> 00:51:07,000
Hvordan har det seg at vi kunne bruke store størrelse?

722
00:51:07,000 --> 00:51:13,000
Det viser seg at disse # definerer er virkelig,

723
00:51:13,000 --> 00:51:19,000
under panseret, en tekst som finne og erstatte, hvis det er fornuftig.

724
00:51:19,000 --> 00:51:24,000
Når du kompilere koden, forbehandling fase

725
00:51:24,000 --> 00:51:27,000
av kompilatoren går gjennom filen,

726
00:51:27,000 --> 00:51:31,000
og det ser for overalt at du har skrevet egenkapital,

727
00:51:31,000 --> 00:51:39,000
og det erstatter den teksten bokstavelig talt med en 8, akkurat sånn.

728
00:51:39,000 --> 00:51:42,000
I den forstand er dette veldig forskjellig fra en variabel.

729
00:51:42,000 --> 00:51:45,000
Det tar ikke opp noe plass i minnet.

730
00:51:45,000 --> 00:51:52,000
Det er en enkel tekst replace triks.

731
00:51:52,000 --> 00:51:57,000
I dette tilfellet skal vi bruke størrelse.

732
00:51:57,000 --> 00:52:01,000
Herfra vil vi gjøre noen form for repetisjon,

733
00:52:01,000 --> 00:52:03,000
og vi er på rett spor med vår do-while-løkke.

734
00:52:03,000 --> 00:52:08,000
Vi ønsker å gjøre noe før en tilstand ikke holder lenger,

735
00:52:08,000 --> 00:52:12,000
og som vi så tidligere, så vi at den tilstanden

736
00:52:12,000 --> 00:52:19,000
var faktisk at vi ikke vil til slutt

737
00:52:19,000 --> 00:52:24,000
å være mindre enn den begynne.

738
00:52:24,000 --> 00:52:26,000
>> Dette er vår stoppe tilstand.

739
00:52:26,000 --> 00:52:35,000
Hvis dette skjer, vil vi stoppe og erklære som "Hei, vi har ikke funnet noe."

740
00:52:35,000 --> 00:52:43,000
For å uttrykke dette, ønsker vi å bruke noen form for loop.

741
00:52:43,000 --> 00:52:49,000
I dette tilfellet ville det være en gjør-mens loop, en for løkke, en stund loop?

742
00:52:49,000 --> 00:52:51,000
Vi har en do-while løkke her.

743
00:52:51,000 --> 00:52:53,000
Har dere liker at tilnærmingen?

744
00:52:53,000 --> 00:52:59,000
Tror du vi bør prøve en annen tilnærming?

745
00:52:59,000 --> 00:53:01,000
Kevin, noen tanker?

746
00:53:01,000 --> 00:53:06,000
Vi kunne ha en stund loop fordi vi vet maksimal

747
00:53:06,000 --> 00:53:11,000
ville være større enn min i starten anyways.

748
00:53:11,000 --> 00:53:14,000
Ja, så det er ingen initialisering som må skje.

749
00:53:14,000 --> 00:53:17,000
De gjør-mens sløyfer er stor når du har å initialisere noe

750
00:53:17,000 --> 00:53:21,000
før så teste, mens her

751
00:53:21,000 --> 00:53:26,000
Vi vet at vi ikke kommer til å holde reinitializing både begynner og slutter

752
00:53:26,000 --> 00:53:28,000
hver runde av loopen.

753
00:53:28,000 --> 00:53:32,000
Vi vet at vi ønsker å initialisere dem, så sjekk vår tilstand.

754
00:53:32,000 --> 00:53:38,000
I dette tilfellet vil jeg faktisk gå med en enkel stund loop.

755
00:53:38,000 --> 00:53:44,000
Det viser seg at gjør-mens sløyfer brukes ganske sjelden.

756
00:53:44,000 --> 00:53:49,000
En rekke steder ikke engang undervise gjøre mens sløyfer.

757
00:53:49,000 --> 00:53:53,000
De er bra for håndtering brukerens input, så vi har sett mange av dem så langt.

758
00:53:53,000 --> 00:53:59,000
Men normalt for og mens sløyfer er mye mer vanlig.

759
00:53:59,000 --> 00:54:03,000
Det viser seg at denne tilstanden som skrevet

760
00:54:03,000 --> 00:54:09,000
vil egentlig ikke gjøre oss mye godt, og hvorfor er det?

761
00:54:09,000 --> 00:54:11,000
Jeg beklager, jeg vet ikke navnet ditt.

762
00:54:11,000 --> 00:54:13,000
Jeg er Jerry. >> Beklager?

763
00:54:13,000 --> 00:54:15,000
Det er B-O-R-U-I.

764
00:54:15,000 --> 00:54:18,000
Oh, okay.

765
00:54:18,000 --> 00:54:23,000
Jeg ser ikke deg på listen min.

766
00:54:23,000 --> 00:54:26,000
Åh, det er fordi-oh, det er fornuftig.

767
00:54:26,000 --> 00:54:31,000
Har du en idé om hvorfor dette mens loop ikke kan fungere som tiltenkt,

768
00:54:31,000 --> 00:54:38,000
som skrevet med tilstanden?

769
00:54:38,000 --> 00:54:43,000
[Jerry] Mener du som du vil at alle ting etter den i-?

770
00:54:43,000 --> 00:54:46,000
Ja, slik at man.

771
00:54:46,000 --> 00:54:49,000
Vi må kanskje sette alt dette ting i mens loop, som er helt sant.

772
00:54:49,000 --> 00:54:55,000
Den andre tingen som er litt mer problematisk, skjønt, er at denne tilstanden ikke fungerer.

773
00:54:55,000 --> 00:54:57,000
[Student] Du må snu den.

774
00:54:57,000 --> 00:55:04,000
Rett, så denne tilstanden vil aldri være sant i utgangspunktet den måten vi snakket om det.

775
00:55:04,000 --> 00:55:08,000
Vi ønsker å gjøre noe før slutten <begynne,

776
00:55:08,000 --> 00:55:13,000
men vi ønsker å gjøre noe mens

777
00:55:13,000 --> 00:55:21,000
begynne ≤ slutt.

778
00:55:21,000 --> 00:55:24,000
>> Det er det reversering av logikken der.

779
00:55:24,000 --> 00:55:27,000
Jeg er skyldig i å lage disse feilene hele tiden.

780
00:55:27,000 --> 00:55:31,000
[Student] Hvorfor må det være mindre enn eller lik?

781
00:55:31,000 --> 00:55:33,000
Fordi husker du det slik at vi fikk

782
00:55:33,000 --> 00:55:36,000
hvor det var bare ett element, og vi var nede,

783
00:55:36,000 --> 00:55:43,000
og vi var ute på akkurat 15 i matrisen vårt?

784
00:55:43,000 --> 00:55:47,000
Og vår begynnelse og vår ende var de samme element.

785
00:55:47,000 --> 00:55:50,000
Vi ønsker å sørge for at vi håndterer den saken.

786
00:55:50,000 --> 00:55:54,000
Hvis vi gjorde en rett mindre enn,

787
00:55:54,000 --> 00:55:58,000
vi ville bare være i stand til å komme ned til en 2-element array.

788
00:55:58,000 --> 00:56:06,000
Når vi kom ned til det siste elementet, hvis det var vår element, ville vi aldri finne det.

789
00:56:06,000 --> 00:56:10,000
Nå her, kan vi gjøre akkurat som du sa.

790
00:56:10,000 --> 00:56:15,000
Vi kan begynne plopping ting rett inn i midten av vår mens loop.

791
00:56:15,000 --> 00:56:20,000
Vi kan plop i midtpunktet vår.

792
00:56:20,000 --> 00:56:24,000
Vi kan ta alle disse hvis uttalelser,

793
00:56:24,000 --> 00:56:30,000
trekke dem ut av denne gjør-mens loop,

794
00:56:30,000 --> 00:56:34,000
plop dem i,

795
00:56:34,000 --> 00:56:39,000
rydde ting opp litt,

796
00:56:39,000 --> 00:56:48,000
og jeg skal gå videre og lagre denne revisjonen.

797
00:56:48,000 --> 00:56:53,000
Og på dette punktet, vi får ganske nær.

798
00:56:53,000 --> 00:56:55,000
Sam.

799
00:56:55,000 --> 00:56:58,000
Jeg tror du må også ha int midtpunktet = størrelse - 1/2.

800
00:56:58,000 --> 00:57:01,000
Fikk den, størrelse - 1/2.

801
00:57:01,000 --> 00:57:05,000
Er det noe annet vi trenger å endre om den linjen?

802
00:57:05,000 --> 00:57:10,000
Det var en god fangst.

803
00:57:10,000 --> 00:57:14,000
>> Hva gjør størrelse? Er vi stadig skiftende størrelse?

804
00:57:14,000 --> 00:57:17,000
For å holde linjen som dette, må vi endre størrelsen.

805
00:57:17,000 --> 00:57:21,000
Vi må endre størrelsen hver gang vi går rundt for loop.

806
00:57:21,000 --> 00:57:25,000
Men husk når vi skulle gjennom vårt eksempel bare litt tidligere,

807
00:57:25,000 --> 00:57:30,000
og vi hadde i begynnelsen på 4

808
00:57:30,000 --> 00:57:33,000
og slutten helt over på 108?

809
00:57:33,000 --> 00:57:35,000
Hvordan gjorde vi beregner midtpunktet?

810
00:57:35,000 --> 00:57:38,000
Brukte vi størrelsen?

811
00:57:38,000 --> 00:57:40,000
Eller vi brukte begynner og slutter i stedet?

812
00:57:40,000 --> 00:57:42,000
Det er forskjellen mellom slutten og begynnelsen.

813
00:57:42,000 --> 00:57:50,000
Nøyaktig, og hvordan akkurat skal jeg skrive det, Charlotte?

814
00:57:50,000 --> 00:57:52,000
Bare ende - begynne.

815
00:57:52,000 --> 00:57:55,000
Du trenger ikke å gjøre det - en

816
00:57:55,000 --> 00:57:58,000
fordi - 1 har blitt tatt i slutten og begynnelsen allerede.

817
00:57:58,000 --> 00:58:00,000
[Nate] Flott, er du helt rett.

818
00:58:00,000 --> 00:58:03,000
Vi trenger ikke å gjøre det - 1 fordi det - en er tatt

819
00:58:03,000 --> 00:58:08,000
og sto for når vi initialisere slutten variabel.

820
00:58:08,000 --> 00:58:11,000
>> Er det noe annet jeg trenger å gjøre syntaktisk å ha denne linjen fornuftig?

821
00:58:11,000 --> 00:58:13,000
[Student] Plus begynne. >> Plus begynne?

822
00:58:13,000 --> 00:58:15,000
[Student] På slutten.

823
00:58:15,000 --> 00:58:20,000
Fordi det er bare beregnet halve lengden.

824
00:58:20,000 --> 00:58:26,000
Du må legge til begynne.

825
00:58:26,000 --> 00:58:31,000
[Nate] Hva ville dette beregne for oss?

826
00:58:31,000 --> 00:58:35,000
Hvis vi tenker slutten på denne aller første iterasjon av loopen,

827
00:58:35,000 --> 00:58:40,000
end kommer til å være i posisjon indeks 7.

828
00:58:40,000 --> 00:58:43,000
Begynne er i posisjon 0.

829
00:58:43,000 --> 00:58:47,000
Husk, vi leter etter enten

830
00:58:47,000 --> 00:58:52,000
posisjon 3 eller posisjon 4.

831
00:58:52,000 --> 00:58:56,000
Hvis vi ser på dette regnestykket, bare gjøre det litt mer konkret,

832
00:58:56,000 --> 00:59:02,000
sette noen tall her, har vi 7, 0,

833
00:59:02,000 --> 00:59:10,000
så 7-0, og deretter / 2

834
00:59:10,000 --> 00:59:19,000
er 3 i heltallsdivisjon, altså.

835
00:59:19,000 --> 00:59:26,000
Deretter trenger vi å deretter legge tilbake vår begynne?

836
00:59:26,000 --> 00:59:28,000
Vi gjør ikke i dette tilfellet.

837
00:59:28,000 --> 00:59:31,000
På den aller første iterasjon, vil det være fint fordi begynne er 0.

838
00:59:31,000 --> 00:59:36,000
Men som vi fremgang, gjør vi egentlig alt bare trenger

839
00:59:36,000 --> 00:59:42,000
end - begynner / 2.

840
00:59:42,000 --> 00:59:46,000
Det er en annen triks her, og det er nemlig en av forrang.

841
00:59:46,000 --> 00:59:49,000
[Student] Trenger vi parentes?

842
00:59:49,000 --> 00:59:53,000
[Nate] Nettopp, og det er fordi hvis vi ikke sette disse parentes,

843
00:59:53,000 --> 00:59:58,000
så denne linjen vil bli tolket i stedet

844
00:59:58,000 --> 01:00:09,000
som (slutten) - (begynne / 2), som vi definitivt ikke ønsker.

845
01:00:09,000 --> 01:00:11,000
Se opp for disse prioriteringsregler.

846
01:00:11,000 --> 01:00:15,000
[Student] Hvorfor er ikke ender det + begynne?

847
01:00:15,000 --> 01:00:17,000
Hvorfor er ikke det ende + begynne?

848
01:00:17,000 --> 01:00:19,000
[Student] Hvorfor er det ikke det?

849
01:00:19,000 --> 01:00:24,000
Hvorfor skulle det være +?

850
01:00:24,000 --> 01:00:26,000
Jeg tror du har rett.

851
01:00:26,000 --> 01:00:28,000
[Student] Fordi det er gjennomsnittet?

852
01:00:28,000 --> 01:00:31,000
[Nate] End + begynne, er du helt rett.

853
01:00:31,000 --> 01:00:34,000
Wow, jeg helt goofed. Du har rett.

854
01:00:34,000 --> 01:00:39,000
Hvis vi gjorde minus, ville vi ønsker å legge til begynne tilbake igjen

855
01:00:39,000 --> 01:00:43,000
I dette tilfellet, du er veldig riktig at vi ønsker å ta gjennomsnittet av de to,

856
01:00:43,000 --> 01:00:45,000
så vi ønsker å legge dem, i motsetning til å trekke dem.

857
01:00:45,000 --> 01:00:49,000
[Student] Det vil også fungere hvis du gjorde ende - begynner / 2 + begynne.

858
01:00:49,000 --> 01:00:55,000
Det ville gjort hvis vi gjør-Jeg tror det.

859
01:00:55,000 --> 01:01:00,000
>> For eksempel, hvis vi var ute på begynne,

860
01:01:00,000 --> 01:01:04,000
og vi flyttet det over her

861
01:01:04,000 --> 01:01:08,000
til 15.

862
01:01:08,000 --> 01:01:12,000
Nå begynne er i 2-stilling.

863
01:01:12,000 --> 01:01:15,000
End er ved posisjon 7.

864
01:01:15,000 --> 01:01:21,000
Hvis vi trekker dem, får vi 5.

865
01:01:21,000 --> 01:01:24,000
Dele det med 2, får vi to.

866
01:01:24,000 --> 01:01:27,000
Og så legger vi til 2 tilbake i,

867
01:01:27,000 --> 01:01:30,000
og som får oss til 4. plass,

868
01:01:30,000 --> 01:01:33,000
som er rett her, som er midtpunktet.

869
01:01:33,000 --> 01:01:36,000
[Student] Trenger vi å ta vare på emballasjen?

870
01:01:36,000 --> 01:01:39,000
I hvilken forstand trenger vi å ta vare på innpakning?

871
01:01:39,000 --> 01:01:43,000
Hvis summen eller forskjellen mellom

872
01:01:43,000 --> 01:01:45,000
avhengig av hvordan vi gjør det er ikke et partall.

873
01:01:45,000 --> 01:01:49,000
Deretter datamaskinen blir forvirret om når det er 2,5;

874
01:01:49,000 --> 01:01:52,000
flytter du til venstre eller til høyre for å avgjøre hva som er midtpunktet?

875
01:01:52,000 --> 01:01:54,000
Fikk den.

876
01:01:54,000 --> 01:01:56,000
Det viser seg at med heltallsdivisjon,

877
01:01:56,000 --> 01:01:59,000
vi ikke noen gang får disse flyttall.

878
01:01:59,000 --> 01:02:01,000
Vi får aldri desimal.

879
01:02:01,000 --> 01:02:04,000
Det er helt forkastet.

880
01:02:04,000 --> 01:02:08,000
Hvis du har dele en datamaskin to int variabler,

881
01:02:08,000 --> 01:02:11,000
og en er 7, og den andre er 2,

882
01:02:11,000 --> 01:02:13,000
du vil ikke få 3,5 som resultat.

883
01:02:13,000 --> 01:02:16,000
Det vil få 3.

884
01:02:16,000 --> 01:02:19,000
Resten vil bli forkastet, så det er effektivt avrunding-

885
01:02:19,000 --> 01:02:24,000
ikke en runde, men snarere en etasje, hvis dere er kjent med at det i matematikk,

886
01:02:24,000 --> 01:02:27,000
hvor du helt forkaste desimal,

887
01:02:27,000 --> 01:02:31,000
og så du egentlig avkorting det ned til nærmeste

888
01:02:31,000 --> 01:02:33,000
Hele posisjon, til nærmeste hele tall.

889
01:02:33,000 --> 01:02:38,000
[Student] Men så det er problematisk fordi hvis du har en rekke av 7 elementer

890
01:02:38,000 --> 01:02:43,000
deretter som tar automatisk den tredje elementet ut av midtpunktet istedenfor 4..

891
01:02:43,000 --> 01:02:46,000
Hvordan håndterer vi det?

892
01:02:46,000 --> 01:02:49,000
Det er problematisk fordi hvis vi hadde en rekke 7,

893
01:02:49,000 --> 01:02:54,000
det skulle plukke den 3. i stedet for fjerde.

894
01:02:54,000 --> 01:02:56,000
Kan du forklare litt mer?

895
01:02:56,000 --> 01:02:59,000
[Student] Fordi hvis du har 7 elementer deretter fjerde element

896
01:02:59,000 --> 01:03:04,000
ville være midtpunktet, ikke sant?

897
01:03:04,000 --> 01:03:07,000
Husk din kommentar om å være null indeksert, skjønt.

898
01:03:07,000 --> 01:03:10,000
[Student] Yeah, så i posisjon 3. Det ville være midtpunktet.

899
01:03:10,000 --> 01:03:12,000
Ja.

900
01:03:12,000 --> 01:03:16,000
Oh, okay. Jeg ser hva du mener.

901
01:03:16,000 --> 01:03:19,000
Det er litt rart, som vi blir vant til dette hele oppfatningen av

902
01:03:19,000 --> 01:03:22,000
bli kvitt desimaler.

903
01:03:22,000 --> 01:03:26,000
Det er et stort poeng.

904
01:03:26,000 --> 01:03:30,000
La oss avslutte dette.

905
01:03:30,000 --> 01:03:32,000
Vi har beregnet vår midtpunktet.

906
01:03:32,000 --> 01:03:37,000
>> Vi tester for å se om vår nålen er lik den midterste verdien.

907
01:03:37,000 --> 01:03:41,000
Vi skriver at vi fant det, men egentlig, hva vi ønsker å gjøre i denne situasjonen?

908
01:03:41,000 --> 01:03:46,000
Vi har funnet det, så vi ønsker å la den som ringer vet at vi fant det.

909
01:03:46,000 --> 01:03:49,000
Vi har fått en funksjon som er en boolean skrevet funksjon.

910
01:03:49,000 --> 01:03:54,000
Måten vi signalisere til den som ringer av vår funksjon som vi er klar til å gå

911
01:03:54,000 --> 01:03:58,000
er vi sier, "Hei, dette er sant."

912
01:03:58,000 --> 01:04:00,000
Hvordan ville vi gjøre det, Kevin?

913
01:04:00,000 --> 01:04:02,000
Du nikker hodet. >> [Kevin] Legg return true.

914
01:04:02,000 --> 01:04:06,000
[Nate] Akkurat, return true.

915
01:04:06,000 --> 01:04:12,000
Nå, hvis det ikke er like, hvordan ville vi ser på den venstre halvdelen?

916
01:04:12,000 --> 01:04:16,000
Noen ideer?

917
01:04:16,000 --> 01:04:18,000
Stella, noen ideer?

918
01:04:18,000 --> 01:04:21,000
Du trenger for å sette en ny posisjon for slutten.

919
01:04:21,000 --> 01:04:23,000
Ja.

920
01:04:23,000 --> 01:04:29,000
Så vi må gjøre stilling midtpunktet - slutten.

921
01:04:29,000 --> 01:04:33,000
Flott.

922
01:04:33,000 --> 01:04:36,000
Vi trenger å sette en ny stilling for slutten

923
01:04:36,000 --> 01:04:38,000
å se på den venstre halvdelen.

924
01:04:38,000 --> 01:04:41,000
Dette var hva vi snakket om før der

925
01:04:41,000 --> 01:04:44,000
Jeg holde går tilbake til dette eksemplet.

926
01:04:44,000 --> 01:04:50,000
Jeg har den begynner her, og da har jeg til slutt hele veien hit.

927
01:04:50,000 --> 01:04:53,000
>> Igjen, hvis vi leter etter 15, og vår midtpunktet er på 16,

928
01:04:53,000 --> 01:04:56,000
og vi innser, "Oops, er 16 større.

929
01:04:56,000 --> 01:04:59,000
Vi ønsker å flytte til venstre halvdel. "

930
01:04:59,000 --> 01:05:02,000
Vi vil deretter flytte slutt på 15,

931
01:05:02,000 --> 01:05:06,000
og vi gjør det ved å ta en bort fra midtpunktet

932
01:05:06,000 --> 01:05:09,000
og innstillingen som ny slutt.

933
01:05:09,000 --> 01:05:12,000
Likeledes, hvis vi ønsker å se på høyre halvdel, hvordan ville vi gjøre det?

934
01:05:12,000 --> 01:05:14,000
Har du en idé?

935
01:05:14,000 --> 01:05:22,000
[Student] Du har nettopp satt begynne å midtpunktet + 1.

936
01:05:22,000 --> 01:05:24,000
[Nate] Great.

937
01:05:24,000 --> 01:05:29,000
Og nå i tilfelle at vi ikke finner noe,

938
01:05:29,000 --> 01:05:32,000
får det tatt vare på for oss?

939
01:05:32,000 --> 01:05:36,000
Daniel, betyr det bli tatt vare på for oss?

940
01:05:36,000 --> 01:05:38,000
[Daniel] Nei

941
01:05:38,000 --> 01:05:40,000
[Nate] Hvis vi gjør det gjennom hele matrisen, og vi finner ikke noe,

942
01:05:40,000 --> 01:05:42,000
hvor ville det bli tatt vare på, eller skal vi ta vare på den?

943
01:05:42,000 --> 01:05:44,000
[Daniel] while tilstand.

944
01:05:44,000 --> 01:05:48,000
[Nate] Yeah, mens tilstanden, akkurat.

945
01:05:48,000 --> 01:05:51,000
Det vil ta vare på å gå gjennom hele matrisen hvis vi ikke finner noe.

946
01:05:51,000 --> 01:05:53,000
Dette mens loop vil ende.

947
01:05:53,000 --> 01:05:56,000
Vi vil aldri møtt denne tilstanden,

948
01:05:56,000 --> 01:06:03,000
og vi kan returnere falsk.

949
01:06:03,000 --> 01:06:10,000
Vi kan også la dette hvis du er i her som dette

950
01:06:10,000 --> 01:06:14,000
fordi hvis dette hvis setningen er sann,

951
01:06:14,000 --> 01:06:16,000
og vår funksjon kommer tilbake,

952
01:06:16,000 --> 01:06:21,000
og så vi vil i hovedsak avbryte denne funksjonen på dette punktet

953
01:06:21,000 --> 01:06:24,000
når vi kommer tilbake sant.

954
01:06:24,000 --> 01:06:28,000
Men hva skjer med denne strukturen her?

955
01:06:28,000 --> 01:06:34,000
Vil dette fungere helt, eller er det noen logisk brist i det?

956
01:06:34,000 --> 01:06:37,000
>> Det er noen logisk brist i det, med måten det er satt opp.

957
01:06:37,000 --> 01:06:40,000
Hva kan det være?

958
01:06:40,000 --> 01:06:43,000
[Student] Hvorfor trenger du det - og + 1s?

959
01:06:43,000 --> 01:06:47,000
Som setter vår rekke opp til å bli vår nye venstre halvdel og høyre halvdel.

960
01:06:47,000 --> 01:06:51,000
[Student] Men hvorfor kunne ikke du gjøre det uten - 1s og + 1s?

961
01:06:51,000 --> 01:06:53,000
[Nate] Vi kunne sette den lik midtpunktet?

962
01:06:53,000 --> 01:07:04,000
Hva kan være problematisk om det?

963
01:07:04,000 --> 01:07:08,000
[Student] Jeg antar det er ineffektivt fordi du sjekker en verdi som allerede er kontrollert.

964
01:07:08,000 --> 01:07:11,000
[Nate] Akkurat, så Sam er helt riktig.

965
01:07:11,000 --> 01:07:15,000
Hvis du setter enden og begynner lik midtpunktet

966
01:07:15,000 --> 01:07:18,000
i stedet for - 1 og + 1 reflektert,

967
01:07:18,000 --> 01:07:22,000
på et tidspunkt i fremtiden vil vi ende opp med å sjekke midtpunktet igjen.

968
01:07:22,000 --> 01:07:26,000
[Student] Jeg startet pset, og da jeg hadde noe sånt

969
01:07:26,000 --> 01:07:30,000
hvor jeg glemte + 1, og det ble sittende fast i en uendelig loop.

970
01:07:30,000 --> 01:07:34,000
Høyre, fordi på et tidspunkt du aldri kommer til å få begynne og slutte

971
01:07:34,000 --> 01:07:39,000
å faktisk overlappe.

972
01:07:39,000 --> 01:07:41,000
Cool.

973
01:07:41,000 --> 01:07:44,000
Det er enda en logisk brist, og det er at dette bør definitivt være

974
01:07:44,000 --> 01:07:48,000
en else if.

975
01:07:48,000 --> 01:07:55,000
Hvorfor kan det være?

976
01:07:55,000 --> 01:07:59,000
>> Grunnen er hvis det ikke er en annen hvis-så du det, Kevin?

977
01:07:59,000 --> 01:08:02,000
[Kevin] Yeah, fordi du endrer endepunktet.

978
01:08:02,000 --> 01:08:05,000
[Nate] Nettopp.

979
01:08:05,000 --> 01:08:07,000
Vi endrer endepunktet,

980
01:08:07,000 --> 01:08:12,000
og hvis det er skrevet slik-vi gjør mellomrom mellom-

981
01:08:12,000 --> 01:08:14,000
det vil sjekke denne saken.

982
01:08:14,000 --> 01:08:18,000
Dette tilfellet, hvis det lykkes, vil den avbryte ut av funksjon.

983
01:08:18,000 --> 01:08:21,000
Da vil det se dette neste sak,

984
01:08:21,000 --> 01:08:24,000
og dersom dette lykkes, vil den justere endepunktet,

985
01:08:24,000 --> 01:08:28,000
og da vil det fortsette og sjekke dette tilfellet.

986
01:08:28,000 --> 01:08:31,000
Men på dette punktet, vet vi ikke vil at den skal fortsette å kontrollere.

987
01:08:31,000 --> 01:08:35,000
Heldigvis har vi ikke tilbakestille midtpunktet her,

988
01:08:35,000 --> 01:08:39,000
og vi vet at denne saken ikke vil lykkes.

989
01:08:39,000 --> 01:08:44,000
Men vi definitivt ønsker å sette annet hvis i det

990
01:08:44,000 --> 01:08:48,000
selv om det kanskje i dette tilfellet

991
01:08:48,000 --> 01:08:52,000
siden vi ikke justerer midtpunktet, ville det gjøre en forskjell?

992
01:08:52,000 --> 01:08:54,000
Nei, fordi disse sakene er alle eksklusive.

993
01:08:54,000 --> 01:08:58,000
Igjen, min feil.

994
01:08:58,000 --> 01:09:01,000
Vi har ikke, tror jeg, trenger dette else if.

995
01:09:01,000 --> 01:09:05,000
Vi kan gi det en sjanse og kjøre den og se hva som skjer.

996
01:09:05,000 --> 01:09:08,000
Building, det oppstod en feil.

997
01:09:08,000 --> 01:09:12,000
Det er nok fordi jeg forlot disse b-og e er her.

998
01:09:12,000 --> 01:09:14,000
Har jeg noe mer av dem opp på toppen?

999
01:09:14,000 --> 01:09:16,000
Det ser ikke ut som det.

1000
01:09:16,000 --> 01:09:20,000
Vi zoome ut, bygge,

1001
01:09:20,000 --> 01:09:24,000
der det går, så nå hvis vi søker etter 15,

1002
01:09:24,000 --> 01:09:28,000
Ja.

1003
01:09:28,000 --> 01:09:30,000
La meg zoome inn

1004
01:09:30,000 --> 01:09:33,000
15, ja. Vi kan kjøre den på nytt.

1005
01:09:33,000 --> 01:09:36,000
Opplasting kildekode, bygge, kjøre.

1006
01:09:36,000 --> 01:09:41,000
Vi kan søke etter noe sånt 13,

1007
01:09:41,000 --> 01:09:45,000
og vi ikke får noe å skrive ut, så det er ikke å finne det for oss.

1008
01:09:45,000 --> 01:09:51,000
Det er flott, fordi det ikke er i vår liste.

1009
01:09:51,000 --> 01:09:53,000
>> Vi er nå ute av tiden.

1010
01:09:53,000 --> 01:09:55,000
Det kommer til å være det for denne uken.

1011
01:09:55,000 --> 01:10:00,000
Takk for at du deltar, og se deg senere.

1012
01:10:00,000 --> 01:10:02,000
>> [CS50.TV]