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

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
>> Okay, lad os komme i gang.

5
00:00:10,000 --> 00:00:13,000
Velkommen til uge 4 af CS50.

6
00:00:13,000 --> 00:00:19,000
Hvis du fyre åbner en webbrowser og åbne op Pset 3,

7
00:00:19,000 --> 00:00:23,000
Scramble med CS50, vil vi begynde at gå

8
00:00:23,000 --> 00:00:26,000
gennem den del af spørgsmål her.

9
00:00:26,000 --> 00:00:32,000
Ligesom sidste uge, vil vi arbejde i CS50 Spaces,

10
00:00:32,000 --> 00:00:35,000
hvis du også vil trække det op så godt,

11
00:00:35,000 --> 00:00:43,000
og hvis du gå videre og besøge dette link, som jeg har fået heroppe på toppen.

12
00:00:43,000 --> 00:00:45,000
Det er tid til at komme i gang.

13
00:00:45,000 --> 00:00:51,000
Vi har fået vores lille hi-program her. Intet crazy.

14
00:00:51,000 --> 00:00:55,000
En af de første ting, jeg vil gøre med jer i dag er at gå over et par 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 fornemmelse for, hvilke former for kode personale skriver,

17
00:01:03,000 --> 00:01:07,000
hvad slags kode andre studerende skriver,

18
00:01:07,000 --> 00:01:10,000
og har du tage et kig på det, fordi jeg ved, det er underligt

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

20
00:01:14,000 --> 00:01:18,000
på din egen version, nogle gange, men det er nyttigt at se, hvordan andre mennesker gjorde det,

21
00:01:18,000 --> 00:01:22,000
især dem, der er flot.

22
00:01:22,000 --> 00:01:27,000
For det meste, jeg var virkelig imponeret over de løsninger, som du fyre produceret.

23
00:01:27,000 --> 00:01:31,000
Jeg har endnu ikke begyndt at se på dit problem Set 2s, men hvis de er noget som den første,

24
00:01:31,000 --> 00:01:34,000
det betyder noget men gode ting.

25
00:01:34,000 --> 00:01:40,000
>> Hvis du ser på mine ændringer, lad os starte helt ned på revision 1,

26
00:01:40,000 --> 00:01:47,000
og vi kommer til at tage et hurtigt kig på en Mario løsning.

27
00:01:47,000 --> 00:01:54,000
Hvis du trækker denne op, disse programmer som vi kommer til at præsentere, er korrekte.

28
00:01:54,000 --> 00:01:56,000
Der var ikke rigtighed problemer med disse problemer, men snarere,

29
00:01:56,000 --> 00:01:59,000
vi ønsker at tale lidt om de forskellige design spørgsmål

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

31
00:02:03,000 --> 00:02:08,000
En af de ting, der var interessant om løsningen

32
00:02:08,000 --> 00:02:11,000
er, at den har anvendt denne nye konstruktion kaldet pund definere,

33
00:02:11,000 --> 00:02:15,000
undertiden også betegnet som en hash definere.

34
00:02:15,000 --> 00:02:18,000
Lad mig zoome ind på det her.

35
00:02:18,000 --> 00:02:24,000
A # define giver dig mulighed for at give navne til disse numre i din program.

36
00:02:24,000 --> 00:02:28,000
I dette tilfælde, den maksimale højde af en pyramide i Mario

37
00:02:28,000 --> 00:02:34,000
blev 23 og snarere end at lægge 23 i min kode-

38
00:02:34,000 --> 00:02:37,000
vi vil gerne henvise til, at så hård kodning 23 -

39
00:02:37,000 --> 00:02:43,000
i stedet dette giver navnet MAX_HEIGHT til dette nummer,

40
00:02:43,000 --> 00:02:48,000
så at hernede i min do-while-løkke

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

42
00:02:51,000 --> 00:02:55,000
i stedet for at sætte nummer 23 i.

43
00:02:55,000 --> 00:02:57,000
[Student] Hvad er fordelen ved at gøre det?

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

45
00:02:59,000 --> 00:03:03,000
Den ene er læsbarheden.

46
00:03:03,000 --> 00:03:08,000
En fordel ved at bruge denne # define er læsbarheden.

47
00:03:08,000 --> 00:03:11,000
Når jeg læser denne kode, kan jeg se, hvad der foregår.

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

49
00:03:15,000 --> 00:03:19,000
for højden er <0, hvilket vi også kunne have defineret

50
00:03:19,000 --> 00:03:22,000
at være en minimumhøjde eller en min højde.

51
00:03:22,000 --> 00:03:25,000
Den anden fordel er, at jeg derefter kan læse resten af ​​linien for at se

52
00:03:25,000 --> 00:03:30,000
at vi også er kontrol for at sikre, at højden ikke er større end max højde,

53
00:03:30,000 --> 00:03:35,000
fordi vi kommer til at fortsætte, mens højden er større end max højde.

54
00:03:35,000 --> 00:03:40,000
Den anden fordel er, hvis jeg zoome ud en lille smule her-

55
00:03:40,000 --> 00:03:49,000
hvis jeg køre dette program, og jeg kører den, sige, med 23 lige nu,

56
00:03:49,000 --> 00:03:52,000
det vil udskrive alle 23 rækker ligesom det.

57
00:03:52,000 --> 00:03:54,000
Men sige jeg ønskede at ændre maks. højde,

58
00:03:54,000 --> 00:03:57,000
og nu vil jeg gerne begrænse den maksimale højde af pyramider

59
00:03:57,000 --> 00:04:06,000
at være kun sige, mand, det 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 lad os sige, vi ønskede at indstille det lig med 10.

62
00:04:18,000 --> 00:04:22,000
Nu på dette punkt, var alt jeg havde at gøre ændre det i denne ene sted.

63
00:04:22,000 --> 00:04:27,000
Jeg kan genkompilere koden, og nu hvis jeg prøver og skrive i 12,

64
00:04:27,000 --> 00:04:30,000
Det vil tilskynde mig igen.

65
00:04:30,000 --> 00:04:33,000
I dette tilfælde er vi kun bruger MAX_HEIGHT gang.

66
00:04:33,000 --> 00:04:37,000
Det er ikke det store af en besvær at gå i

67
00:04:37,000 --> 00:04:40,000
og ændre det i while-løkken, hvis du har brug for.

68
00:04:40,000 --> 00:04:44,000
Men i programmer, hvor du refererer til det samme magiske tal

69
00:04:44,000 --> 00:04:47,000
igen og igen, denne # define mekanisme er virkelig praktisk

70
00:04:47,000 --> 00:04:52,000
fordi du bare ændre det en gang i toppen af ​​filen, det er typisk, hvor du lægger dem-

71
00:04:52,000 --> 00:04:57,000
og ændringen siver ned gennem resten af ​​filen.

72
00:04:57,000 --> 00:05:02,000
>> Andre ting, jeg ønskede at bemærke i denne opgave, som jeg troede kiggede virkelig rart,

73
00:05:02,000 --> 00:05:05,000
den ene var navngivningen af ​​variablerne.

74
00:05:05,000 --> 00:05:14,000
Du kan se her, at vi har fået heltalsvariabler kaldet række og kaldte højde.

75
00:05:14,000 --> 00:05:20,000
Spaces, hashes, det hjælper at gøre koden lidt mere læselig,

76
00:05:20,000 --> 00:05:25,000
gør det lidt mere forståeligt, hvad der rent faktisk sker.

77
00:05:25,000 --> 00:05:31,000
Dette er i modsætning til anvendelse af fx tilfældige bogstaver

78
00:05:31,000 --> 00:05:35,000
eller blot volapyk helt.

79
00:05:35,000 --> 00:05:39,000
En sidste ting jeg vil påpege, er, at der i for-løkker,

80
00:05:39,000 --> 00:05:45,000
ofte disse iterator variabler, disse tællere, du bruger i din for sløjfer,

81
00:05:45,000 --> 00:05:51,000
Det er standard og konventionelt at starte dem med enten i og derefter j og derefter k

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

83
00:05:54,000 --> 00:05:56,000
og dette er blot en konvention.

84
00:05:56,000 --> 00:05:58,000
Der er masser af konventioner.

85
00:05:58,000 --> 00:06:00,000
Det afhænger af programmeringssprog, du bruger.

86
00:06:00,000 --> 00:06:04,000
Men i C, vi starter typisk med i.

87
00:06:04,000 --> 00:06:08,000
Det giver ikke mening at bruge, siger, a eller b

88
00:06:08,000 --> 00:06:13,000
afhængigt af situationen.

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

90
00:06:15,000 --> 00:06:25,000
Hvis du nu trække op Revision 2, vil du se en anden Mario,

91
00:06:25,000 --> 00:06:29,000
og dette svarer til den anden, som vi lige har set,

92
00:06:29,000 --> 00:06:32,000
men det gør noget lidt sejt.

93
00:06:32,000 --> 00:06:38,000
Hvis vi ser på denne sektion lige her inde i den indre for-løkke,

94
00:06:38,000 --> 00:06:44,000
de bruger nogle skøre søger syntaks her til højre på denne linie.

95
00:06:44,000 --> 00:06:47,000
Dette kaldes en ternær operatør.

96
00:06:47,000 --> 00:06:53,000
Det er en hvis ellers erklæring kondenseret til én linje.

97
00:06:53,000 --> 00:06:57,000
Betingelsen er denne del i parentes.

98
00:06:57,000 --> 00:07:05,000
Det er svarer til at sige, om j <højde - i - 1.

99
00:07:05,000 --> 00:07:10,000
Og derefter hvad indholdet af det, hvis blok ville være, er den plads

100
00:07:10,000 --> 00:07:16,000
og derefter indholdet af, hvad andet ville være, er dette #.

101
00:07:16,000 --> 00:07:20,000
Det er væsentligt at tildele en plads til denne variabel.

102
00:07:20,000 --> 00:07:24,000
Det er at sætte en plads i indholdet af blokken variable,

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

104
00:07:29,000 --> 00:07:32,000
derefter blokken variabel bliver dette #.

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

106
00:07:37,000 --> 00:07:43,000
og udskrive alt ud i slutningen denne løsning udskriver det et tegn ad gangen.

107
00:07:43,000 --> 00:07:48,000
Pretty cool.

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

109
00:07:53,000 --> 00:07:58,000
Nu, hvis vi ser på grådige, denne første løsning

110
00:07:58,000 --> 00:08:00,000
bruger disse # definerer ganske lidt.

111
00:08:00,000 --> 00:08:06,000
Vi har fået en konstant defineret for hver af de forskellige numre i dette program.

112
00:08:06,000 --> 00:08:12,000
Vi har fået en til cent per dollar, en for kvartaler, dimes, nickels og øre,

113
00:08:12,000 --> 00:08:15,000
og nu, hvis vi rulle ned og læse koden,

114
00:08:15,000 --> 00:08:22,000
kan vi se en standard gør-while-løkke udskrivning alt ud.

115
00:08:22,000 --> 00:08:25,000
Kind of det springende punkt af dette problem var at indse, at

116
00:08:25,000 --> 00:08:29,000
du har brug for at konvertere svømmeren, at du læser i fra brugeren til et heltal

117
00:08:29,000 --> 00:08:32,000
præcist gør det matematik, og det er fordi

118
00:08:32,000 --> 00:08:36,000
med kommatal, ligesom vi talte om i foredrag kortvarigt

119
00:08:36,000 --> 00:08:41,000
Det er ikke muligt præcist at repræsentere hver enkelt værdi på antallet linje

120
00:08:41,000 --> 00:08:47,000
fordi der er uendeligt mange værdier mellem 3 og, siger, 3,1 selv.

121
00:08:47,000 --> 00:08:54,000
Du kan få 3,01 og 3,001 og 3,0001, og du kan holde ud.

122
00:08:54,000 --> 00:09:00,000
Det viser sig, når du arbejder med penge, du ofte vil konvertere det

123
00:09:00,000 --> 00:09:05,000
i heltal format, så du ikke mister øre og den slags ting.

124
00:09:05,000 --> 00:09:09,000
Gør det og afrunding var nøglen.

125
00:09:09,000 --> 00:09:14,000
Denne opløsning anvendes en helt enkel, stor algoritme,

126
00:09:14,000 --> 00:09:17,000
som dekrementeres antallet af cents tilbage, først af kvartaler,

127
00:09:17,000 --> 00:09:19,000
derefter ved dimes, derefter ved nickels, derefter ved øre,

128
00:09:19,000 --> 00:09:24,000
og tilsætning til antallet af mønter hver gang.

129
00:09:24,000 --> 00:09:31,000
>> En anden løsning, som vi vil se, da jeg zoome ud og gå til revision 4,

130
00:09:31,000 --> 00:09:40,000
havde en meget lignende begyndelse, men i stedet brugt div og mod

131
00:09:40,000 --> 00:09:44,000
lige herovre at beregne antallet af cents.

132
00:09:44,000 --> 00:09:50,000
Dette er antallet af sider er lig med antallet af cents divideret med 25,

133
00:09:50,000 --> 00:09:53,000
og grunden til at dette virker, er fordi vi laver heltalsdivision,

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

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

136
00:10:02,000 --> 00:10:05,000
Det er virkelig afhænger af.

137
00:10:05,000 --> 00:10:08,000
[Student] Du kommentere mere end kode lige her.

138
00:10:08,000 --> 00:10:16,000
Ja, og så er der en flok af varierende filosofier om dette.

139
00:10:16,000 --> 00:10:21,000
Min personlige filosofi er, at din kode er virkelig sandheden,

140
00:10:21,000 --> 00:10:24,000
ligesom din kode er, hvad der faktisk bliver kørt på computeren,

141
00:10:24,000 --> 00:10:29,000
og så din kode bør være så overskueligt som muligt for ikke nødvendiggøre så mange kommentarer.

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

143
00:10:33,000 --> 00:10:38,000
eller algoritmisk, det er godt at kommentere dem, så du kan

144
00:10:38,000 --> 00:10:43,000
tilføje en ekstra dimension, et ekstra lag til en anden læser din kode.

145
00:10:43,000 --> 00:10:49,000
I disse løsninger, de ofte er kommenteret hårdere, bare fordi

146
00:10:49,000 --> 00:10:52,000
Vi ønsker at være i stand til at distribuere dem og have folk samle dem op

147
00:10:52,000 --> 00:10:56,000
og læse dem temmelig nemt.

148
00:10:56,000 --> 00:11:05,000
Men absolut, ville jeg enig i, at det er tungt.

149
00:11:05,000 --> 00:11:07,000
[Student] Men når de er i tvivl, gå tungere?

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

151
00:11:10,000 --> 00:11:17,000
Nogle mennesker vil undertiden sige return 0 eller sådan noget.

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
Det er klart det er, hvad der sker.

154
00:11:22,000 --> 00:11:25,000
Jeg har ikke brug for engelsk at fortælle mig det.

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

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

157
00:11:32,000 --> 00:11:35,000
det er ikke at gøre forskellen mellem kommentere point eller ej.

158
00:11:35,000 --> 00:11:41,000
Den slags 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 tidspunkt, lad os begynde at arbejde på problemet Set 3 afsnit med spørgsmål.

161
00:11:48,000 --> 00:11:52,000
Hvis du fyre trække denne op igen,

162
00:11:52,000 --> 00:11:55,000
som med sidste uge, vi ikke kommer til at se shorts i dette afsnit.

163
00:11:55,000 --> 00:12:00,000
Vi vil lade jer gøre det på din egen tid og taler om spørgsmålene.

164
00:12:00,000 --> 00:12:05,000
Men nu i dette afsnit vil vi bruge lidt mere tid

165
00:12:05,000 --> 00:12:11,000
taler om mindre af de kodende basics

166
00:12:11,000 --> 00:12:15,000
som vi gjorde i sidste uge, og i stedet vil vi fokusere mere på

167
00:12:15,000 --> 00:12:22,000
en lille smule mere af teorien, så at tale om binær søgning og derefter sortering.

168
00:12:22,000 --> 00:12:27,000
Fra dem af jer der har fulgt sammen med foredrag,

169
00:12:27,000 --> 00:12:30,000
kan nogen give mig et resumé af, hvad forskellen er

170
00:12:30,000 --> 00:12:35,000
mellem binær søgning og lineær søgning?

171
00:12:35,000 --> 00:12:37,000
Hvad sker der? Sure.

172
00:12:37,000 --> 00:12:42,000
Lineære søgning søger gennem hvert element i den sorterede liste

173
00:12:42,000 --> 00:12:45,000
én efter én efter én efter én efter én,

174
00:12:45,000 --> 00:12:50,000
og binær søgning opdeler listen i 2 grupper,

175
00:12:50,000 --> 00:12:57,000
checks Hvis tasterne værdi, du søger efter, er større end eller mindre end midtpunktet værdi

176
00:12:57,000 --> 00:13:00,000
at du lige har fundet, og hvis det er mindre end, det går med den nederste liste

177
00:13:00,000 --> 00:13:03,000
og derefter fordeler det igen, gør det samme funktion

178
00:13:03,000 --> 00:13:07,000
hele vejen ned, indtil den finder midtpunktet til at være lig med værdien selv.

179
00:13:07,000 --> 00:13:10,000
Right.

180
00:13:10,000 --> 00:13:12,000
>> Hvorfor skal vi pleje?

181
00:13:12,000 --> 00:13:20,000
Hvorfor taler vi om binær søgning kontra lineær søgning?

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

183
00:13:22,000 --> 00:13:24,000
Binary er meget hurtigere, så hvis du fordobler størrelsen af ​​problemet

184
00:13:24,000 --> 00:13:27,000
det tager et skridt frem end dobbelt så mange.

185
00:13:27,000 --> 00:13:29,000
Præcis.

186
00:13:29,000 --> 00:13:31,000
Det er en stor svar.

187
00:13:31,000 --> 00:13:36,000
Lineær søgning i høj grad at kontrollere et element ad gangen,

188
00:13:36,000 --> 00:13:39,000
og da vi så på den første dag af forelæsning

189
00:13:39,000 --> 00:13:42,000
da David gik gennem hans telefonbog eksempel

190
00:13:42,000 --> 00:13:45,000
og revet ud én side af telefonbogen på et tidspunkt

191
00:13:45,000 --> 00:13:47,000
og holdes at gøre det igen og igen og igen,

192
00:13:47,000 --> 00:13:51,000
det kommer til at tage ham en virkelig lang tid at finde nogen i telefonbogen,

193
00:13:51,000 --> 00:13:55,000
medmindre, selvfølgelig, han ledte efter nogen i begyndelsen af ​​alfabetet.

194
00:13:55,000 --> 00:14:00,000
Med binær søgning, kan du gå meget hurtigere,

195
00:14:00,000 --> 00:14:05,000
og det er ikke bare dobbelt så hurtigt eller 3 gange så hurtigt eller 4 gange så hurtigt.

196
00:14:05,000 --> 00:14:13,000
Men problemet bliver mindre og mindre og mindre meget hurtigere.

197
00:14:13,000 --> 00:14:17,000
For at illustrere dette, vil vi begynde at tale om, hvad der foregår

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

199
00:14:21,000 --> 00:14:27,000
Problemet ved hånden er, at hvis jeg har en bred vifte af numre,

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

201
00:14:40,000 --> 00:14:47,000
og derefter på 9 med et ton af 0'erne efter det,

202
00:14:47,000 --> 00:14:52,000
Vi ønsker at være i stand til at regne ud, virkelig hurtigt, hvad der er i

203
00:14:52,000 --> 00:14:57,000
denne række af tal.

204
00:14:57,000 --> 00:15:00,000
Jeg ved, at dette virker lidt fjollet og lidt konstruerede,

205
00:15:00,000 --> 00:15:02,000
fordi lige nu er det.

206
00:15:02,000 --> 00:15:05,000
Vi har et array, der ikke har mange elementer i det,

207
00:15:05,000 --> 00:15:08,000
og hvis jeg spørger en af ​​jer til at finde ud af, hvorvidt

208
00:15:08,000 --> 00:15:11,000
23 er i array, kan du gøre det temmelig hurtigt

209
00:15:11,000 --> 00:15:16,000
blot ved et blik på dette og fortæller mig ja eller nej.

210
00:15:16,000 --> 00:15:20,000
Den analoge at overveje, er forestille sig, hvis det var, siger,

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

212
00:15:27,000 --> 00:15:31,000
Selvfølgelig kan du gøre kommandoen F eller kontrol F og se noget op.

213
00:15:31,000 --> 00:15:33,000
Du kan også bruge filtre og eftersøgningen kram,

214
00:15:33,000 --> 00:15:37,000
men hvis du skulle kigge igennem denne fil linje for linje for linje,

215
00:15:37,000 --> 00:15:40,000
det ville tage dig lang tid at finde den.

216
00:15:40,000 --> 00:15:42,000
Det er lidt ligesom i telefonbogen eksempel også, hvor

217
00:15:42,000 --> 00:15:44,000
ingen ser gennem en telefonbog én side ad gangen.

218
00:15:44,000 --> 00:15:47,000
Typisk, de åbne den til midten,

219
00:15:47,000 --> 00:15:50,000
eller i tilfælde af en masse telefonbøger og ordbøger, hvor

220
00:15:50,000 --> 00:15:54,000
du rent faktisk har det indtastet på det første bogstav,

221
00:15:54,000 --> 00:16:01,000
du skifte til det første bogstav og åbne og begynde at gå igennem der.

222
00:16:01,000 --> 00:16:03,000
>> Mind mig om dit navn igen. >> Sam.

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

224
00:16:05,000 --> 00:16:11,000
Ligesom Sam sagde, at lineær søgeproces vil være virkelig langsom,

225
00:16:11,000 --> 00:16:15,000
og i stedet med binær søgning, er den måde, det fungerer som

226
00:16:15,000 --> 00:16:21,000
hver gang vi går igennem en iteration af vores søgning algoritme,

227
00:16:21,000 --> 00:16:27,000
vi kommer til at opdele listen i halve, det væsentlige,

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å den næste iteration af løkken, vil vi dele det igen

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 bliver mindre og mindre

232
00:16:48,000 --> 00:16:55,000
fordi vi holder kassere halvdel af listen hver eneste gang.

233
00:16:55,000 --> 00:16:59,000
Hvordan virker dette skille arbejde?

234
00:16:59,000 --> 00:17:05,000
Ligesom en påmindelse, hvad vi vil gøre, hvis vi var en computer

235
00:17:05,000 --> 00:17:11,000
og vi var, siger, at søge efter nummer 5 i denne liste

236
00:17:11,000 --> 00:17:15,000
er, at vi ville vælge et nummer i midten.

237
00:17:15,000 --> 00:17:26,000
I midten af ​​denne liste, fordi der er 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 numre,

238
00:17:26,000 --> 00:17:32,000
vi ville vælge det ønskede nummer enten ved den 4. position eller på 5th position,

239
00:17:32,000 --> 00:17:38,000
og vi ville kalde det midt i vores liste.

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

241
00:17:42,000 --> 00:17:51,000
Så, ligesom Sam sagde, vil vi prøve at se, hvis dette antal er lig

242
00:17:51,000 --> 00:17:59,000
til det antal, som vi ønsker at få eller vores ønskede nummer.

243
00:17:59,000 --> 00:18:06,000
Hvis det er lige, så vi har fundet det. Vi vinder.

244
00:18:06,000 --> 00:18:12,000
Hvis det ikke er ens, så er der et par tilfælde.

245
00:18:12,000 --> 00:18:15,000
De to sager er enten antallet skal være større end antallet, vi kigger på,

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

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

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

249
00:18:33,000 --> 00:18:41,000
Og så har vi gentage hele processen igen

250
00:18:41,000 --> 00:18:48,000
på enten den højre halvdel eller den venstre halvdel af listen.

251
00:18:48,000 --> 00:18:51,000
>> Det første problem i dagens afsnit er at finde ud af

252
00:18:51,000 --> 00:18:55,000
hvordan vi rent faktisk kan begynde at udtrykke dette i C-kode.

253
00:18:55,000 --> 00:18:58,000
Vi har pseudokoden her.

254
00:18:58,000 --> 00:19:04,000
Hvad vi vil begynde at gøre er jeg vil trække op en helt ny plads,

255
00:19:04,000 --> 00:19:09,000
gemme denne revision, så vi har disse notater til senere,

256
00:19:09,000 --> 00:19:20,000
vi vil slette alt dette, og derefter kopiere og indsætte fra problemet indstillede

257
00:19:20,000 --> 00:19:26,000
denne information ind i vores rum, og forhåbentlig ikke går i stykker.

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

259
00:19:28,000 --> 00:19:33,000
Hvis du fyre alle gør det, kopiere og indsætte denne kode til din nye rum,

260
00:19:33,000 --> 00:19:43,000
i en tom én.

261
00:19:43,000 --> 00:19:47,000
Lad os prøve Daniel. Hvis du kompilere og køre dette program, virker det?

262
00:19:47,000 --> 00:19:49,000
Nej >> Hvad er det siger?

263
00:19:49,000 --> 00:19:53,000
Det siger den kontrol når til slutningen af ​​ikke-void funktion.

264
00:19:53,000 --> 00:19:55,000
Ja, så lad mig prøve at køre det.

265
00:19:55,000 --> 00:19:59,000
Har du fyre set det før? Ved du hvad det betyder?

266
00:19:59,000 --> 00:20:01,000
Okay, lad os dissekere det en lille smule.

267
00:20:01,000 --> 00:20:10,000
Det siger i file.c on line 9, kolonne 1 vi har en fejl, ligesom du sagde,

268
00:20:10,000 --> 00:20:16,000
og det siger, at det er som følge af fejlen advarsel og returtypen advarsel.

269
00:20:16,000 --> 00:20:18,000
Det ligner noget, der foregår med afkastet type, som giver mening.

270
00:20:18,000 --> 00:20:21,000
Vi har en non-void funktion, hvilket betyder, at vi har en funktion

271
00:20:21,000 --> 00:20:24,000
der ikke vender tilbage ugyldige.

272
00:20:24,000 --> 00:20:27,000
En void funktion er en, der ser sådan ud:

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

274
00:20:35,000 --> 00:20:38,000
hvilket betyder, at hvis vi havde noget herinde

275
00:20:38,000 --> 00:20:45,000
ligesom tilbagevenden 1, ville vi få en compiler fejl for dette.

276
00:20:45,000 --> 00:20:49,000
Men vi har en ikke-void funktion.

277
00:20:49,000 --> 00:20:51,000
Vores non-void funktion i dette tilfælde er vores søgefunktion

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

279
00:20:56,000 --> 00:20:59,000
Når det sige, at kontrollen når enden af ​​en ikke-void funktion,

280
00:20:59,000 --> 00:21:02,000
det er fordi søgning ikke har en return-sætning.

281
00:21:02,000 --> 00:21:04,000
Det er ikke returnere noget af typen bool.

282
00:21:04,000 --> 00:21:09,000
>> Vi kan ordne det, og hvad tror du fyre tror

283
00:21:09,000 --> 00:21:13,000
søgning bør vende tilbage som standard?

284
00:21:13,000 --> 00:21:16,000
Hvad skal være standard returværdien af ​​søgning?

285
00:21:16,000 --> 00:21:19,000
Fordi det er, hvad vi kan lægge i slutningen.

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

287
00:21:21,000 --> 00:21:23,000
Sandt eller falsk? >> Sandt eller falsk.

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

289
00:21:26,000 --> 00:21:28,000
Falsk. Det ved jeg ikke.

290
00:21:28,000 --> 00:21:30,000
False? Lad os prøve det.

291
00:21:30,000 --> 00:21:32,000
Hvorfor ville du sige return false? Det er godt intuition.

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

293
00:21:35,000 --> 00:21:39,000
Vi vil returnere falsk i dette tilfælde, fordi dette vil være vores standard

294
00:21:39,000 --> 00:21:44,000
hvis en eller anden grund listen er tom, eller nålen

295
00:21:44,000 --> 00:21:46,000
at vi leder efter findes ikke.

296
00:21:46,000 --> 00:21:50,000
Så til allersidst, hvis vi ikke returnere sandt tidligere i denne funktion,

297
00:21:50,000 --> 00:21:55,000
vi altid ved, at denne funktion vil sige nope, det er ikke i array.

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

299
00:21:58,000 --> 00:22:03,000
Nu, hvis vi kompilere og køre det, lad mig spare dette, så vi kan trække det op.

300
00:22:03,000 --> 00:22:08,000
Nu, hvis vi kompilere og køre vores program, det bygger.

301
00:22:08,000 --> 00:22:12,000
Vi får vores lille prompt.

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

303
00:22:20,000 --> 00:22:25,000
Det gik ikke udskrive noget. Det ligner alt endte okay.

304
00:22:25,000 --> 00:22:35,000
Vi har fået at udfylde dette i.

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

306
00:22:39,000 --> 00:22:44,000
Lad mig se, gemme dette,

307
00:22:44,000 --> 00:22:49,000
og jeg vil trække denne algoritme op igen.

308
00:22:49,000 --> 00:22:51,000
Lad os slå denne fyr. Nope.

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

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

311
00:23:03,000 --> 00:23:11,000
Hvad ville være en god strategi til at starte off denne kode?

312
00:23:11,000 --> 00:23:16,000
Du er nødt til at vælge et nummer i midten.

313
00:23:16,000 --> 00:23:23,000
Hvordan vi vælger et nummer midt i et array?

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

315
00:23:25,000 --> 00:23:27,000
[Student] strlen divideret med 2.

316
00:23:27,000 --> 00:23:32,000
Strlen divideret med 2. Det er en stor en.

317
00:23:32,000 --> 00:23:35,000
Strlen arbejder med særlige typer af arrays.

318
00:23:35,000 --> 00:23:38,000
Hvilke typer af arrays?

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

320
00:23:44,000 --> 00:23:48,000
Det er den samme slags koncept, som vi vil anvende,

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

322
00:23:52,000 --> 00:23:55,000
Vi har en bred vifte af int'er.

323
00:23:55,000 --> 00:23:58,000
Men hvad betyder strlen får for os?

324
00:23:58,000 --> 00:24:01,000
Ved du, hvad det får for os?

325
00:24:01,000 --> 00:24:03,000
[Student] strlen får os længden.

326
00:24:03,000 --> 00:24:05,000
Præcis, det får os længden.

327
00:24:05,000 --> 00:24:09,000
Strlen får længden af ​​array for os.

328
00:24:09,000 --> 00:24:14,000
>> Hvordan får vi det i vores binær søgning program?

329
00:24:14,000 --> 00:24:18,000
Hvordan ville du få længden af ​​et array?

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

331
00:24:20,000 --> 00:24:25,000
Du kan få længden af ​​en korrekt formateret 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 tilbage på denne kode, vi har denne integer array.

334
00:24:36,000 --> 00:24:38,000
Hvordan kan vi vide, hvor længe det er?

335
00:24:38,000 --> 00:24:44,000
[Student] Er der en tilsvarende én for endpoint, ligesom int l eller noget?

336
00:24:44,000 --> 00:24:49,000
Det viser sig, at der faktisk ikke er, og så på en måde, dette er

337
00:24:49,000 --> 00:24:52,000
en af ​​de ting, der er bare godt at vide om C,

338
00:24:52,000 --> 00:24:57,000
at der ikke er nogen måde at få længden af ​​et array

339
00:24:57,000 --> 00:24:59,000
hvis alt jeg give dig, er det array.

340
00:24:59,000 --> 00:25:02,000
Grunden til at det virker med strygere, årsagen strlen værker,

341
00:25:02,000 --> 00:25:06,000
er fordi, hvis en streng er formateret korrekt,

342
00:25:06,000 --> 00:25:12,000
det vil have, at særlige \ 0 tegn til allersidst.

343
00:25:12,000 --> 00:25:16,000
>> Du kan også forestille mig, hvis du har en forkert formateret streng

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

345
00:25:20,000 --> 00:25:22,000
[Student] Kan du tilføje \ 0?

346
00:25:22,000 --> 00:25:24,000
Vi kunne i dette tilfælde.

347
00:25:24,000 --> 00:25:29,000
Vi kunne tilføje nogle slags \ 0

348
00:25:29,000 --> 00:25:33,000
eller anden form for tilkendegiver karakter og derefter bruge det.

349
00:25:33,000 --> 00:25:36,000
Men det er ikke helt kommer til at arbejde

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

351
00:25:40,000 --> 00:25:43,000
og her har vi int'er.

352
00:25:43,000 --> 00:25:46,000
Den anden ting er, hvis vi skulle bruge en speciel værdi

353
00:25:46,000 --> 00:25:49,000
ligesom -1 for at markere afslutningen på et array

354
00:25:49,000 --> 00:25:54,000
så kunne vi aldrig gemme en -1 i vores heltal arrays.

355
00:25:54,000 --> 00:25:56,000
Vi ville blive hængende.

356
00:25:56,000 --> 00:26:00,000
Det viser sig, at den eneste måde at få længden

357
00:26:00,000 --> 00:26:03,000
af et array i C er rent faktisk at huske det

358
00:26:03,000 --> 00:26:08,000
når du sætter den op, og derefter sende det rundt med array

359
00:26:08,000 --> 00:26:14,000
så at når jeg har en funktion, der kommer til at gøre noget arbejde

360
00:26:14,000 --> 00:26:18,000
på en bred vifte af heltal eller decimaltal eller fordobler eller hvad har du,

361
00:26:18,000 --> 00:26:22,000
Jeg er også nødt til at give den funktion array længde,

362
00:26:22,000 --> 00:26:26,000
og det er præcis, hvad vi har gjort her i søgefunktionen.

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

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

365
00:26:36,000 --> 00:26:41,000
Det sker bare, at vi har kaldt denne variabel her,

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

367
00:26:43,000 --> 00:26:46,000
Dette kaldes en funktions argument liste eller parameterliste,

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

369
00:26:51,000 --> 00:26:53,000
Folk bruger forskellige udtryk på forskellige tidspunkter.

370
00:26:53,000 --> 00:26:55,000
Jeg har nogle gange interchange dem selv.

371
00:26:55,000 --> 00:27:00,000
Det bare så sker det, at denne variabel her er opkaldt lignende

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

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

374
00:27:06,000 --> 00:27:11,000
Kapitaliseringen ligegyldigt.

375
00:27:11,000 --> 00:27:14,000
>> Hvis man ser på, hvad der sker her, vi erklærer

376
00:27:14,000 --> 00:27:18,000
vores int array, som vi har kaldt numre.

377
00:27:18,000 --> 00:27:23,000
Vi har givet det vores størrelse, der svarer til vores # definere op øverst.

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

379
00:27:27,000 --> 00:27:35,000
Og så når vi så kalde vores søgefunktion dernede,

380
00:27:35,000 --> 00:27:40,000
passerer vi i det antal vi vil søge efter, og som vi har bedt om det,

381
00:27:40,000 --> 00:27:43,000
fået fra brugeren.

382
00:27:43,000 --> 00:27:46,000
Vi passerer i array, dette tal,

383
00:27:46,000 --> 00:27:51,000
og så har vi også nødt til at passere i størrelsen af ​​array,

384
00:27:51,000 --> 00:27:57,000
og så værdien af ​​størrelse 8 bliver gemt

385
00:27:57,000 --> 00:28:01,000
eller videregives til denne heltalsvariabel kaldet størrelse.

386
00:28:01,000 --> 00:28:08,000
Vi har størrelsen af ​​arrayet.

387
00:28:08,000 --> 00:28:11,000
Nu, hvis vi går tilbage til det, vi talte om tidligere,

388
00:28:11,000 --> 00:28:14,000
Jeg tror Missy opdraget det punkt, hvad vi skulle gøre, er at få længden af ​​array

389
00:28:14,000 --> 00:28:20,000
og dividere det med 2, og det vil give os midtpunktet.

390
00:28:20,000 --> 00:28:22,000
Lad os se.

391
00:28:22,000 --> 00:28:25,000
Kan jeg få nogen skriver dette, og gemme det i deres plads?

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

393
00:28:27,000 --> 00:28:31,000
Kan jeg få dig skrive det i?

394
00:28:31,000 --> 00:28:35,000
Skriv den første linje, hvor du tager længden af ​​array og få midtpunktet

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

396
00:28:41,000 --> 00:28:44,000
Jeg vil give dig et par sekunder. Er du klar?

397
00:28:44,000 --> 00:28:46,000
[Student lydløs]

398
00:28:46,000 --> 00:28:50,000
Sure, kunne jeg have dig med at beregne midtpunktet

399
00:28:50,000 --> 00:28:55,000
af høstakken arrayet inde i søgefunktionen

400
00:28:55,000 --> 00:29:03,000
ved hjælp af længden af ​​høstak matrix, som er den størrelse variabel?

401
00:29:03,000 --> 00:29:08,000
Intet tricky her.

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

403
00:29:12,000 --> 00:29:17,000
Og gemme den, og ramte knappen Gem heroppe på toppen,

404
00:29:17,000 --> 00:29:19,000
og vi vil trække det op.

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

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

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

408
00:29:30,000 --> 00:29:32,000
[Leila] Nej, det skal være højere.

409
00:29:32,000 --> 00:29:34,000
[Nate] Yeah, så hvad skal vi gøre?

410
00:29:34,000 --> 00:29:36,000
[Leila] Ligesom int midtpunkt eller noget.

411
00:29:36,000 --> 00:29:41,000
Awesome. Ja, lad os gøre det, int midtpunkt = størrelse.

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

413
00:29:44,000 --> 00:29:47,000
Lad os slette denne kommentar og få det ud af vejen.

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

415
00:29:50,000 --> 00:29:52,000
Vi laver ikke noget med heltal,

416
00:29:52,000 --> 00:29:55,000
så vi er nødt til at udskrive det eller noget lignende.

417
00:29:55,000 --> 00:29:58,000
Ja, præcis.

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

419
00:30:00,000 --> 00:30:02,000
Hvad andet er ikke til at arbejde her?

420
00:30:02,000 --> 00:30:06,000
Jeg tror, ​​du sagde noget, Sam. Semikoloner.

421
00:30:06,000 --> 00:30:08,000
Ja, jeg mangler disse semikoloner.

422
00:30:08,000 --> 00:30:14,000
Det kommer til at være en konstant ting under hele udtrykket.

423
00:30:14,000 --> 00:30:17,000
Den sidste ting, jeg vil gøre, er at jeg vil sætte nogle hvide plads på hver side

424
00:30:17,000 --> 00:30:23,000
af denne operatør her, da det er typisk hvordan vi gør det

425
00:30:23,000 --> 00:30:26,000
ifølge vores styleguide.

426
00:30:26,000 --> 00:30:29,000
Vi har midtpunktet af vores array.

427
00:30:29,000 --> 00:30:32,000
Nu, hvis vi husker tilbage til vores algoritme,

428
00:30:32,000 --> 00:30:37,000
hvad var det andet trin, at vi måtte gøre, når vi har midtpunktet?

429
00:30:37,000 --> 00:30:42,000
[Student] Hvis det er større [uhørlig].

430
00:30:42,000 --> 00:30:48,000
Ja, så vi er nødt til at gøre en form for sammenligning, og hvad skal vi sammenligner her?

431
00:30:48,000 --> 00:30:53,000
Du sagde, at hvis det er større end. Hvad er det i denne sætning hentyder til?

432
00:30:53,000 --> 00:30:57,000
Det nummer, der kommer op, hvis det er større end midtpunktet og derefter gå op til array?

433
00:30:57,000 --> 00:31:05,000
Præcis, så antallet, der kommer op, 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 hvad skal vi sammenligne mod nålen?

436
00:31:12,000 --> 00:31:15,000
Fordi nålen er, hvad vi leder efter.

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

438
00:31:18,000 --> 00:31:21,000
>> Men giver det mening at kontrollere,

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

440
00:31:27,000 --> 00:31:32,000
Giver det mening?

441
00:31:32,000 --> 00:31:35,000
Er der nogen er uenige?

442
00:31:35,000 --> 00:31:40,000
Lad os give det en chance, hvis (nål == midtpunktet).

443
00:31:40,000 --> 00:31:42,000
[Student] Må printf du fandt den.

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

445
00:31:51,000 --> 00:31:56,000
Ellers-Jeg kommer til at begynde at gøre noget anderledes her.

446
00:31:56,000 --> 00:32:00,000
Jeg har tænkt mig at begynde at sætte seler rundt, hvis udsagn hele tiden

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

448
00:32:05,000 --> 00:32:07,000
vi får ikke de compilere.

449
00:32:07,000 --> 00:32:09,000
Ja, Sam. Du har en pointe.

450
00:32:09,000 --> 00:32:12,000
Problemet er, at midtpunktet repræsenterer en position i arrayet,

451
00:32:12,000 --> 00:32:15,000
men du kan få det til at repræsentere den værdi i den position af array.

452
00:32:15,000 --> 00:32:17,000
Det er en stor punkt.

453
00:32:17,000 --> 00:32:19,000
Har alle høre, hvad Sam sagde?

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

455
00:32:22,000 --> 00:32:28,000
udgør blot en position i array, men det er ikke den faktiske element i array.

456
00:32:28,000 --> 00:32:30,000
Hvis du tænker over koden som skrevet lige nu,

457
00:32:30,000 --> 00:32:35,000
hvis vi ser på dette array hernede, der har 8 elementer i det,

458
00:32:35,000 --> 00:32:39,000
Hvad er værdien af ​​midtpunktet vil være i denne funktion?

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 for antallet 4 -

462
00:32:51,000 --> 00:32:54,000
og vi kan bare køre denne kode og sætte lidt trist ansigt i her

463
00:32:54,000 --> 00:32:58,000
fordi vi ikke finde det, hvis vi køre denne kode

464
00:32:58,000 --> 00:33:04,000
som er lige nu, uploade det, bygning, lad mig rulle ned,

465
00:33:04,000 --> 00:33:09,000
og hvis vi ser for tallet 4,

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

467
00:33:18,000 --> 00:33:23,000
En af grundene er, at vi ikke vendte tilbage sandt,

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

469
00:33:26,000 --> 00:33:28,000
Og Sam siger nej.

470
00:33:28,000 --> 00:33:31,000
Hvad har vi?

471
00:33:31,000 --> 00:33:35,000
Vi virkelig fundet midtpunktet, som hvis vi ser på arrayet hernede,

472
00:33:35,000 --> 00:33:38,000
det vil være det element ved indeks 4, at vi kigger på,

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

474
00:33:42,000 --> 00:33:46,000
>> Hvordan får vi rent faktisk får det element ved 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 træde char eller noget?

477
00:33:52,000 --> 00:33:55,000
Hvad ville det gøre, lige ud af nysgerrighed?

478
00:33:55,000 --> 00:33:57,000
Kan du uddybe lidt mere?

479
00:33:57,000 --> 00:34:02,000
Du er nødt til at omdanne position i nummeret,

480
00:34:02,000 --> 00:34:05,000
så du bliver nødt til at lave en forbindelse, jeg synes det er char, men det kan ikke være.

481
00:34:05,000 --> 00:34:07,000
Ja, det er en god pointe.

482
00:34:07,000 --> 00:34:12,000
Vi har gjort en masse af denne konvertering positioner i chars, disse tegn,

483
00:34:12,000 --> 00:34:14,000
i de første to problemområder sæt.

484
00:34:14,000 --> 00:34:18,000
Det viser sig, at her, det er næsten identisk med

485
00:34:18,000 --> 00:34:24,000
adgang til i'te tegn i en streng, hvis det giver mening.

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

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

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

489
00:34:39,000 --> 00:34:44,000
Du kan gøre høstak, åben beslag, mid, lukket beslag.

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

491
00:34:46,000 --> 00:34:51,000
Gem det i her, og vi vil trække det op.

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

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

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

495
00:35:03,000 --> 00:35:07,000
til elementet i position midtpunkt i vores høstak array.

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

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

498
00:35:12,000 --> 00:35:15,000
Ja, der ser temmelig godt, hvis (nål == høstak [midtpunkt]).

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

500
00:35:18,000 --> 00:35:22,000
Nu, hvis vi køre koden-vi tilbage op en lille smule,

501
00:35:22,000 --> 00:35:26,000
det kompilerer, det kører, og nu, hvis vi ser for 4,

502
00:35:26,000 --> 00:35:30,000
vi ikke finde det, fordi nu er vi rent faktisk får nummeret 23.

503
00:35:30,000 --> 00:35:33,000
Vi får værdien 23, og det er hvad vi sammenligne med vores nål.

504
00:35:33,000 --> 00:35:35,000
Men det er godt. Det er et skridt i den rigtige retning.

505
00:35:35,000 --> 00:35:37,000
>> Det er det, vi forsøger at gøre.

506
00:35:37,000 --> 00:35:40,000
Vi prøver ikke at sammenligne nålen mod positioner i array

507
00:35:40,000 --> 00:35:44,000
men snarere mod de faktiske elementer i arrayet.

508
00:35:44,000 --> 00:35:49,000
Hvis vi ser tilbage nu igen på det næste trin i vores algoritme,

509
00:35:49,000 --> 00:35:51,000
hvad er det næste skridt?

510
00:35:51,000 --> 00:35:57,000
Leila allerede nævnt det kort.

511
00:35:57,000 --> 00:36:00,000
[Student] Kontroller at se, om den er større eller mindre end, og derefter beslutte, hvilken måde at flytte.

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

513
00:36:03,000 --> 00:36:07,000
Kan du sætte nogle-Jeg gemme denne revision,

514
00:36:07,000 --> 00:36:13,000
og derefter, hvis du lægger i nogle linier, der vil gøre det.

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

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

517
00:36:19,000 --> 00:36:26,000
det er 0 indekseret, så hvis vi sætter 4, det er faktisk ikke det tegn, vi leder efter?

518
00:36:26,000 --> 00:36:30,000
Ja, og det andet problem med at er-

519
00:36:30,000 --> 00:36:35,000
det er en stor fangst, fordi det kommer til at ende op sker muligvis

520
00:36:35,000 --> 00:36:42,000
hvis vi at bevæge os, og vi ikke nogensinde justere første omgang?

521
00:36:42,000 --> 00:36:46,000
Jeg gætte, hvad vi kan ende med at gøre forsøger at få adgang til

522
00:36:46,000 --> 00:36:49,000
elementet på 8. position af arrayet,

523
00:36:49,000 --> 00:36:53,000
som i dette tilfælde findes ikke.

524
00:36:53,000 --> 00:36:56,000
Vi ønsker at gøre en slags tegner sig for den kendsgerning

525
00:36:56,000 --> 00:36:59,000
at vi har nogle nul indeksering.

526
00:36:59,000 --> 00:37:05,000
[Charlotte] Undskyld, jeg mente midtpunkt - 1 i de firkantede parenteser.

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

528
00:37:08,000 --> 00:37:10,000
Vi vil vende tilbage til dette spørgsmål i bare en smule.

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

530
00:37:13,000 --> 00:37:16,000
det er når vi virkelig se dette kommer i spil.

531
00:37:16,000 --> 00:37:21,000
I øjeblikket kan vi gøre det, men du er helt rigtigt.

532
00:37:21,000 --> 00:37:28,000
At nul indeksering vil have en effekt, at vi er nødt til at redegøre for.

533
00:37:28,000 --> 00:37:30,000
Lad os se.

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

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

536
00:37:36,000 --> 00:37:41,000
Jeg var bare ikke sikker på, hvad der skal udskrives, hvis du synes, at det er mindre end høstakken midtpunktet eller større end.

537
00:37:41,000 --> 00:37:43,000
Her kan jeg spare, hvad Det har jeg-

538
00:37:43,000 --> 00:37:47,000
[Nate] Yeah, hvis du gemmer hvad du har fået, og vi vil trække det op.

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

540
00:37:49,000 --> 00:37:51,000
[Student] Og jeg sætter spørgsmålstegn til hvad jeg ikke vidste.

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

542
00:37:54,000 --> 00:37:58,000
Her har vi spørgsmålstegn, fordi vi stadig ikke kender

543
00:37:58,000 --> 00:38:06,000
hvad vi vil helt gøre endnu.

544
00:38:06,000 --> 00:38:12,000
Hvad ville vi ønsker at gøre-oops, så har vi nogle seler alle funky på os.

545
00:38:12,000 --> 00:38:15,000
Vi vil rette op på disse seler.

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

547
00:38:19,000 --> 00:38:22,000
Og så hvad gør vi ønsker at gøre, ifølge vores algoritme,

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

549
00:38:27,000 --> 00:38:32,000
Sig i det tilfælde, at nålen er mindre end hvad vi ser på. Kevin.

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

551
00:38:34,000 --> 00:38:40,000
Right, så vi vil sætte en kommentar ind her, der siger "se på venstre halvdel."

552
00:38:40,000 --> 00:38:46,000
Og hvis nålen er større end høstak ved midtpunktet, hvad vi ønsker at gøre?

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

554
00:38:48,000 --> 00:38:53,000
Kig på den højre halvdel, "se på højre halvdel."

555
00:38:53,000 --> 00:38:58,000
Ikke for lurvet.

556
00:38:58,000 --> 00:39:05,000
Okay, så på dette punkt, er tingene ser temmelig godt.

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

558
00:39:13,000 --> 00:39:15,000
[Student] Du har ikke endpoints for halvdele.

559
00:39:15,000 --> 00:39:18,000
Højre, har vi ikke endpoints for halvdele.

560
00:39:18,000 --> 00:39:20,000
Vi har også kun kommer til at gå igennem denne gang.

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

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

563
00:39:27,000 --> 00:39:34,000
For at gennemføre dette, vil vi nødt til at gøre en form for gentagelse.

564
00:39:34,000 --> 00:39:39,000
Vi er nødt til at gentage, indtil vi finder, at

565
00:39:39,000 --> 00:39:43,000
enten elementet er derinde, fordi vi har indsnævret og endelig fundet det,

566
00:39:43,000 --> 00:39:46,000
eller det er ikke der, fordi vi har set gennem alle de ting

567
00:39:46,000 --> 00:39:52,000
i de relevante halvdele af arrayet og fandt, at der intet er derinde.

568
00:39:52,000 --> 00:39:56,000
>> Når vi har fået denne gentagelse foregår, hvad vi skal bruge?

569
00:39:56,000 --> 00:39:58,000
[Student] A loop.

570
00:39:58,000 --> 00:40:00,000
Nogle slags løkke. Ja.

571
00:40:00,000 --> 00:40:03,000
[Student] Kan vi gøre en gør-while-løkke og har det gør det, og derefter, mens

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

573
00:40:10,000 --> 00:40:18,000
Men lidt ligesom at gøre det, så længe det ikke er lig den værdi, som brugeren input.

574
00:40:18,000 --> 00:40:21,000
Ja, så lad os se, hvordan kan denne skrive sig selv?

575
00:40:21,000 --> 00:40:23,000
Du sagde lad os bruge et do-while-løkke.

576
00:40:23,000 --> 00:40:26,000
Hvor kommer do start?

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

578
00:40:33,000 --> 00:40:42,000
[Nate] Okay, og hvad skal vi gøre?

579
00:40:42,000 --> 00:40:44,000
Vi udfylde tid senere.

580
00:40:44,000 --> 00:40:46,000
Hvad skal vi gøre?

581
00:40:46,000 --> 00:40:49,000
[Student] Må ikke vi ønsker at gøre alle de ting vi har i hvis portion?

582
00:40:49,000 --> 00:40:52,000
[Nate] Gør alle disse ting, stor.

583
00:40:52,000 --> 00:40:55,000
Kopier og indsæt.

584
00:40:55,000 --> 00:40:59,000
Åh, mand.

585
00:40:59,000 --> 00:41:03,000
Lad os se om det virker, hvis vi kan fane dette over.

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

587
00:41:08,000 --> 00:41:16,000
Okay, og vi sparer dette, så du fyre har det.

588
00:41:16,000 --> 00:41:21,000
Okay, og vi vil gøre dette, mens-

589
00:41:21,000 --> 00:41:25,000
hvad var det så længe betingelse du var ude efter?

590
00:41:25,000 --> 00:41:31,000
[Student] Mens nålen ikke lige, så ligesom det udråbstegn.

591
00:41:31,000 --> 00:41:37,000
Men jeg er ikke sikker på præcis, hvad det er endnu.

592
00:41:37,000 --> 00:41:39,000
[Nate] Ja, det er en måde at gøre det på.

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 huskede, da jeg kiggede på de videoer,

595
00:41:43,000 --> 00:41:48,000
Jeg tog et screenshot af en af-lignende da vi gjorde pseudokoden for det,

596
00:41:48,000 --> 00:41:52,000
Der var en vis forbindelse mellem max og min.

597
00:41:52,000 --> 00:41:58,000
Jeg tror, ​​det var noget som hvis max er stadig mindre end min.

598
00:41:58,000 --> 00:42:00,000
Fik det.

599
00:42:00,000 --> 00:42:04,000
[Sam] Eller gerne, hvis max ikke er mindre end min eller sådan noget,

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

601
00:42:06,000 --> 00:42:13,000
>> Ja, så hvad betyder det lyde som max og min henviste til?

602
00:42:13,000 --> 00:42:16,000
[Sam] Værdier, som-heltal, der vil ændre

603
00:42:16,000 --> 00:42:18,000
i forhold til hvor vi sætter midtpunktet.

604
00:42:18,000 --> 00:42:20,000
Præcis.

605
00:42:20,000 --> 00:42:24,000
[Sam] På det tidspunkt, går det til [uhørlig] beregne max og min.

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

607
00:42:29,000 --> 00:42:35,000
Giver det mening at folk?

608
00:42:35,000 --> 00:42:39,000
Hvis vi skulle begynde at kigge på, hvordan vi vil gøre det iteration,

609
00:42:39,000 --> 00:42:43,000
du er helt rigtigt, at vi ønsker at bruge en form for do-while-løkke.

610
00:42:43,000 --> 00:42:49,000
Men jeg gætte, hvis vi husker, hvad der foregår på stedet af dette array

611
00:42:49,000 --> 00:42:53,000
og hvad der rent faktisk sker-Jeg kommer til at skrive herovre-

612
00:42:53,000 --> 00:42:58,000
i det første iteration af binær søgning, har-vi

613
00:42:58,000 --> 00:43:05,000
Jeg har tænkt mig at bruge b og e til at betegne begyndelsen.

614
00:43:05,000 --> 00:43:10,000
Og så i slutningen af ​​vores array.

615
00:43:10,000 --> 00:43:14,000
Vi ved, at starten er på 4 lige over her,

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

617
00:43:18,000 --> 00:43:23,000
Siger, at vi leder efter nummeret 15.

618
00:43:23,000 --> 00:43:27,000
Første gang vi gør det, som vi så tidligere,

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

620
00:43:30,000 --> 00:43:34,000
afhængigt af, hvordan vi beregner tingene ud.

621
00:43:34,000 --> 00:43:37,000
Siden jævnt dividere i midten ville give os denne plads

622
00:43:37,000 --> 00:43:42,000
mellem 16 og 23, kan vi ikke jævnt opdele det

623
00:43:42,000 --> 00:43:47,000
eller dele den og få fat i en ægte midtpunkt.

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

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

626
00:43:55,000 --> 00:43:59,000
At derefter se på den venstre halvdel af grupperingen

627
00:43:59,000 --> 00:44:03,000
hvad vi vil ende med at gøre, er genudsætning

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

629
00:44:07,000 --> 00:44:16,000
og siger: "Okay, nu er vores endpoint vil være her."

630
00:44:16,000 --> 00:44:22,000
Den næste iteration af vores loop, vi nu kigger på dette array,

631
00:44:22,000 --> 00:44:25,000
effektivt at have fjernet denne del, fordi nu

632
00:44:25,000 --> 00:44:30,000
hvis vi tager midtpunktet at være forskellen mellem begyndelsen og enden,

633
00:44:30,000 --> 00:44:34,000
Vi finder vores midtpunkt at være 8,

634
00:44:34,000 --> 00:44:40,000
som vi kan derefter teste 8 for at se, hvor det er i forhold til det antal vi leder efter,

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

636
00:44:44,000 --> 00:44:49,000
så vi er nødt til at flytte til den højre del af listen,

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

638
00:44:51,000 --> 00:44:54,000
Vi ved, at den højre del vil være der, hvor vi finder det,

639
00:44:54,000 --> 00:45:01,000
men computeren ikke ved det, så hvad vi vil gøre, er at vi vil faktisk

640
00:45:01,000 --> 00:45:04,000
har dette gå op, og nu begyndelsen og enden

641
00:45:04,000 --> 00:45:11,000
er det samme sted, så midtpunktet bliver den eneste nummer på listen på det tidspunkt,

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

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

644
00:45:21,000 --> 00:45:24,000
holde styr på de endepunkter af arrayet for at finde ud af

645
00:45:24,000 --> 00:45:35,000
hvordan man kan indsnævre tingene ned?

646
00:45:35,000 --> 00:45:42,000
>> Hvad ville der ske, hvis det ikke var lig med 15 nu?

647
00:45:42,000 --> 00:45:52,000
Hvad hvis vi ledte efter 15 og i stedet dette nummer var også 16?

648
00:45:52,000 --> 00:45:54,000
Vi ville sige: "Åh, det er større.

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

650
00:45:57,000 --> 00:46:01,000
Og vi ville flytte vores e til højre,

651
00:46:01,000 --> 00:46:06,000
på hvilket tidspunkt har vi et endepunkt, der ville være modstridende.

652
00:46:06,000 --> 00:46:09,000
Det ville ikke være i stand til at søge efter alle flere elementer

653
00:46:09,000 --> 00:46:13,000
fordi vi nu har vores endpoint og vores startpunkt,

654
00:46:13,000 --> 00:46:16,000
vores max og vor min, er nu vendt.

655
00:46:16,000 --> 00:46:23,000
Vi gennemsøge hele array. Vi kan ikke finde noget.

656
00:46:23,000 --> 00:46:27,000
Det er det punkt, hvor vi gerne vil sige, "Okay, vi kommer til at stoppe denne algoritme.

657
00:46:27,000 --> 00:46:34,000
Vi har ikke fundet noget. Vi ved, det er ikke her. "

658
00:46:34,000 --> 00:46:36,000
Hvordan skal det hen?

659
00:46:36,000 --> 00:46:40,000
[Student] Hvor præcis er computeren skifte ende?

660
00:46:40,000 --> 00:46:45,000
Hvordan ende ender inden begyndelsen?

661
00:46:45,000 --> 00:46:48,000
Enden ender inden begyndelsen

662
00:46:48,000 --> 00:46:54,000
på grund af den matematik, vi vil gøre hver gang vi gør det.

663
00:46:54,000 --> 00:47:00,000
Den måde, vi bytte er, hvis man ser på den allerførste gang vi gør dette swap

664
00:47:00,000 --> 00:47:03,000
hvor vi har begyndelsen på 4 og slutningen

665
00:47:03,000 --> 00:47:13,000
hele vejen ned ved 108 og vores midtpunktet, dvs, ved 16 -

666
00:47:13,000 --> 00:47:20,000
Jeg har tænkt mig at nulstille dette tilbage til 15-hvis vi leder efter den 15,

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

668
00:47:25,000 --> 00:47:28,000
og ønskede at skille sig af med hele den højre del af listen,

669
00:47:28,000 --> 00:47:36,000
så vi, at hvad vi ønskede at gøre, er at flytte denne e lige her.

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

671
00:47:44,000 --> 00:47:48,000
Ligeledes når vi gjorde denne iteration af algoritmen

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

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

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

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

676
00:48:07,000 --> 00:48:10,000
>> Hvis vi havde været tilfældet at kigge efter en anden værdi, ikke 15,

677
00:48:10,000 --> 00:48:14,000
eller hvis denne 15 i stedet havde været 16,

678
00:48:14,000 --> 00:48:20,000
vi ville have fundet, at e vi ønsker at flytte en før midtpunktet.

679
00:48:20,000 --> 00:48:33,000
Nu e ville være der vendt mindre end b.

680
00:48:33,000 --> 00:48:39,000
Lad os gennemgå, hvordan vi rent faktisk ender kodning denne algoritme.

681
00:48:39,000 --> 00:48:44,000
Vi ved, at vi ønsker at have denne midtpunktet beregning.

682
00:48:44,000 --> 00:48:48,000
Vi ved også, at vi ønsker at spore begyndelsen og slutningen af ​​array

683
00:48:48,000 --> 00:48:51,000
af vores nuværende opstilling, så vi kan finde ud af

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

685
00:48:56,000 --> 00:49:03,000
Det gør vi med enten begynder og slutter,

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

687
00:49:07,000 --> 00:49:10,000
Jeg vil bruge begynder og ender denne gang.

688
00:49:10,000 --> 00:49:15,000
Når vi begynder, hvis vi ser tilbage på vores eksempel hernede,

689
00:49:15,000 --> 00:49:20,000
vores start var sat til begyndelsen af ​​array, som naturlige.

690
00:49:20,000 --> 00:49:25,000
Hvilken indeks var det? Hvad skal vores begynde være?

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, så vi kunne sætte det lig med høstak [0].

694
00:49:37,000 --> 00:49:40,000
Problemet er dog, at dette giver os ikke positionen af ​​det første element.

695
00:49:40,000 --> 00:49:45,000
Det giver os indekset for det første element eller den faktiske værdi i den første position.

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] Hvad dette vil gøre, er-godt, vil det ikke gøre nogen konverteringen.

698
00:49:52,000 --> 00:49:56,000
Hvad det vil gøre, er at det vil gemme en 4 i begynder,

699
00:49:56,000 --> 00:49:59,000
og så vil det være svært at foretage sammenligninger mod begynde

700
00:49:59,000 --> 00:50:03,000
fordi begin vil holde værdi på 4,

701
00:50:03,000 --> 00:50:06,000
som er begyndelsen på vores array,

702
00:50:06,000 --> 00:50:08,000
men vi ønsker at spore de indeks i array

703
00:50:08,000 --> 00:50:11,000
i modsætning til værdierne.

704
00:50:11,000 --> 00:50:17,000
Vi vil faktisk bruge et 0, som.

705
00:50:17,000 --> 00:50:20,000
For enden af ​​array-Charlotte bragt dette op lidt tidligere.

706
00:50:20,000 --> 00:50:23,000
Det er her, vi vil tage hensyn til nul indeksering.

707
00:50:23,000 --> 00:50:25,000
>> Charlotte, hvad er slutningen af ​​array?

708
00:50:25,000 --> 00:50:28,000
Hvad er indekset enden?

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 skal vi bruge?

711
00:50:32,000 --> 00:50:35,000
Skal vi bruge kapital størrelse eller små bogstaver størrelse?

712
00:50:35,000 --> 00:50:37,000
Capital størrelse.

713
00:50:37,000 --> 00:50:42,000
I dette tilfælde kunne vi bruge kapital størrelse.

714
00:50:42,000 --> 00:50:45,000
Hvis vi ønskede denne funktion til at være bærbar

715
00:50:45,000 --> 00:50:48,000
og bruge denne funktion i andre programmer,

716
00:50:48,000 --> 00:50:50,000
vi rent faktisk kan bruge små bogstaver størrelse.

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

718
00:50:52,000 --> 00:51:01,000
Men Charlotte er helt rigtigt, at vi gerne vil have 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 er det at du kan bruge store bogstaver størrelse?

721
00:51:05,000 --> 00:51:07,000
Hvordan er det at vi kunne bruge store bogstaver størrelse?

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

723
00:51:13,000 --> 00:51:19,000
under kølerhjelmen, finde en tekst som og erstatte, hvis det giver mening.

724
00:51:19,000 --> 00:51:24,000
Når du kompilerer din kode, forbehandling fase

725
00:51:24,000 --> 00:51:27,000
af compileren går gennem filen,

726
00:51:27,000 --> 00:51:31,000
og det ser for overalt, at du har skrevet kapital størrelse,

727
00:51:31,000 --> 00:51:39,000
og det erstatter det ordret med en 8, ligesom det.

728
00:51:39,000 --> 00:51:42,000
I den forstand er det meget forskelligt fra en variabel.

729
00:51:42,000 --> 00:51:45,000
Det tager ikke nogen plads i hukommelsen.

730
00:51:45,000 --> 00:51:52,000
Det er en simpel tekst erstatte trick.

731
00:51:52,000 --> 00:51:57,000
I dette tilfælde vil vi bruge størrelse.

732
00:51:57,000 --> 00:52:01,000
Herfra vi ønsker at gøre en form for gentagelse,

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

734
00:52:03,000 --> 00:52:08,000
Vi ønsker at gøre noget, indtil en betingelse ikke holder længere,

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

736
00:52:12,000 --> 00:52:19,000
var faktisk, at vi ikke ønsker enden

737
00:52:19,000 --> 00:52:24,000
at være mindre end begyndelsen.

738
00:52:24,000 --> 00:52:26,000
>> Det er vores standsning tilstand.

739
00:52:26,000 --> 00:52:35,000
Hvis dette sker, vil vi stoppe op og erklære lignende, "Hey, har vi ikke fundet noget."

740
00:52:35,000 --> 00:52:43,000
For at udtrykke dette, ønsker vi at bruge en form for løkke.

741
00:52:43,000 --> 00:52:49,000
I dette tilfælde ville det være en do-while-løkke, en for-løkke, en while-løkke?

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 du fyre som denne fremgangsmåde?

744
00:52:53,000 --> 00:52:59,000
Tror du vi skal prøve en anden tilgang?

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

746
00:53:01,000 --> 00:53:06,000
Vi kunne have en while-løkke, fordi vi ved maksimal

747
00:53:06,000 --> 00:53:11,000
ville være større end min ved start anyways.

748
00:53:11,000 --> 00:53:14,000
Ja, så der er ingen initialisering, der skal ske.

749
00:53:14,000 --> 00:53:17,000
Disse gør-while-løkker er stor, når du er nødt til at initialisere noget

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

751
00:53:21,000 --> 00:53:26,000
vi ved, at vi ikke kommer til at holde Reinitialisering både begynder og slutter

752
00:53:26,000 --> 00:53:28,000
hver runde af løkken.

753
00:53:28,000 --> 00:53:32,000
Vi ved, at vi ønsker at initialisere dem, så tjek vores tilstand.

754
00:53:32,000 --> 00:53:38,000
I dette tilfælde vil jeg faktisk gå med en simpel while-løkke.

755
00:53:38,000 --> 00:53:44,000
Det viser sig, at do-while-løkker bruges forholdsvis sjældent.

756
00:53:44,000 --> 00:53:49,000
En masse steder ikke engang underviser ikke mens sløjfer.

757
00:53:49,000 --> 00:53:53,000
De er gode til håndtering af bruger input, så vi har set en masse af dem hidtil.

758
00:53:53,000 --> 00:53:59,000
Men normalt for og while-løkker er en masse mere almindelige.

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

760
00:54:03,000 --> 00:54:09,000
vil ikke rigtig gøre os meget godt, og hvorfor så det?

761
00:54:09,000 --> 00:54:11,000
Jeg er ked af, jeg ikke kender dit navn.

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

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 kan ikke se dig på min liste.

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

767
00:54:26,000 --> 00:54:31,000
Har du en idé om, hvorfor dette while-løkke fungerer muligvis ikke efter hensigten,

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

769
00:54:38,000 --> 00:54:43,000
[Jerry] Du mener ligesom du vil have alle de ting efter den ind i-?

770
00:54:43,000 --> 00:54:46,000
Ja, så det er en.

771
00:54:46,000 --> 00:54:49,000
Vi skal måske lægge alle disse ting ind i while-løkken, som er helt sandt.

772
00:54:49,000 --> 00:54:55,000
Den anden ting, der er lidt mere problematisk, er dog, at denne betingelse ikke virker.

773
00:54:55,000 --> 00:54:57,000
[Student] Du er nødt til at vende det.

774
00:54:57,000 --> 00:55:04,000
Right, så denne betingelse vil aldrig være sandt oprindeligt den måde, vi talte om det.

775
00:55:04,000 --> 00:55:08,000
Vi ønsker at gøre noget indtil udgangen <begynde,

776
00:55:08,000 --> 00:55:13,000
men vi ønsker at gøre noget, mens

777
00:55:13,000 --> 00:55:21,000
begynder ≤ ende.

778
00:55:21,000 --> 00:55:24,000
>> Der er det omvendt logik der.

779
00:55:24,000 --> 00:55:27,000
Jeg laver disse fejltagelser hele tiden.

780
00:55:27,000 --> 00:55:31,000
[Student] Hvorfor skal det være mindre end eller lig med?

781
00:55:31,000 --> 00:55:33,000
Fordi husker du det sådan, at vi fik

782
00:55:33,000 --> 00:55:36,000
hvor der kun var et enkelt element, og vi var nede,

783
00:55:36,000 --> 00:55:43,000
og vi ledte på blot de 15 i vores array?

784
00:55:43,000 --> 00:55:47,000
Og vores begyndelse og vores ende var det samme element.

785
00:55:47,000 --> 00:55:50,000
Vi ønsker at sikre, at vi håndterer denne sag.

786
00:55:50,000 --> 00:55:54,000
Hvis vi gjorde en lige mindre end,

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

788
00:55:58,000 --> 00:56:06,000
Når vi kom ned til det sidste element, hvis det var vores element, ville vi aldrig finde det.

789
00:56:06,000 --> 00:56:10,000
Nu her, kan vi gøre præcis som du sagde.

790
00:56:10,000 --> 00:56:15,000
Vi kan begynde plopping ting lige ind i midten af ​​vores while-løkke.

791
00:56:15,000 --> 00:56:20,000
Vi kan plop i vores midtpunkt.

792
00:56:20,000 --> 00:56:24,000
Vi kan tage alle disse hvis udsagn,

793
00:56:24,000 --> 00:56:30,000
trække dem ud af denne do-while-løkke,

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

795
00:56:34,000 --> 00:56:39,000
rense tingene op en lille smule,

796
00:56:39,000 --> 00:56:48,000
og jeg vil gå videre og gemme denne revision.

797
00:56:48,000 --> 00:56:53,000
Og på dette tidspunkt, vi får temmelig tæt.

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

799
00:56:55,000 --> 00:56:58,000
Jeg tror, ​​du også nødt til at have int midtpunkt = størrelse - 1/2.

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

801
00:57:01,000 --> 00:57:05,000
Er der noget andet, vi er nødt til at ændre om denne linje?

802
00:57:05,000 --> 00:57:10,000
Det var en god fangst.

803
00:57:10,000 --> 00:57:14,000
>> Hvad gør size gøre? Er vi nogensinde skiftende størrelse?

804
00:57:14,000 --> 00:57:17,000
For at holde den linje som denne, er vi nødt til at ændre størrelsen.

805
00:57:17,000 --> 00:57:21,000
Vi er nødt til at ændre størrelsen hver gang vi gå rundt i for-løkken.

806
00:57:21,000 --> 00:57:25,000
Men huske, da vi var på vej gennem vores eksempel bare en lille smule tidligere,

807
00:57:25,000 --> 00:57:30,000
og vi havde starten på 4

808
00:57:30,000 --> 00:57:33,000
og enden hele vejen over ved 108?

809
00:57:33,000 --> 00:57:35,000
Hvordan kom vi beregner midtpunktet?

810
00:57:35,000 --> 00:57:38,000
Blev vi bruger størrelse?

811
00:57:38,000 --> 00:57:40,000
Eller vi bruger begynder og slutter i stedet?

812
00:57:40,000 --> 00:57:42,000
Det er forskellen mellem udgangen og begyndelsen.

813
00:57:42,000 --> 00:57:50,000
Præcis, og præcist hvordan skal jeg skrive det, Charlotte?

814
00:57:50,000 --> 00:57:52,000
Bare ende - begynde.

815
00:57:52,000 --> 00:57:55,000
Du ville ikke behøver at gøre det - 1

816
00:57:55,000 --> 00:57:58,000
fordi - 1 er medtaget i slutningen og begyndelsen allerede.

817
00:57:58,000 --> 00:58:00,000
[Nate] Great, du er helt rigtigt.

818
00:58:00,000 --> 00:58:03,000
Vi har ikke at gøre - 1, fordi der - 1 er medtaget

819
00:58:03,000 --> 00:58:08,000
og tegnede sig for når vi initialisere enden variabel.

820
00:58:08,000 --> 00:58:11,000
>> Er der andet jeg skal gøre syntaktisk at have denne linje giver mening?

821
00:58:11,000 --> 00:58:13,000
[Student] Plus begynde. >> Plus begynde?

822
00:58:13,000 --> 00:58:15,000
[Student] Ved udgangen.

823
00:58:15,000 --> 00:58:20,000
Fordi det kun er beregnet halvdelen af ​​længden.

824
00:58:20,000 --> 00:58:26,000
Du er nødt til at tilføje begynde.

825
00:58:26,000 --> 00:58:31,000
[Nate] Hvad ville dette beregne for os?

826
00:58:31,000 --> 00:58:35,000
Hvis vi tænker over ende på dette allerførste iteration af løkken,

827
00:58:35,000 --> 00:58:40,000
ende vil være i position indeks 7.

828
00:58:40,000 --> 00:58:43,000
Begynd er i 0-stilling.

829
00:58:43,000 --> 00:58:47,000
Husk, vi leder efter enten

830
00:58:47,000 --> 00:58:52,000
position 3 eller 4-stillingen.

831
00:58:52,000 --> 00:58:56,000
Hvis vi ser på denne matematik, for bare at gøre det lidt mere håndgribeligt,

832
00:58:56,000 --> 00:59:02,000
sætte nogle numre her, har vi 7, 0,

833
00:59:02,000 --> 00:59:10,000
SO 7 - 0, og derefter / 2

834
00:59:10,000 --> 00:59:19,000
er 3 i heltalsdivision, der er.

835
00:59:19,000 --> 00:59:26,000
Så skal vi derefter tilføje tilbage vores begynde?

836
00:59:26,000 --> 00:59:28,000
Det gør vi ikke i dette tilfælde.

837
00:59:28,000 --> 00:59:31,000
På den allerførste iteration, vil det være fint, fordi begin er 0.

838
00:59:31,000 --> 00:59:36,000
Men da vi fremskridt, har vi virkelig alle bare brug

839
00:59:36,000 --> 00:59:42,000
ende - begynder / 2.

840
00:59:42,000 --> 00:59:46,000
Der er en anden trick her, og det er nemlig en af ​​forrang.

841
00:59:46,000 --> 00:59:49,000
[Student] Har vi brug for parenteser?

842
00:59:49,000 --> 00:59:53,000
[Nate] Præcis, og det er fordi hvis vi ikke sætte disse parenteser,

843
00:59:53,000 --> 00:59:58,000
så denne linje vil blive fortolket i stedet

844
00:59:58,000 --> 01:00:09,000
som (slut) - (begynder / 2), som vi absolut ikke ønsker.

845
01:00:09,000 --> 01:00:11,000
Watch out for disse forrangsbestemmelserne.

846
01:00:11,000 --> 01:00:15,000
[Student] Hvorfor er det ikke ender + begynde?

847
01:00:15,000 --> 01:00:17,000
Hvorfor er det ikke ender + begynde?

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 ville det være +?

850
01:00:24,000 --> 01:00:26,000
Jeg tror, ​​du har ret.

851
01:00:26,000 --> 01:00:28,000
[Student] Fordi det er gennemsnittet?

852
01:00:28,000 --> 01:00:31,000
[Nate] End + begynde, du er helt rigtigt.

853
01:00:31,000 --> 01:00:34,000
Wow, jeg er helt goofed. Du har ret.

854
01:00:34,000 --> 01:00:39,000
Hvis vi gjorde det minus, ville vi vil tilføje begynde igen

855
01:00:39,000 --> 01:00:43,000
I dette tilfælde er du meget ret i, at vi ønsker at tage gennemsnittet af de to,

856
01:00:43,000 --> 01:00:45,000
så vi ønsker at tilføje dem, i modsætning til trække dem.

857
01:00:45,000 --> 01:00:49,000
[Student] Det ville også virke, hvis du gjorde ende - begynder / 2 + begynde.

858
01:00:49,000 --> 01:00:55,000
Det ville gøre, hvis vi gør-jeg tror det.

859
01:00:55,000 --> 01:01:00,000
>> For eksempel, hvis vi ledte på begynde

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
Nu begynder er i position 2.

863
01:01:12,000 --> 01:01:15,000
End er i position 7.

864
01:01:15,000 --> 01:01:21,000
Hvis vi trækker dem, vi får 5.

865
01:01:21,000 --> 01:01:24,000
Divider at ved 2, vi får 2.

866
01:01:24,000 --> 01:01:27,000
Og så tilføjer vi 2 tilbage i,

867
01:01:27,000 --> 01:01:30,000
og der får os til den 4. plads,

868
01:01:30,000 --> 01:01:33,000
der er lige her, som er midtpunktet.

869
01:01:33,000 --> 01:01:36,000
[Student] Har vi brug for at tage sig af indpakning?

870
01:01:36,000 --> 01:01:39,000
I hvilken forstand har vi brug for at tage sig af indpakning?

871
01:01:39,000 --> 01:01:43,000
Hvis summen eller forskellen mellem

872
01:01:43,000 --> 01:01:45,000
afhængigt af, hvordan vi gør det, er ikke et lige tal.

873
01:01:45,000 --> 01:01:49,000
Så computeren bliver forvirret, om når det er 2,5;

874
01:01:49,000 --> 01:01:52,000
vil du flytte til venstre eller til højre for at afgøre, hvilket er midtpunktet?

875
01:01:52,000 --> 01:01:54,000
Fik det.

876
01:01:54,000 --> 01:01:56,000
Det viser sig, at med heltalsdivisioner,

877
01:01:56,000 --> 01:01:59,000
vi ikke nogensinde få disse kommatal.

878
01:01:59,000 --> 01:02:01,000
Vi har aldrig få decimal.

879
01:02:01,000 --> 01:02:04,000
Det er helt bortkastet.

880
01:02:04,000 --> 01:02:08,000
Hvis du har en computer dividere to int variabler,

881
01:02:08,000 --> 01:02:11,000
og man er 7, og den anden er 2,

882
01:02:11,000 --> 01:02:13,000
du vil ikke få 3,5 som følge heraf.

883
01:02:13,000 --> 01:02:16,000
Det vil få 3.

884
01:02:16,000 --> 01:02:19,000
Resten vil blive kasseret, så det er effektivt afrunding

885
01:02:19,000 --> 01:02:24,000
ikke en runde, men snarere et gulv, hvis du fyre kender det i matematik,

886
01:02:24,000 --> 01:02:27,000
hvor du helt kassere decimal,

887
01:02:27,000 --> 01:02:31,000
og så du hovedsageligt beskærer det ned til nærmeste

888
01:02:31,000 --> 01:02:33,000
Hele position, til det nærmeste hele tal.

889
01:02:33,000 --> 01:02:38,000
[Student] Men så er det problematisk, fordi hvis du har en vifte af 7 elementer

890
01:02:38,000 --> 01:02:43,000
så der automatisk tager 3. element ud af midtpunktet i stedet for den 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 havde en vifte af 7,

893
01:02:49,000 --> 01:02:54,000
Det ville vælge den 3. i stedet for 4..

894
01:02:54,000 --> 01:02:56,000
Kan du forklare lidt mere?

895
01:02:56,000 --> 01:02:59,000
[Student] Fordi hvis du har 7 elementer så det 4. element

896
01:02:59,000 --> 01:03:04,000
ville være midtpunktet, right?

897
01:03:04,000 --> 01:03:07,000
Husk din kommentar om at være nul indekseret, selvom.

898
01:03:07,000 --> 01:03:10,000
[Student] Yeah, så i 3-stillingen. Det ville være midtpunktet.

899
01:03:10,000 --> 01:03:12,000
Yeah.

900
01:03:12,000 --> 01:03:16,000
Oh, okay. Jeg kan se hvad du mener.

901
01:03:16,000 --> 01:03:19,000
Det er lidt underligt, da vi vænner os til hele denne forestilling om

902
01:03:19,000 --> 01:03:22,000
at komme af decimaler.

903
01:03:22,000 --> 01:03:26,000
Det er en stor punkt.

904
01:03:26,000 --> 01:03:30,000
Lad os afslutte dette op.

905
01:03:30,000 --> 01:03:32,000
Vi har beregnet vores midtpunkt.

906
01:03:32,000 --> 01:03:37,000
>> Vi tester, om vores nålen er lig med middelværdien.

907
01:03:37,000 --> 01:03:41,000
Vi udskriver, at vi fandt det, men virkelig, hvad vi ønsker at gøre i denne situation?

908
01:03:41,000 --> 01:03:46,000
Vi har fundet det, så vi ønsker at lade den, der ringer vide, at vi fandt det.

909
01:03:46,000 --> 01:03:49,000
Vi har en funktion, der er en boolean maskinskrevet funktion.

910
01:03:49,000 --> 01:03:54,000
Den måde, vi signalere til den, der ringer på vores funktion, at vi er klar til at gå

911
01:03:54,000 --> 01:03:58,000
er vi siger, "Hey, det er sandt."

912
01:03:58,000 --> 01:04:00,000
Hvordan ville vi gøre det, Kevin?

913
01:04:00,000 --> 01:04:02,000
Du nikker hovedet. >> [Kevin] Tilføj afkast sandt.

914
01:04:02,000 --> 01:04:06,000
[Nate] Præcis, returnere sandt.

915
01:04:06,000 --> 01:04:12,000
Nu, hvis det ikke er lige, hvordan ville vi se på den venstre halvdel?

916
01:04:12,000 --> 01:04:16,000
Nogen ideer?

917
01:04:16,000 --> 01:04:18,000
Stella, nogen ideer?

918
01:04:18,000 --> 01:04:21,000
Du skal angive en ny position for enden.

919
01:04:21,000 --> 01:04:23,000
Yeah.

920
01:04:23,000 --> 01:04:29,000
Så vi er nødt til at gøre placeringen af ​​midtpunktet - enden.

921
01:04:29,000 --> 01:04:33,000
Great.

922
01:04:33,000 --> 01:04:36,000
Vi er nødt til at indstille en ny position for enden

923
01:04:36,000 --> 01:04:38,000
at se på den venstre halvdel.

924
01:04:38,000 --> 01:04:41,000
Det var, hvad vi talte om før, hvor

925
01:04:41,000 --> 01:04:44,000
Jeg holde gå tilbage til dette eksempel.

926
01:04:44,000 --> 01:04:50,000
Jeg har den begynde her, og så har jeg enden hele vejen herover.

927
01:04:50,000 --> 01:04:53,000
>> Igen, hvis vi leder efter 15, og vores midtpunkt er på 16,

928
01:04:53,000 --> 01:04:56,000
og vi er klar over, "Ups, 16 er større.

929
01:04:56,000 --> 01:04:59,000
Vi ønsker at flytte til den venstre halvdel. "

930
01:04:59,000 --> 01:05:02,000
Vi ville derefter flytte ende til 15,

931
01:05:02,000 --> 01:05:06,000
og vi gør det ved at tage en væk fra midtpunktet

932
01:05:06,000 --> 01:05:09,000
og indstilling, der som ny ende.

933
01:05:09,000 --> 01:05:12,000
Ligeledes, hvis vi ønsker at se på den højre halvdel, hvordan ville vi gø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 skal bare indstille begynde at Midtpunkt + 1.

936
01:05:22,000 --> 01:05:24,000
[Nate] Great.

937
01:05:24,000 --> 01:05:29,000
Og nu i tilfælde af, at vi ikke finder noget,

938
01:05:29,000 --> 01:05:32,000
betyder det får taget sig af for os?

939
01:05:32,000 --> 01:05:36,000
Daniel, betyder det får taget sig af for os?

940
01:05:36,000 --> 01:05:38,000
[Daniel] Nej.

941
01:05:38,000 --> 01:05:40,000
[Nate] Hvis vi gør det gennem hele systemet, og vi ikke kan finde noget,

942
01:05:40,000 --> 01:05:42,000
hvor ville det blive taget sig af, eller skal vi tage os af det?

943
01:05:42,000 --> 01:05:44,000
[Daniel] The længe betingelse.

944
01:05:44,000 --> 01:05:48,000
[Nate] Yeah, imens tilstand, præcis.

945
01:05:48,000 --> 01:05:51,000
Det vil tage sig af at gå gennem hele systemet, hvis vi ikke finder noget.

946
01:05:51,000 --> 01:05:53,000
Denne while-løkke vil ende.

947
01:05:53,000 --> 01:05:56,000
Vi vil aldrig har mødt denne betingelse,

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å lade dette hvis i sådan her

950
01:06:10,000 --> 01:06:14,000
fordi hvis dette, hvis udsagn er sandt,

951
01:06:14,000 --> 01:06:16,000
og vores funktion vil vende tilbage,

952
01:06:16,000 --> 01:06:21,000
og så vil vi hovedsageligt afbryde denne funktion på dette punkt

953
01:06:21,000 --> 01:06:24,000
når vi vender tilbage sandt.

954
01:06:24,000 --> 01:06:28,000
Men hvad sker der med denne struktur her?

955
01:06:28,000 --> 01:06:34,000
Vil dette arbejde helt, eller er der nogle logiske fejl derinde?

956
01:06:34,000 --> 01:06:37,000
>> Der er nogle logiske fejl derinde, med den måde det er sat op.

957
01:06:37,000 --> 01:06:40,000
Hvad kan det være?

958
01:06:40,000 --> 01:06:43,000
[Student] Hvorfor har du brug for - og + 1s?

959
01:06:43,000 --> 01:06:47,000
Det sætter vores array op til at være vores nye venstre halvdel og højre halvdel.

960
01:06:47,000 --> 01:06:51,000
[Student] Men hvorfor kunne du ikke gøre det uden - 1s og + 1s?

961
01:06:51,000 --> 01:06:53,000
[Nate] Vi kunne sætte det lig med midtpunktet?

962
01:06:53,000 --> 01:07:04,000
Hvad kan være problematisk ved det?

963
01:07:04,000 --> 01:07:08,000
[Student] Jeg tror det er ineffektiv, fordi du tjekker en værdi, der allerede er blevet kontrolleret.

964
01:07:08,000 --> 01:07:11,000
[Nate] Præcis, så Sam er helt rigtigt.

965
01:07:11,000 --> 01:07:15,000
Hvis du indstiller ende og begynde lig midtpunktet

966
01:07:15,000 --> 01:07:18,000
i stedet for - 1 og + 1 refleksivt,

967
01:07:18,000 --> 01:07:22,000
på et tidspunkt i fremtiden vil vi ende med at kontrollere midtpunktet igen.

968
01:07:22,000 --> 01:07:26,000
[Student] Jeg startede Pset, og så havde jeg noget lignende

969
01:07:26,000 --> 01:07:30,000
hvor jeg glemte + 1, og det fik stukket i en uendelig løkke.

970
01:07:30,000 --> 01:07:34,000
Ret, fordi på et tidspunkt, du aldrig kommer til at få begynder og slutter

971
01:07:34,000 --> 01:07:39,000
til faktisk overlappe.

972
01:07:39,000 --> 01:07:41,000
Cool.

973
01:07:41,000 --> 01:07:44,000
Der er en mere logisk fejl, og det er, at dette absolut bør være

974
01:07:44,000 --> 01:07:48,000
en else if.

975
01:07:48,000 --> 01:07:55,000
Hvad kan det skyldes?

976
01:07:55,000 --> 01:07:59,000
>> Årsagen er, hvis det ikke er en ellers hvis-har du se det, Kevin?

977
01:07:59,000 --> 01:08:02,000
[Kevin] Ja, fordi du ændrer slutpunktet.

978
01:08:02,000 --> 01:08:05,000
[Nate] Præcis.

979
01:08:05,000 --> 01:08:07,000
Vi er ved at ændre endpoint,

980
01:08:07,000 --> 01:08:12,000
og hvis det er skrevet på denne måde-vi gøre mellemrum mellem-

981
01:08:12,000 --> 01:08:14,000
Det vil kontrollere denne sag.

982
01:08:14,000 --> 01:08:18,000
Denne sag, hvis det lykkes, vil afbryde ud af funktionen.

983
01:08:18,000 --> 01:08:21,000
Så vil det kontrollere dette næste sag,

984
01:08:21,000 --> 01:08:24,000
og hvis det lykkes, vil det justere endpoint,

985
01:08:24,000 --> 01:08:28,000
og så vil det fortsætte og tjek denne sag.

986
01:08:28,000 --> 01:08:31,000
Men på dette punkt, vi ikke ønsker, at fortsætte kontrollen.

987
01:08:31,000 --> 01:08:35,000
Heldigvis har vi ikke nulstille midtpunktet her,

988
01:08:35,000 --> 01:08:39,000
og vi ved, at denne sag ikke vil lykkes.

989
01:08:39,000 --> 01:08:44,000
Men vi vil helt sikkert sætte else if derinde

990
01:08:44,000 --> 01:08:48,000
selv om dette kunne, i dette tilfælde

991
01:08:48,000 --> 01:08:52,000
da vi ikke er at justere midtpunktet, ville det gøre en forskel?

992
01:08:52,000 --> 01:08:54,000
Nej, fordi disse sager er alle eksklusive.

993
01:08:54,000 --> 01:08:58,000
Igen, mit dårlige.

994
01:08:58,000 --> 01:09:01,000
Vi har ikke, tror jeg, har brug for dette andet, hvis.

995
01:09:01,000 --> 01:09:05,000
Vi kan give det en chance og køre det og se hvad der sker.

996
01:09:05,000 --> 01:09:08,000
Bygning, der opstod en fejl.

997
01:09:08,000 --> 01:09:12,000
Det er nok fordi jeg forlod disse B og e s herinde.

998
01:09:12,000 --> 01:09:14,000
Har jeg nogen flere af dem op på toppen?

999
01:09:14,000 --> 01:09:16,000
Det ligner ikke det.

1000
01:09:16,000 --> 01:09:20,000
Vi zoome ud, bygge,

1001
01:09:20,000 --> 01:09:24,000
der det går, så nu, hvis vi søger efter 15,

1002
01:09:24,000 --> 01:09:28,000
Ja.

1003
01:09:28,000 --> 01:09:30,000
Lad mig zoome ind

1004
01:09:30,000 --> 01:09:33,000
15, ja. Vi kan køre det igen.

1005
01:09:33,000 --> 01:09:36,000
Uploading kildekode, bygning, der kører.

1006
01:09:36,000 --> 01:09:41,000
Vi kan søge efter noget i retning af 13,

1007
01:09:41,000 --> 01:09:45,000
og vi får ikke noget at udskrive, så det er ikke konstateret, at for os.

1008
01:09:45,000 --> 01:09:51,000
Det er godt, fordi det ikke er i vores liste.

1009
01:09:51,000 --> 01:09:53,000
>> Vi er nu ude af tid.

1010
01:09:53,000 --> 01:09:55,000
Det kommer til at være det for denne uge.

1011
01:09:55,000 --> 01:10:00,000
Tak for sammenføjning, og se dig senere.

1012
01:10:00,000 --> 01:10:02,000
>> [CS50.TV]