1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Sectie 3] [minder comfortabel]

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

3
00:00:05,000 --> 00:00:08,000
>> [Dit is CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Oke, laten we beginnen.

5
00:00:10,000 --> 00:00:13,000
Welkom bij Week 4 van CS50.

6
00:00:13,000 --> 00:00:19,000
Als jullie het openen van een web browser en open te stellen PSET 3,

7
00:00:19,000 --> 00:00:23,000
Scramble met CS50, we gaan om te beginnen gaan

8
00:00:23,000 --> 00:00:26,000
via de rubriek van vragen daar.

9
00:00:26,000 --> 00:00:32,000
Net als vorige week, we werken in CS50 Spaces,

10
00:00:32,000 --> 00:00:35,000
als je ook trek die omhoog als goed,

11
00:00:35,000 --> 00:00:43,000
en als je verder gaan en bezoek deze link die ik heb hier op naar de top.

12
00:00:43,000 --> 00:00:45,000
Het is tijd om te beginnen.

13
00:00:45,000 --> 00:00:51,000
We hebben onze kleine hi programma hier. Niets gek.

14
00:00:51,000 --> 00:00:55,000
Een van de eerste dingen die ik wil doen met jullie vandaag gaan over een paar oplossingen

15
00:00:55,000 --> 00:00:58,000
naar Problem Set 1, een soort van voorbeeld oplossingen,

16
00:00:58,000 --> 00:01:03,000
zodat je kunt krijgen een gevoel voor welke soorten code personeel is het schrijven,

17
00:01:03,000 --> 00:01:07,000
wat voor soort code andere studenten schrijven,

18
00:01:07,000 --> 00:01:10,000
en heb je een kijkje nemen op het omdat ik weet dat het raar is

19
00:01:10,000 --> 00:01:14,000
wanneer u een oplossing voor een probleem set en krijgt commentaar

20
00:01:14,000 --> 00:01:18,000
op uw eigen versie, maar soms is het handig om te zien hoe andere mensen het deed,

21
00:01:18,000 --> 00:01:22,000
met name degenen die zijn mooi ogende.

22
00:01:22,000 --> 00:01:27,000
Voor het grootste deel, was ik echt onder de indruk van de oplossingen die jullie gemaakt.

23
00:01:27,000 --> 00:01:31,000
Ik ben nog niet begonnen met te kijken naar uw probleem Set 2s, maar als ze iets als de eerste,

24
00:01:31,000 --> 00:01:34,000
het betekent niets dan goede dingen.

25
00:01:34,000 --> 00:01:40,000
>> Als je kijkt naar mijn revisies, laten we beginnen helemaal naar beneden op Revisie 1,

26
00:01:40,000 --> 00:01:47,000
en we gaan een snelle blik op een Mario-oplossing te nemen.

27
00:01:47,000 --> 00:01:54,000
Als je trek deze omhoog, deze programma's dat we gaan presenteren correct zijn.

28
00:01:54,000 --> 00:01:56,000
Er waren niet juistheid problemen met deze problemen, maar eerder,

29
00:01:56,000 --> 00:01:59,000
willen we een beetje praten over de verschillende ontwerpaspecten

30
00:01:59,000 --> 00:02:03,000
die werden hier gebruikt.

31
00:02:03,000 --> 00:02:08,000
Een van de dingen die interessant was over de oplossing

32
00:02:08,000 --> 00:02:11,000
is dat het dit nieuwe construct genaamd pond te definiëren gebruikt,

33
00:02:11,000 --> 00:02:15,000
soms ook aangeduid als een hash definiëren.

34
00:02:15,000 --> 00:02:18,000
Laat me hier inzoomen op.

35
00:02:18,000 --> 00:02:24,000
Een # define kunt u een naam geven deze nummers in uw programma.

36
00:02:24,000 --> 00:02:28,000
In dit geval is de maximale hoogte van een piramide in Mario

37
00:02:28,000 --> 00:02:34,000
werd 23 en in plaats van dat 23 in mijn code-

38
00:02:34,000 --> 00:02:37,000
wij verwijzen naar dat zo hard codering 23 -

39
00:02:37,000 --> 00:02:43,000
in plaats daarvan geeft dit de naam MAX_HEIGHT naar dat nummer,

40
00:02:43,000 --> 00:02:48,000
zodat hier in mijn do-while-lus

41
00:02:48,000 --> 00:02:51,000
je kunt eigenlijk verwijzen naar MAX_HEIGHT

42
00:02:51,000 --> 00:02:55,000
in plaats van dat het nummer 23 inch

43
00:02:55,000 --> 00:02:57,000
[Student] Wat is het voordeel om dat te doen?

44
00:02:57,000 --> 00:02:59,000
Dat is een grote vraag.

45
00:02:59,000 --> 00:03:03,000
Een daarvan is de leesbaarheid.

46
00:03:03,000 --> 00:03:08,000
Een voordeel van deze # define is leesbaarheid.

47
00:03:08,000 --> 00:03:11,000
Als ik deze code te lezen, kan ik zien wat er gaande is.

48
00:03:11,000 --> 00:03:15,000
>> Ik zie hier in deze toestand dat we testen

49
00:03:15,000 --> 00:03:19,000
voor de hoogte wordt <0, wat we ook zouden kunnen hebben gedefinieerd

50
00:03:19,000 --> 00:03:22,000
, een minimum of min hoog zijn.

51
00:03:22,000 --> 00:03:25,000
Het andere voordeel is dat ik dan kan de rest van de regel te lezen om te zien

52
00:03:25,000 --> 00:03:30,000
dat we ook controleren om ervoor te zorgen dat de hoogte niet groter is dan de maximale hoogte,

53
00:03:30,000 --> 00:03:35,000
want we gaan verder terwijl de hoogte groter is dan de maximale hoogte.

54
00:03:35,000 --> 00:03:40,000
Het andere voordeel is, als ik uit te zoomen een beetje hier-

55
00:03:40,000 --> 00:03:49,000
als ik zonder dit programma en ik voer het uit, zeg, met 23 op dit moment,

56
00:03:49,000 --> 00:03:52,000
zal het afdrukken alle 23 rijen zomaar.

57
00:03:52,000 --> 00:03:54,000
Maar zeggen dat ik wilde de max. hoogte te veranderen,

58
00:03:54,000 --> 00:03:57,000
en nu wil ik de maximale hoogte van piramides te beperken

59
00:03:57,000 --> 00:04:06,000
om alleen maar zeggen-man, dat was funky zijn.

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

61
00:04:14,000 --> 00:04:18,000
en laten we zeggen dat we wilden het gelijk is aan 10.

62
00:04:18,000 --> 00:04:22,000
Nu op dit moment, alles wat ik moest doen was wijzigen in dit ene locatie.

63
00:04:22,000 --> 00:04:27,000
Ik kan opnieuw compileren van de code, en nu als ik probeer en typ in 12,

64
00:04:27,000 --> 00:04:30,000
Het zal u vragen me weer.

65
00:04:30,000 --> 00:04:33,000
In dit geval zijn we alleen met behulp van MAX_HEIGHT een keer.

66
00:04:33,000 --> 00:04:37,000
Het is niet zo groot van een gedoe om in te gaan

67
00:04:37,000 --> 00:04:40,000
en verander het in de while-lus als dat nodig is.

68
00:04:40,000 --> 00:04:44,000
Maar in programma's waar je verwijzen naar de zelfde magische getal

69
00:04:44,000 --> 00:04:47,000
over en weer, deze # define mechanisme is erg handig

70
00:04:47,000 --> 00:04:52,000
omdat je gewoon veranderen het een keer aan de top van het bestand, het is meestal waar je ze-

71
00:04:52,000 --> 00:04:57,000
en de verandering sijpelt door de rest van het bestand.

72
00:04:57,000 --> 00:05:02,000
>> Andere dingen die ik wilde om op te merken in deze opdracht, dat ik dacht dat zag er erg leuk,

73
00:05:02,000 --> 00:05:05,000
was de naamgeving van de variabelen.

74
00:05:05,000 --> 00:05:14,000
Je ziet hier dat we integer variabelen genoemd rij en zogenaamde hoogtepunt.

75
00:05:14,000 --> 00:05:20,000
Spaces, hashes, het helpt om de code een beetje meer leesbaar,

76
00:05:20,000 --> 00:05:25,000
maakt het een beetje begrijpelijker wat er werkelijk aan de hand is.

77
00:05:25,000 --> 00:05:31,000
Dit in tegenstelling tot het gebruik van bijvoorbeeld willekeurige letters

78
00:05:31,000 --> 00:05:35,000
of gewoon gobbledygook helemaal.

79
00:05:35,000 --> 00:05:39,000
Een laatste ding dat ik wel opmerken is dat in voor lussen,

80
00:05:39,000 --> 00:05:45,000
vaak deze iterator variabelen, deze tellers die je in je gebruiken voor loops,

81
00:05:45,000 --> 00:05:51,000
het is standaard en conventionele te beginnen met i en dan j en dan k

82
00:05:51,000 --> 00:05:54,000
en gaan van daar als u meer variabelen,

83
00:05:54,000 --> 00:05:56,000
en dit is slechts een conventie.

84
00:05:56,000 --> 00:05:58,000
Er zijn veel overeenkomsten.

85
00:05:58,000 --> 00:06:00,000
Het hangt af van de programmeertaal die u gebruikt.

86
00:06:00,000 --> 00:06:04,000
Maar in C, we meestal beginnen met i.

87
00:06:04,000 --> 00:06:08,000
Het heeft geen zin om te gebruiken, laten we zeggen, op a of b

88
00:06:08,000 --> 00:06:13,000
afhankelijk van de situatie.

89
00:06:13,000 --> 00:06:15,000
Dat is het voor deze ene.

90
00:06:15,000 --> 00:06:25,000
Als u nu trek Revisie 2, zie je een andere Mario,

91
00:06:25,000 --> 00:06:29,000
en dit is gelijk aan de andere die we zagen,

92
00:06:29,000 --> 00:06:32,000
maar het doet iets wel cool.

93
00:06:32,000 --> 00:06:38,000
Als we kijken naar deze sectie hier binnen de binnenste for-lus,

94
00:06:38,000 --> 00:06:44,000
ze gebruiken wat gekke zoek syntax hier rechts in deze lijn.

95
00:06:44,000 --> 00:06:47,000
Dit wordt een ternaire operator.

96
00:06:47,000 --> 00:06:53,000
Het is een if else gecondenseerd in een lijn.

97
00:06:53,000 --> 00:06:57,000
De conditie is dit deel tussen haakjes.

98
00:06:57,000 --> 00:07:05,000
Het is als zeggen als j <hoogte - i - 1.

99
00:07:05,000 --> 00:07:10,000
En dan wat de inhoud van dat als blok zou zijn, zijn de ruimte

100
00:07:10,000 --> 00:07:16,000
en dan de inhoud van wat de ander zou zijn zijn deze #.

101
00:07:16,000 --> 00:07:20,000
Het is in wezen het toewijzen van een ruimte om deze variabele.

102
00:07:20,000 --> 00:07:24,000
Het Een spatie in de inhoud van het blok variabele

103
00:07:24,000 --> 00:07:29,000
Als deze voorwaarde is voldaan, en als de voorwaarde niet is voldaan,

104
00:07:29,000 --> 00:07:32,000
vervolgens het blok variabele krijgt deze #.

105
00:07:32,000 --> 00:07:37,000
En, natuurlijk, in plaats van het opbouwen van een gehele reeks

106
00:07:37,000 --> 00:07:43,000
en printen alles aan het eind van deze oplossing drukt het uit een karakter per keer.

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

108
00:07:48,000 --> 00:07:53,000
>> Nog een paar van de dingen om naar te kijken. We gaan naar hebberig.

109
00:07:53,000 --> 00:07:58,000
Als we nu kijken naar hebberig, deze eerste oplossing

110
00:07:58,000 --> 00:08:00,000
gebruikt deze # definieert nogal wat.

111
00:08:00,000 --> 00:08:06,000
We hebben een constante gedefinieerd voor elk van de verschillende nummers in dit programma.

112
00:08:06,000 --> 00:08:12,000
We hebben een voor cent per dollar, een voor kwartalen, dubbeltjes, stuivers en centen,

113
00:08:12,000 --> 00:08:15,000
en nu als we scroll naar beneden en lees de code,

114
00:08:15,000 --> 00:08:22,000
zien we een standaard do-while-lus afdrukken alles uit.

115
00:08:22,000 --> 00:08:25,000
Kind van de kern van dit probleem is het besef dat

116
00:08:25,000 --> 00:08:29,000
u nodig om de vlotter te zetten die je leest in van de gebruiker naar een geheel getal

117
00:08:29,000 --> 00:08:32,000
om nauwkeurig do the math, en dit is omdat

118
00:08:32,000 --> 00:08:36,000
met floating point getallen, zoals we besproken in college kort,

119
00:08:36,000 --> 00:08:41,000
het is niet mogelijk om nauwkeurig te vertegenwoordigen elke waarde op de getallenlijn

120
00:08:41,000 --> 00:08:47,000
want er zijn oneindig veel waarden tussen 3 en, zeg, 3,1 zelfs.

121
00:08:47,000 --> 00:08:54,000
U kunt 3,01 en 3,001 en 3,0001, en je kunt blijven gaan.

122
00:08:54,000 --> 00:09:00,000
Het blijkt wanneer je werkt met geld, je vaak wilt converteren

123
00:09:00,000 --> 00:09:05,000
in integer formaat, zodat je niet verliest centen en dat soort dingen.

124
00:09:05,000 --> 00:09:09,000
Dat te doen en afronding was de sleutel.

125
00:09:09,000 --> 00:09:14,000
Deze oplossing gebruikt een perfect eenvoudige, goed algoritme,

126
00:09:14,000 --> 00:09:17,000
die verlaagd het aantal centen blijven, eerst door kwartalen,

127
00:09:17,000 --> 00:09:19,000
vervolgens door dubbeltjes, vervolgens door stuivers, vervolgens door centen,

128
00:09:19,000 --> 00:09:24,000
en toevoegen aan het aantal munten per keer.

129
00:09:24,000 --> 00:09:31,000
>> Een andere oplossing die we zullen zien, zoals ik uit te zoomen en ga naar Herziening 4,

130
00:09:31,000 --> 00:09:40,000
had een zeer vergelijkbaar begin, maar in plaats daarvan gebruikt div en mod

131
00:09:40,000 --> 00:09:44,000
rechts over hier om het aantal centen te berekenen.

132
00:09:44,000 --> 00:09:50,000
Dit is het aantal kwarten gelijk is aan het aantal cents gedeeld door 25,

133
00:09:50,000 --> 00:09:53,000
en de reden dat dit werkt is omdat we doen integer deling,

134
00:09:53,000 --> 00:09:58,000
dus het is waarbij een eventueel restant.

135
00:09:58,000 --> 00:10:02,000
[Student] Moeten we de zoektocht commentaar geven?

136
00:10:02,000 --> 00:10:05,000
Het hangt echt.

137
00:10:05,000 --> 00:10:08,000
[Student] Je commentaar meer dan code hier.

138
00:10:08,000 --> 00:10:16,000
Ja, en zo zijn er een heleboel verschillende filosofieën op dit punt.

139
00:10:16,000 --> 00:10:21,000
Mijn persoonlijke filosofie is dat je code echt de waarheid,

140
00:10:21,000 --> 00:10:24,000
als uw code is wat er feitelijk niet uitgevoerd op de computer,

141
00:10:24,000 --> 00:10:29,000
en dus de code moet zo leesbaar mogelijk te niet noodzakelijk zo veel commentaar.

142
00:10:29,000 --> 00:10:33,000
Dat gezegd hebbende, als je dingen die soort doen mathematisch van lastige

143
00:10:33,000 --> 00:10:38,000
of algoritmisch, het is goed om te reageren degenen, zodat u kunt

144
00:10:38,000 --> 00:10:43,000
een extra dimensie, een extra laag aan wie het lezen van uw code.

145
00:10:43,000 --> 00:10:49,000
In deze oplossingen, vaak worden ze zwaarder, alleen maar omdat commentaar

146
00:10:49,000 --> 00:10:52,000
We willen in staat zijn om ze te distribueren en er mensen ophalen

147
00:10:52,000 --> 00:10:56,000
en lees ze vrij gemakkelijk.

148
00:10:56,000 --> 00:11:05,000
Maar zeker, ik ben het eens dat dit zwaar is.

149
00:11:05,000 --> 00:11:07,000
[Student] Maar als je twijfelt, ga dan zwaarder?

150
00:11:07,000 --> 00:11:10,000
Als je twijfelt, ga zwaarder.

151
00:11:10,000 --> 00:11:17,000
Sommige mensen zullen zeggen soms return 0 of iets dergelijks.

152
00:11:17,000 --> 00:11:20,000
Ik denk dat het een belachelijke opmerking.

153
00:11:20,000 --> 00:11:22,000
Het is duidelijk dat dat is wat er gebeurt.

154
00:11:22,000 --> 00:11:25,000
Ik hoef niet Engels om me te vertellen dat.

155
00:11:25,000 --> 00:11:28,000
Soms zullen mensen schrijven dingen als "kthxbai!"

156
00:11:28,000 --> 00:11:32,000
Dat is wel leuk, maar ook niet-

157
00:11:32,000 --> 00:11:35,000
dat is niet het maken van het verschil tussen commentaar punten of niet.

158
00:11:35,000 --> 00:11:41,000
Dat soort opmerkingen zijn gewoon ha, ha.

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

160
00:11:43,000 --> 00:11:48,000
>> Op dit punt, laten we beginnen werken aan het probleem Set 3 deel van de vragen.

161
00:11:48,000 --> 00:11:52,000
Als jullie trek deze weer op,

162
00:11:52,000 --> 00:11:55,000
zoals met vorige week, we niet van plan om de korte broek te kijken in dit hoofdstuk.

163
00:11:55,000 --> 00:12:00,000
We laten jullie dat doen op uw eigen tijd en praten over de vragen.

164
00:12:00,000 --> 00:12:05,000
Maar nu in deze paragraaf gaan we wat meer tijd door te brengen

165
00:12:05,000 --> 00:12:11,000
praten over minder van de coderende basics

166
00:12:11,000 --> 00:12:15,000
zoals wij deden vorige week, en in plaats daarvan, gaan we meer focussen op

167
00:12:15,000 --> 00:12:22,000
een beetje meer van de theorie, zodat het over binary search en dan sorteren.

168
00:12:22,000 --> 00:12:27,000
Van degenen onder u die zijn samen volgt met de lezing,

169
00:12:27,000 --> 00:12:30,000
kan iemand mij een samenvatting van wat het verschil is

170
00:12:30,000 --> 00:12:35,000
tussen binair zoeken en lineaire zoeken?

171
00:12:35,000 --> 00:12:37,000
Wat is er aan de hand? Tuurlijk.

172
00:12:37,000 --> 00:12:42,000
Lineair zoeken doorzoekt elk element in de gesorteerde lijst

173
00:12:42,000 --> 00:12:45,000
een voor een door een voor een een,

174
00:12:45,000 --> 00:12:50,000
en binair zoeken verdeelt de lijst in 2 groepen,

175
00:12:50,000 --> 00:12:57,000
controleert of de sleutels waarde die u zoekt is groter dan of kleiner dan het midden-waarde

176
00:12:57,000 --> 00:13:00,000
dat je net gevonden, en als het minder dan, het gaat met de onderste lijst

177
00:13:00,000 --> 00:13:03,000
en dan verdeelt dat opnieuw, doet dezelfde functie

178
00:13:03,000 --> 00:13:07,000
helemaal naar beneden tot hij het midden gelijk aan de waarde zelf.

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

180
00:13:10,000 --> 00:13:12,000
>> Waarom hebben we schelen?

181
00:13:12,000 --> 00:13:20,000
Waarom praten we over binary search versus lineair zoeken?

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

183
00:13:22,000 --> 00:13:24,000
Binaire is een stuk sneller, dus als je het dubbele van de omvang van het probleem

184
00:13:24,000 --> 00:13:27,000
duurt een stap dan tweemaal zoveel.

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

186
00:13:29,000 --> 00:13:31,000
Dat is een geweldig antwoord.

187
00:13:31,000 --> 00:13:36,000
Lineair zoeken is zeer controleert een element tegelijk,

188
00:13:36,000 --> 00:13:39,000
en zoals we zagen op de eerste dag van de lezing

189
00:13:39,000 --> 00:13:42,000
toen David ging door zijn telefoonboek voorbeeld

190
00:13:42,000 --> 00:13:45,000
en scheurde uit een pagina van het telefoonboek op een moment

191
00:13:45,000 --> 00:13:47,000
en bleef dat te doen over en over en weer,

192
00:13:47,000 --> 00:13:51,000
het gaat om hem een ​​hele lange tijd voor iedereen in het telefoonboek te vinden,

193
00:13:51,000 --> 00:13:55,000
tenzij, natuurlijk, werd hij op zoek naar iemand aan het begin van het alfabet.

194
00:13:55,000 --> 00:14:00,000
Met binair zoeken, kunt u een stuk sneller,

195
00:14:00,000 --> 00:14:05,000
en het is niet alleen twee keer zo snel of 3 keer zo snel of 4 keer zo snel.

196
00:14:05,000 --> 00:14:13,000
Maar het probleem kleiner en kleiner veel sneller.

197
00:14:13,000 --> 00:14:17,000
Om dit te illustreren, zullen we praten beginnen over wat er aan de hand

198
00:14:17,000 --> 00:14:21,000
wanneer we binair zoeken schrijven.

199
00:14:21,000 --> 00:14:27,000
Het probleem bij de hand is, dat als ik een array van getallen,

200
00:14:27,000 --> 00:14:40,000
bijvoorbeeld 1, 2, 3, 5, 7, 23, 45, 78, 12,323,

201
00:14:40,000 --> 00:14:47,000
en dan 9 met een ton van 0s na,

202
00:14:47,000 --> 00:14:52,000
We willen in staat zijn om erachter te komen heel snel wat er in

203
00:14:52,000 --> 00:14:57,000
Deze reeks getallen.

204
00:14:57,000 --> 00:15:00,000
Ik weet dat dit lijkt een beetje dom en een beetje gekunsteld,

205
00:15:00,000 --> 00:15:02,000
want nu is het.

206
00:15:02,000 --> 00:15:05,000
We hebben een array die niet zeer veel elementen in,

207
00:15:05,000 --> 00:15:08,000
en als ik een van jullie vragen om erachter te komen of

208
00:15:08,000 --> 00:15:11,000
23 is in de array, dan kunt u dat doen vrij snel

209
00:15:11,000 --> 00:15:16,000
gewoon door een blik op deze en vertelde me ja of nee.

210
00:15:16,000 --> 00:15:20,000
De analoge om te overwegen is denken als dit, laten we zeggen,

211
00:15:20,000 --> 00:15:27,000
een Excel-spreadsheet met 10.000 rijen, 20.000 rijen.

212
00:15:27,000 --> 00:15:31,000
Natuurlijk, kunt u de opdracht F of de controle F en iets opzoeken.

213
00:15:31,000 --> 00:15:33,000
U kunt ook gebruik maken van de filters en de zoektocht spul,

214
00:15:33,000 --> 00:15:37,000
maar als je moest door die bestand regel zien door regel voor regel,

215
00:15:37,000 --> 00:15:40,000
het zou je een lange tijd om het te vinden.

216
00:15:40,000 --> 00:15:42,000
Het is een beetje zoals in het telefoonboek bijvoorbeeld, ook, waar

217
00:15:42,000 --> 00:15:44,000
niemand kijkt door een telefoonboek een pagina per keer.

218
00:15:44,000 --> 00:15:47,000
Typisch, ze openen naar het midden,

219
00:15:47,000 --> 00:15:50,000
of in het geval van veel van de telefoon boeken en woordenboeken, waar

220
00:15:50,000 --> 00:15:54,000
u daadwerkelijk hebt ingetoetst op de eerste letter,

221
00:15:54,000 --> 00:16:01,000
je klep om die eerste brief en openen en doorlopen daar.

222
00:16:01,000 --> 00:16:03,000
>> Doet me denken aan je naam weer. >> Sam.

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

224
00:16:05,000 --> 00:16:11,000
Zoals Sam zegt, is dat lineaire zoekproces gaat om echt traag,

225
00:16:11,000 --> 00:16:15,000
en in plaats daarvan met binair zoeken, de manier waarop dit werkt is dat

226
00:16:15,000 --> 00:16:21,000
elke keer als we gaan door een iteratie van onze zoeken algoritme,

227
00:16:21,000 --> 00:16:27,000
we gaan naar de lijst te verdelen in de helft, in wezen,

228
00:16:27,000 --> 00:16:33,000
in twee kleinere lijsten.

229
00:16:33,000 --> 00:16:39,000
En dan op de volgende iteratie van de lus, zullen we weer verdelen

230
00:16:39,000 --> 00:16:44,000
in andere kleinere lijsten.

231
00:16:44,000 --> 00:16:48,000
Zoals u kunt zien, blijft het probleem steeds kleiner en kleiner

232
00:16:48,000 --> 00:16:55,000
omdat we houden weggooien helft van de lijst elke keer weer.

233
00:16:55,000 --> 00:16:59,000
Hoe werkt deze aftrek zijn werk?

234
00:16:59,000 --> 00:17:05,000
Even ter herinnering, wat we gaan doen als we een computer

235
00:17:05,000 --> 00:17:11,000
en we waren, zeggen, op zoek naar de nummer 5 in deze lijst

236
00:17:11,000 --> 00:17:15,000
is dat we zouden kies een nummer in het midden.

237
00:17:15,000 --> 00:17:26,000
In het midden van deze lijst, omdat er 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 nummers,

238
00:17:26,000 --> 00:17:32,000
we halen het nummer tijdens de 4e positie of op de 5e positie,

239
00:17:32,000 --> 00:17:38,000
en noemen we dat het midden van onze lijst.

240
00:17:38,000 --> 00:17:42,000
Kies aantal in het midden.

241
00:17:42,000 --> 00:17:51,000
Dan, net zoals Sam zei, zullen we testen om te zien of dat aantal is gelijk

242
00:17:51,000 --> 00:17:59,000
om het nummer dat we willen krijgen of onze gewenste nummer.

243
00:17:59,000 --> 00:18:06,000
Als het gelijk, dan hebben we het gevonden. We winnen.

244
00:18:06,000 --> 00:18:12,000
Als het niet gelijk zijn, dan zijn er een paar gevallen.

245
00:18:12,000 --> 00:18:15,000
De twee gevallen zijn ofwel het aantal moet groter zijn dan het aantal waar we naar kijken,

246
00:18:15,000 --> 00:18:19,000
of het is minder dan.

247
00:18:19,000 --> 00:18:25,000
Als het groter is, gaan we naar rechts.

248
00:18:25,000 --> 00:18:33,000
En als het minder, gaan we naar links.

249
00:18:33,000 --> 00:18:41,000
En dan hebben we herhalen het hele proces

250
00:18:41,000 --> 00:18:48,000
op de rechtse helft of de linkerhelft van de lijst.

251
00:18:48,000 --> 00:18:51,000
>> Het eerste probleem in rubriek van vandaag is om erachter te komen

252
00:18:51,000 --> 00:18:55,000
hoe kunnen we daadwerkelijk beginnen om dit uit te drukken in C-code.

253
00:18:55,000 --> 00:18:58,000
We hebben de pseudocode hier.

254
00:18:58,000 --> 00:19:04,000
Wat we gaan doen is Ik trek een gloednieuwe ruimte,

255
00:19:04,000 --> 00:19:09,000
bewaar deze herziening, zodat we deze notities voor later,

256
00:19:09,000 --> 00:19:20,000
we verwijderen dit alles, en dan kopiëren en plakken vanuit het probleem set

257
00:19:20,000 --> 00:19:26,000
deze informatie in onze ruimtes, en hopelijk niet breekt.

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

259
00:19:28,000 --> 00:19:33,000
Als jullie allemaal doen, kopiëren en plak deze code in uw nieuwe ruimte,

260
00:19:33,000 --> 00:19:43,000
in een blanco kaart.

261
00:19:43,000 --> 00:19:47,000
Laten we proberen Daniel. Als je compileren en uitvoeren van dit programma, werkt het?

262
00:19:47,000 --> 00:19:49,000
Nee. >> Wat zegt het?

263
00:19:49,000 --> 00:19:53,000
Het zegt dat de controle bereikt einde van niet-void functie.

264
00:19:53,000 --> 00:19:55,000
Ja, dus laat me proberen het runnen van het.

265
00:19:55,000 --> 00:19:59,000
Hebben jullie dit eerder gezien? Weet je wat dit betekent?

266
00:19:59,000 --> 00:20:01,000
Oke, laten we ontleden dit een beetje.

267
00:20:01,000 --> 00:20:10,000
Het zegt op file.c op lijn 9, kolom 1 hebben we een fout hebben, net zoals je zei,

268
00:20:10,000 --> 00:20:16,000
en het zegt dat het is als gevolg van de fout waarschuwing en de return type waarschuwing.

269
00:20:16,000 --> 00:20:18,000
Het lijkt erop dat er iets aan de hand is met de terugkeer type, wat logisch is.

270
00:20:18,000 --> 00:20:21,000
We hebben een niet-leegte functie gekregen, wat betekent dat we een functie hebben

271
00:20:21,000 --> 00:20:24,000
dat niet ledig terugkeren.

272
00:20:24,000 --> 00:20:27,000
Een leegte functie is er een die er zo uitziet:

273
00:20:27,000 --> 00:20:35,000
leegte foo (), en het is nietig omdat de return type is nietig,

274
00:20:35,000 --> 00:20:38,000
wat betekent dat als we hier iets

275
00:20:38,000 --> 00:20:45,000
zoals return 1, zouden we een compiler error voor.

276
00:20:45,000 --> 00:20:49,000
We hebben echter een niet-void functie.

277
00:20:49,000 --> 00:20:51,000
Onze niet-void functie is in dit geval onze zoekfunctie

278
00:20:51,000 --> 00:20:56,000
omdat het een return type van de bool.

279
00:20:56,000 --> 00:20:59,000
Wanneer het zegt dat de controle na een non-void functie bereikt,

280
00:20:59,000 --> 00:21:02,000
het is omdat zoekopdracht heeft geen return-statement.

281
00:21:02,000 --> 00:21:04,000
Het is niet wat terugstuurt van het type bool.

282
00:21:04,000 --> 00:21:09,000
>> We kunnen vaststellen dat, en wat doen jullie denken

283
00:21:09,000 --> 00:21:13,000
zoek moeten terugkeren standaard?

284
00:21:13,000 --> 00:21:16,000
Wat moet de standaard return waarde van search zijn?

285
00:21:16,000 --> 00:21:19,000
Want dat is wat we kunnen aan het eind.

286
00:21:19,000 --> 00:21:21,000
Charlotte, heeft u-?

287
00:21:21,000 --> 00:21:23,000
Waar of niet waar? >> Waar of niet waar.

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

289
00:21:26,000 --> 00:21:28,000
False. Ik weet het niet.

290
00:21:28,000 --> 00:21:30,000
False? Laten we het eens proberen.

291
00:21:30,000 --> 00:21:32,000
Waarom zeg je return false? Dat is geweldig intuïtie.

292
00:21:32,000 --> 00:21:35,000
[Charlotte] Ik weet het niet.

293
00:21:35,000 --> 00:21:39,000
We gaan valse terug te keren in dit geval, want dit zal onze verzuim

294
00:21:39,000 --> 00:21:44,000
als om wat voor reden dan ook de lijst leeg is of de naald

295
00:21:44,000 --> 00:21:46,000
dat we op zoek naar bestaat niet.

296
00:21:46,000 --> 00:21:50,000
Dan aan het einde, als we niet echt eerder terug in deze functie,

297
00:21:50,000 --> 00:21:55,000
we altijd weten dat deze functie zal zeggen nope, het is niet in de array.

298
00:21:55,000 --> 00:21:58,000
Het is niet in de hooiberg.

299
00:21:58,000 --> 00:22:03,000
Als we nu samen te stellen en voer het uit-laat me bewaar deze zodat we kunnen trek het omhoog.

300
00:22:03,000 --> 00:22:08,000
Als we nu samen te stellen en uit te voeren ons programma, het bouwt.

301
00:22:08,000 --> 00:22:12,000
We krijgen onze kleine prompt.

302
00:22:12,000 --> 00:22:20,000
Als ik sloeg 4-uh-oh.

303
00:22:20,000 --> 00:22:25,000
Het zag er niet uit te printen niets. Het lijkt erop dat alles eindigde in orde.

304
00:22:25,000 --> 00:22:35,000
We moeten dit in te vullen inch

305
00:22:35,000 --> 00:22:39,000
We spraken over het algoritme in pseudocode een beetje geleden.

306
00:22:39,000 --> 00:22:44,000
Laat me eens kijken, sla dit,

307
00:22:44,000 --> 00:22:49,000
en Ik trek dat algoritme weer omhoog.

308
00:22:49,000 --> 00:22:51,000
Laten we gaan deze kerel. Nope.

309
00:22:51,000 --> 00:22:58,000
Daar is het.

310
00:22:58,000 --> 00:23:03,000
Hoe gaan we dit doen?

311
00:23:03,000 --> 00:23:11,000
Wat zou een goede strategie bij het wegrijden deze code zijn?

312
00:23:11,000 --> 00:23:16,000
Je moet een nummer in het midden te kiezen.

313
00:23:16,000 --> 00:23:23,000
Hoe kunnen we een aantal plukken in het midden van een array?

314
00:23:23,000 --> 00:23:25,000
Eventuele suggesties?

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

316
00:23:27,000 --> 00:23:32,000
Strlen gedeeld door 2. Dat is een goeie.

317
00:23:32,000 --> 00:23:35,000
Strlen werkt met speciale soorten arrays.

318
00:23:35,000 --> 00:23:38,000
Welke soorten arrays?

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

320
00:23:44,000 --> 00:23:48,000
Het is dat dezelfde soort concept dat we willen toepassen,

321
00:23:48,000 --> 00:23:52,000
maar we kunnen geen gebruik maken van strlen omdat we niet beschikken over een array van karakters.

322
00:23:52,000 --> 00:23:55,000
We hebben een scala aan ints.

323
00:23:55,000 --> 00:23:58,000
Maar wat betekent strlen krijgen voor ons?

324
00:23:58,000 --> 00:24:01,000
Weet je wat het wordt voor ons?

325
00:24:01,000 --> 00:24:03,000
[Student] strlen brengt ons de lengte.

326
00:24:03,000 --> 00:24:05,000
Precies, het wordt ons de lengte.

327
00:24:05,000 --> 00:24:09,000
Strlen krijgt de lengte van de array voor ons.

328
00:24:09,000 --> 00:24:14,000
>> Hoe krijgen we dat in onze binary search programma?

329
00:24:14,000 --> 00:24:18,000
Hoe zou je de lengte van een array?

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

331
00:24:20,000 --> 00:24:25,000
U kunt de lengte van een juist geformatteerd C snaar array met strlen.

332
00:24:25,000 --> 00:24:31,000
Het probleem is echter dat we niet beschikken over een string array.

333
00:24:31,000 --> 00:24:36,000
Als we terugkijken naar deze code, hebben we dit integer array.

334
00:24:36,000 --> 00:24:38,000
Hoe weten we hoe lang het is?

335
00:24:38,000 --> 00:24:44,000
[Student] Is er een equivalent een voor eindpunt, zoals int l of zo?

336
00:24:44,000 --> 00:24:49,000
Het blijkt dat er eigenlijk niet is, en dus in zekere zin is dit

337
00:24:49,000 --> 00:24:52,000
een van die dingen die gewoon goed om te weten over C,

338
00:24:52,000 --> 00:24:57,000
dat er geen manier om de lengte van een array te krijgen

339
00:24:57,000 --> 00:24:59,000
Als alles wat ik geven is de array.

340
00:24:59,000 --> 00:25:02,000
De reden dat het werkt met strijkers, de reden strlen werken,

341
00:25:02,000 --> 00:25:06,000
is omdat als een string is juist geformatteerd,

342
00:25:06,000 --> 00:25:12,000
zal hebben dat de speciale \ 0 karakter helemaal aan het eind.

343
00:25:12,000 --> 00:25:16,000
>> U kunt ook voorstellen dat als u een onjuist opgemaakte tekenreeks

344
00:25:16,000 --> 00:25:20,000
en er is er geen \ 0 karakter, dan is het hele ding werkt niet.

345
00:25:20,000 --> 00:25:22,000
[Student] kunt u de \ 0?

346
00:25:22,000 --> 00:25:24,000
We kunnen in dit geval.

347
00:25:24,000 --> 00:25:29,000
We kunnen toevoegen een soort van \ 0

348
00:25:29,000 --> 00:25:33,000
of een soort van betekenende karakter en gebruik die.

349
00:25:33,000 --> 00:25:36,000
Maar dat is niet helemaal gaat werken

350
00:25:36,000 --> 00:25:40,000
omdat de \ 0 is voor een char type,

351
00:25:40,000 --> 00:25:43,000
en hier hebben we ints.

352
00:25:43,000 --> 00:25:46,000
Het andere ding is als we een speciale waarde te gebruiken

353
00:25:46,000 --> 00:25:49,000
zoals -1 tot het einde van een array markeren

354
00:25:49,000 --> 00:25:54,000
dan kunnen we slaan nooit een -1 in onze integer arrays.

355
00:25:54,000 --> 00:25:56,000
We zouden worden geplakt.

356
00:25:56,000 --> 00:26:00,000
Het blijkt dat de enige manier om de lengte te krijgen

357
00:26:00,000 --> 00:26:03,000
van een array in C daadwerkelijk onthouden

358
00:26:03,000 --> 00:26:08,000
wanneer u het op en leid deze rond met de array

359
00:26:08,000 --> 00:26:14,000
zodat wanneer ik een functie die gaat wat werk te doen

360
00:26:14,000 --> 00:26:18,000
op een array van gehele getallen of vlotters of dubbelspel of wat dan ook,

361
00:26:18,000 --> 00:26:22,000
Ik moet ook de functie geven array lengte,

362
00:26:22,000 --> 00:26:26,000
en dat is precies wat we hier hebben gedaan in de zoekfunctie.

363
00:26:26,000 --> 00:26:30,000
Als je kijkt, wat we gedaan hebben toen we langs in ons aanbod hier,

364
00:26:30,000 --> 00:26:36,000
we ook langs de lengte, de grootte.

365
00:26:36,000 --> 00:26:41,000
Het gebeurt gewoon dat we deze variabele hier genoemd,

366
00:26:41,000 --> 00:26:43,000
deze parameter of argument.

367
00:26:43,000 --> 00:26:46,000
Dit heet een functie het argument van lijst of lijst met parameters,

368
00:26:46,000 --> 00:26:51,000
en deze worden ook wel argumenten of parameters.

369
00:26:51,000 --> 00:26:53,000
Mensen gebruiken verschillende termen op verschillende tijdstippen.

370
00:26:53,000 --> 00:26:55,000
Ik heb soms verwisselen ze zelf.

371
00:26:55,000 --> 00:27:00,000
Het is gewoon zo gebeurt het dat deze variabele hier eveneens wordt genoemd

372
00:27:00,000 --> 00:27:03,000
deze # hier te definiëren op.

373
00:27:03,000 --> 00:27:06,000
Maar ze zijn niet hetzelfde.

374
00:27:06,000 --> 00:27:11,000
De kapitalisatie er wel toe doet.

375
00:27:11,000 --> 00:27:14,000
>> Als je kijkt naar wat hier gebeurt, verklaren wij

376
00:27:14,000 --> 00:27:18,000
onze int array, die we hebben nummers.

377
00:27:18,000 --> 00:27:23,000
We hebben gezien dat onze omvang, wat overeenkomt met onze # up definiëren aan de top.

378
00:27:23,000 --> 00:27:27,000
Het gaat worden 8.

379
00:27:27,000 --> 00:27:35,000
En dan, als we dan contact op met onze zoekfunctie beneden,

380
00:27:35,000 --> 00:27:40,000
passeren we het aantal willen we zoeken, die we hebben gevraagd,

381
00:27:40,000 --> 00:27:43,000
gekregen van de gebruiker.

382
00:27:43,000 --> 00:27:46,000
We geven in het array, deze getallen,

383
00:27:46,000 --> 00:27:51,000
en dan ook geschieden in de grootte van de array,

384
00:27:51,000 --> 00:27:57,000
en dan de waarde van de maat 8 wordt opgeslagen

385
00:27:57,000 --> 00:28:01,000
of doorgegeven aan deze integer variabele genaamd grootte.

386
00:28:01,000 --> 00:28:08,000
Wij hebben de grootte van de matrix.

387
00:28:08,000 --> 00:28:11,000
Als we nu terug gaan naar waar we het over vroeger,

388
00:28:11,000 --> 00:28:14,000
Ik denk dat Missy bracht het punt dat wat we moesten doen is de lengte van de array

389
00:28:14,000 --> 00:28:20,000
en deel dit door 2, en dat geeft ons het middelpunt.

390
00:28:20,000 --> 00:28:22,000
Laten we eens kijken.

391
00:28:22,000 --> 00:28:25,000
Kan ik iemand dit schrijf en sla het op in hun ruimte?

392
00:28:25,000 --> 00:28:27,000
Hoe zit het met Leila?

393
00:28:27,000 --> 00:28:31,000
Kan ik u dit schrijf in?

394
00:28:31,000 --> 00:28:35,000
Schrijf de eerste regel waar u de lengte van de array en krijg het midden

395
00:28:35,000 --> 00:28:41,000
en bewaar deze op een nieuwe variabele.

396
00:28:41,000 --> 00:28:44,000
Ik geef je een paar seconden. Bent u er klaar voor?

397
00:28:44,000 --> 00:28:46,000
[Student onverstaanbaar]

398
00:28:46,000 --> 00:28:50,000
Tuurlijk, had ik bereken je het middelpunt

399
00:28:50,000 --> 00:28:55,000
van de hooiberg reeks in de zoekfunctie

400
00:28:55,000 --> 00:29:03,000
waarbij de lengte van de hooiberg array, ter grootte variabele?

401
00:29:03,000 --> 00:29:08,000
Niets lastig hier.

402
00:29:08,000 --> 00:29:12,000
[Leila] het juiste formaat / 2 en just-

403
00:29:12,000 --> 00:29:17,000
En sla het op en druk op de knop Opslaan hier aan de top,

404
00:29:17,000 --> 00:29:19,000
en we trek het omhoog.

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

406
00:29:22,000 --> 00:29:28,000
Daar gaan we dan. Awesome.

407
00:29:28,000 --> 00:29:30,000
>> Zoals zal dit compileren?

408
00:29:30,000 --> 00:29:32,000
[Leila] Nee, het moet hoger zijn.

409
00:29:32,000 --> 00:29:34,000
[Nate] Ja, dus wat moeten we doen?

410
00:29:34,000 --> 00:29:36,000
[Leila] Net als int midden of iets dergelijks.

411
00:29:36,000 --> 00:29:41,000
Awesome. Ja, laten we dat doen, int midden = grootte.

412
00:29:41,000 --> 00:29:44,000
Zal dit samen te stellen?

413
00:29:44,000 --> 00:29:47,000
Laten we verwijderen deze reactie en krijg het uit de weg.

414
00:29:47,000 --> 00:29:50,000
Wat zal niet compileren over dit?

415
00:29:50,000 --> 00:29:52,000
We doen iets met integer,

416
00:29:52,000 --> 00:29:55,000
dus we moeten het of iets dergelijks af te drukken.

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

418
00:29:58,000 --> 00:30:00,000
We krijgen een ongebruikte variabele.

419
00:30:00,000 --> 00:30:02,000
Wat is niet van plan om te werken over dit?

420
00:30:02,000 --> 00:30:06,000
Ik denk dat je iets zei, Sam. Puntkomma's.

421
00:30:06,000 --> 00:30:08,000
Ja, ik mis die puntkomma's.

422
00:30:08,000 --> 00:30:14,000
Het gaat om een ​​constante ding in de loop van de termijn.

423
00:30:14,000 --> 00:30:17,000
Het laatste wat ik zal doen is zal ik wat witte ruimte op beide zijden

424
00:30:17,000 --> 00:30:23,000
van deze operator hier, want die typisch is hoe we het doen

425
00:30:23,000 --> 00:30:26,000
volgens onze stijlgids.

426
00:30:26,000 --> 00:30:29,000
We hebben het middelpunt van ons aanbod.

427
00:30:29,000 --> 00:30:32,000
Nu als we ons herinneren terug naar ons algoritme,

428
00:30:32,000 --> 00:30:37,000
wat was de tweede stap die we moesten doen als we hebben het midden?

429
00:30:37,000 --> 00:30:42,000
[Student] Als het groter is [onverstaanbaar].

430
00:30:42,000 --> 00:30:48,000
Ja, dus we moeten een soort van vergelijking te doen, en wat gaan we vergelijken hier?

431
00:30:48,000 --> 00:30:53,000
Je zei dat als deze groter is dan. Wat is het in die zin met betrekking tot?

432
00:30:53,000 --> 00:30:57,000
Het nummer dat verschijnt, als dat hoger is dan het middelpunt, ga dan naar de array?

433
00:30:57,000 --> 00:31:05,000
Precies, dus het nummer dat komt als we-

434
00:31:05,000 --> 00:31:10,000
De naald, dus we zijn in vergelijking met de naald,

435
00:31:10,000 --> 00:31:12,000
en wat gaan we het vergelijken met de naald?

436
00:31:12,000 --> 00:31:15,000
Omdat de naald is wat we zoeken.

437
00:31:15,000 --> 00:31:18,000
We zijn te vergelijken met naar het midden.

438
00:31:18,000 --> 00:31:21,000
>> Maar heeft het zin om te controleren om te zien

439
00:31:21,000 --> 00:31:27,000
indien de nld = midden?

440
00:31:27,000 --> 00:31:32,000
Is dat logisch?

441
00:31:32,000 --> 00:31:35,000
Heeft iemand het niet eens?

442
00:31:35,000 --> 00:31:40,000
Laten we het eens proberen, als (naald == middelpunt).

443
00:31:40,000 --> 00:31:42,000
[Student] Heb printf je het gevonden hebt.

444
00:31:42,000 --> 00:31:51,000
[Nate] printf ("We vonden het \ n");

445
00:31:51,000 --> 00:31:56,000
Anders-Ik ga om te beginnen met iets anders te doen hier.

446
00:31:56,000 --> 00:32:00,000
Ik ga beginnen met het opzetten accolades om if-statements de hele tijd

447
00:32:00,000 --> 00:32:05,000
alleen maar omdat als we voegen meer spullen, dan

448
00:32:05,000 --> 00:32:07,000
krijgen we niet de samenstellers.

449
00:32:07,000 --> 00:32:09,000
Ja, Sam. Je hebt een punt.

450
00:32:09,000 --> 00:32:12,000
Het probleem is dat een positie midden in de array vertegenwoordigt,

451
00:32:12,000 --> 00:32:15,000
maar je kunt het om de waarde in die positie van de array te vertegenwoordigen.

452
00:32:15,000 --> 00:32:17,000
Dat is een groot punt.

453
00:32:17,000 --> 00:32:19,000
Heeft iedereen horen wat Sam zei?

454
00:32:19,000 --> 00:32:22,000
Hij zei dat middelpunt zoals

455
00:32:22,000 --> 00:32:28,000
vertegenwoordigt slechts een positie in het stelsel, maar het is niet de werkelijke element in de array.

456
00:32:28,000 --> 00:32:30,000
Als u denkt over de code in zoals geschreven op dit moment,

457
00:32:30,000 --> 00:32:35,000
als we kijken naar deze array hier beneden, die heeft 8 elementen in,

458
00:32:35,000 --> 00:32:39,000
wat is de waarde van de midden gaat worden in deze functie?

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
Als we kijken naar het aantal 4 -

462
00:32:51,000 --> 00:32:54,000
en we kunnen alleen nog maar deze code en zet een beetje verdrietig gezicht in hier

463
00:32:54,000 --> 00:32:58,000
omdat we het niet vinden, als we deze code uitvoert

464
00:32:58,000 --> 00:33:04,000
zoals op dit moment, uploaden, gebouw, laat me naar beneden scrollen,

465
00:33:04,000 --> 00:33:09,000
en als we kijken naar het getal 4,

466
00:33:09,000 --> 00:33:18,000
we vonden het, maar we hebben dit niet naar printf ja.

467
00:33:18,000 --> 00:33:23,000
Een van de redenen is dat we niet echt terug,

468
00:33:23,000 --> 00:33:26,000
maar hebben we echt vinden de nummer 4?

469
00:33:26,000 --> 00:33:28,000
En Sam is geen zegt.

470
00:33:28,000 --> 00:33:31,000
Wat hebben we gevonden?

471
00:33:31,000 --> 00:33:35,000
We hebben echt gevonden het midden, die, als we kijken naar de array hier beneden,

472
00:33:35,000 --> 00:33:38,000
het gaat om het element te zijn bij index 4 dat we kijken naar,

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

474
00:33:42,000 --> 00:33:46,000
>> Hoe kunnen we daadwerkelijk krijgen dat element in het midden

475
00:33:46,000 --> 00:33:48,000
en niet alleen het middelpunt zelf?

476
00:33:48,000 --> 00:33:52,000
[Student] Wij zouden invoeren char of zo?

477
00:33:52,000 --> 00:33:55,000
Wat zou dat te doen, gewoon uit nieuwsgierigheid?

478
00:33:55,000 --> 00:33:57,000
Kunt u ingaan iets meer zijn?

479
00:33:57,000 --> 00:34:02,000
U de positie zetten in het aantal,

480
00:34:02,000 --> 00:34:05,000
dus je hebt te maken een connectie-Ik denk dat het char is, maar het is misschien niet.

481
00:34:05,000 --> 00:34:07,000
Ja, dat is een goed punt.

482
00:34:07,000 --> 00:34:12,000
We doen veel van dit omzetten van posities in tekens, deze tekens,

483
00:34:12,000 --> 00:34:14,000
in de eerste twee sets probleem.

484
00:34:14,000 --> 00:34:18,000
Het blijkt dat hier, dit is bijna gelijk aan

485
00:34:18,000 --> 00:34:24,000
toegang te krijgen tot de i-teken in een tekenreeks, als dat zinvol is.

486
00:34:24,000 --> 00:34:30,000
Hier willen we het middelpunt element te openen.

487
00:34:30,000 --> 00:34:34,000
Hoe doen we dat?

488
00:34:34,000 --> 00:34:39,000
Kevin, heb je suggesties hoe we dat doen?

489
00:34:39,000 --> 00:34:44,000
Je zou hooiberg te doen, open beugel, mid, gesloten beugel.

490
00:34:44,000 --> 00:34:46,000
Kun je schrijven dat voor ons?

491
00:34:46,000 --> 00:34:51,000
Sla het op in hier, en we zullen dat omhoog te trekken.

492
00:34:51,000 --> 00:34:56,000
We kijken naar deze lijn 9,

493
00:34:56,000 --> 00:34:59,000
en we beseffen dat we niet willen om de naald te vergelijken met het middelpunt,

494
00:34:59,000 --> 00:35:03,000
maar in plaats daarvan willen we de naald te vergelijken

495
00:35:03,000 --> 00:35:07,000
om het element op positie midden in onze hooiberg array.

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

497
00:35:10,000 --> 00:35:12,000
Daar gaan we dan.

498
00:35:12,000 --> 00:35:15,000
Ja, dat ziet er goed uit, als (naald == hooiberg [midden]).

499
00:35:15,000 --> 00:35:18,000
We vonden het.

500
00:35:18,000 --> 00:35:22,000
Als we nu lopen de code-we zullen een back-up een beetje-

501
00:35:22,000 --> 00:35:26,000
stelt zij, het loopt, en nu als we kijken voor 4,

502
00:35:26,000 --> 00:35:30,000
we vonden het niet want nu we daadwerkelijk krijgen van het nummer 23.

503
00:35:30,000 --> 00:35:33,000
We krijgen de waarde 23, en dat is wat we in vergelijking met onze naald.

504
00:35:33,000 --> 00:35:35,000
Maar dat is goed. Dat is een stap in de goede richting.

505
00:35:35,000 --> 00:35:37,000
>> Dat is wat we proberen te doen.

506
00:35:37,000 --> 00:35:40,000
We proberen niet om de naald te vergelijken met posities in de array

507
00:35:40,000 --> 00:35:44,000
maar tegen de feitelijke elementen in de array.

508
00:35:44,000 --> 00:35:49,000
Als we terugkijken nu weer bij de volgende stap in ons algoritme,

509
00:35:49,000 --> 00:35:51,000
wat is de volgende stap?

510
00:35:51,000 --> 00:35:57,000
Leila al zagen kort.

511
00:35:57,000 --> 00:36:00,000
[Student] Controleer om te zien of het is groter dan of kleiner dan en dan beslissen welke manier om te bewegen.

512
00:36:00,000 --> 00:36:03,000
[Nate] Ja, zou dus hoe we dat doen?

513
00:36:03,000 --> 00:36:07,000
Kunt u in een aantal-Ik sla deze herziening,

514
00:36:07,000 --> 00:36:13,000
en dan als je in een aantal lijnen die zal dat doen.

515
00:36:13,000 --> 00:36:15,000
Ja, Charlotte. >> Ik heb een vraag.

516
00:36:15,000 --> 00:36:19,000
Mocht het niet midden - 1 omdat de eerste is

517
00:36:19,000 --> 00:36:26,000
het is 0 geïndexeerd, dus als we 4 plaatsen, dat is eigenlijk niet het karakter die we zoeken?

518
00:36:26,000 --> 00:36:30,000
Ja, en het andere probleem dat-

519
00:36:30,000 --> 00:36:35,000
dat is een grote vangst, want wat gaat uiteindelijk gebeuren mogelijk

520
00:36:35,000 --> 00:36:42,000
als we in beweging blijven en we niet ooit in eerste instantie aan te passen?

521
00:36:42,000 --> 00:36:46,000
Ik denk dat wat we zouden kunnen eindigen doen is proberen om toegang te krijgen

522
00:36:46,000 --> 00:36:49,000
het element op de 8e positie van de array,

523
00:36:49,000 --> 00:36:53,000
die in dit geval bestaat niet.

524
00:36:53,000 --> 00:36:56,000
We willen een soort van boekhouding te doen voor het feit

525
00:36:56,000 --> 00:36:59,000
dat hebben we een aantal nul indexering.

526
00:36:59,000 --> 00:37:05,000
[Charlotte] Sorry, ik bedoelde midpoint - 1 in de vierkante haken.

527
00:37:05,000 --> 00:37:08,000
We kunnen dat doen.

528
00:37:08,000 --> 00:37:10,000
We komen terug op deze kwestie in slechts een beetje.

529
00:37:10,000 --> 00:37:13,000
Als we eenmaal beginnen te krijgen om de werkelijke looping,

530
00:37:13,000 --> 00:37:16,000
dat is wanneer we echt zien dit in het spel komen.

531
00:37:16,000 --> 00:37:21,000
Voorlopig kunnen we dit doen, maar je hebt helemaal gelijk.

532
00:37:21,000 --> 00:37:28,000
Dat nul indexering zal een effect hebben dat we moeten verantwoorden.

533
00:37:28,000 --> 00:37:30,000
Laten we eens kijken.

534
00:37:30,000 --> 00:37:34,000
>> Hoe is het groter dan en kleiner dan-?

535
00:37:34,000 --> 00:37:36,000
[Student] Ik krijg hoe de groter dan en kleiner dan deel te doen.

536
00:37:36,000 --> 00:37:41,000
Ik was niet zeker wat te drukken als u vindt dat het minder is dan de hooiberg midden of groter dan.

537
00:37:41,000 --> 00:37:43,000
Hier kan ik redden wat I've-

538
00:37:43,000 --> 00:37:47,000
[Nate] Ja, als je bespaart wat je hebt, en we trek het omhoog.

539
00:37:47,000 --> 00:37:49,000
Daar gaan we dan.

540
00:37:49,000 --> 00:37:51,000
[Student] En ik vraagtekens gezet voor wat ik niet wist.

541
00:37:51,000 --> 00:37:54,000
[Nate] Dat ziet er geweldig uit.

542
00:37:54,000 --> 00:37:58,000
Hier hebben we vraagtekens, want we weten nog steeds niet

543
00:37:58,000 --> 00:38:06,000
wat we gaan helemaal nog doen.

544
00:38:06,000 --> 00:38:12,000
Wat zouden we willen-doen oeps, we hebben een aantal beugels alle funky op ons.

545
00:38:12,000 --> 00:38:15,000
We corrigeren deze braces.

546
00:38:15,000 --> 00:38:19,000
Daar gaan we dan.

547
00:38:19,000 --> 00:38:22,000
En dus wat willen we doen, volgens ons algoritme,

548
00:38:22,000 --> 00:38:27,000
als we niet vinden de naald?

549
00:38:27,000 --> 00:38:32,000
Zeg in het geval dat de naald is minder dan wat we kijken. Kevin.

550
00:38:32,000 --> 00:38:34,000
Kijk alleen naar de linker helft.

551
00:38:34,000 --> 00:38:40,000
Juist, dus zetten we een reactie hier die zegt: "kijk naar linker helft."

552
00:38:40,000 --> 00:38:46,000
En als de naald groter is dan de hooiberg in het midden, wat we willen doen?

553
00:38:46,000 --> 00:38:48,000
[Student] Dan moet je kijken naar de rechter helft.

554
00:38:48,000 --> 00:38:53,000
Kijk naar de rechter helft, "kijk naar rechter helft."

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

556
00:38:58,000 --> 00:39:05,000
Oke, dus op dit punt, dingen ziet er goed uit.

557
00:39:05,000 --> 00:39:13,000
Het probleem met de code geschreven is wat?

558
00:39:13,000 --> 00:39:15,000
[Student] Je hoeft niet eindpunten voor de helften.

559
00:39:15,000 --> 00:39:18,000
Juist, we hebben niet eindpunten voor de helften.

560
00:39:18,000 --> 00:39:20,000
We zijn ook alleen maar om te gaan door deze ene keer.

561
00:39:20,000 --> 00:39:23,000
We alleen maar kijken naar een middelpunt.

562
00:39:23,000 --> 00:39:27,000
Ofwel het element is er, of het is het niet.

563
00:39:27,000 --> 00:39:34,000
Om dit te voltooien, moeten we een soort van herhaling doen.

564
00:39:34,000 --> 00:39:39,000
We moeten blijven herhalen totdat we zien dat

565
00:39:39,000 --> 00:39:43,000
ofwel het element is daar, want we hebben teruggebracht en eindelijk gevonden,

566
00:39:43,000 --> 00:39:46,000
of het is er niet in want we hebben keek door alle van de dingen

567
00:39:46,000 --> 00:39:52,000
in de juiste helften van de array en dat niets in.

568
00:39:52,000 --> 00:39:56,000
>> Wanneer we nog hebt deze herhaling aan de hand, wat gaan we gebruiken?

569
00:39:56,000 --> 00:39:58,000
[Student] Een lus.

570
00:39:58,000 --> 00:40:00,000
Een soort lus. Ja.

571
00:40:00,000 --> 00:40:03,000
[Student] Kunnen we doen een do-while-lus en laat het dat doen en dan tijdens het

572
00:40:03,000 --> 00:40:10,000
de naald is niet gelijk aan-ik ben niet zeker waar ik heen ging met dat.

573
00:40:10,000 --> 00:40:18,000
Maar een soort doen zolang het niet gelijk aan de waarde die de gebruiker input.

574
00:40:18,000 --> 00:40:21,000
Ja, dus laten we eens kijken, hoe kan dit schrijven zelf?

575
00:40:21,000 --> 00:40:23,000
Je zei dat we gebruik maken van een do-while-lus.

576
00:40:23,000 --> 00:40:26,000
Waar komt de doe start?

577
00:40:26,000 --> 00:40:33,000
[Student] Direct na de grootte / 2.

578
00:40:33,000 --> 00:40:42,000
[Nate] Oke, en wat gaan we doen?

579
00:40:42,000 --> 00:40:44,000
We zullen later de tijd.

580
00:40:44,000 --> 00:40:46,000
Wat gaan we doen?

581
00:40:46,000 --> 00:40:49,000
[Student] Niet willen we alle spullen hebben we in de als deel?

582
00:40:49,000 --> 00:40:52,000
[Nate] Doe dit allemaal, geweldig.

583
00:40:52,000 --> 00:40:55,000
Kopiëren en plakken.

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

585
00:40:59,000 --> 00:41:03,000
Laten we eens kijken of dit werkt, als we kunnen tabblad dit over.

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

587
00:41:08,000 --> 00:41:16,000
Oke, en besparen we dit zodat jullie het hebben.

588
00:41:16,000 --> 00:41:21,000
Oke, en we gaan dit doen terwijl-

589
00:41:21,000 --> 00:41:25,000
wat was de conditie terwijl je zoekt?

590
00:41:25,000 --> 00:41:31,000
[Student] Terwijl de naald niet gelijk doet, dus als het uitroepteken.

591
00:41:31,000 --> 00:41:37,000
Maar ik weet niet precies wat dat nog is.

592
00:41:37,000 --> 00:41:39,000
[Nate] Ja, dit is een manier om het te doen.

593
00:41:39,000 --> 00:41:41,000
Sam, heb je een reactie achterlaten?

594
00:41:41,000 --> 00:41:43,000
[Sam] Ik herinnerde me toen ik keek naar de video's,

595
00:41:43,000 --> 00:41:48,000
Ik nam een ​​screenshot van een van de-achtige toen we de pseudocode voor het,

596
00:41:48,000 --> 00:41:52,000
was er een relatie tussen de max. en min..

597
00:41:52,000 --> 00:41:58,000
Ik denk dat het iets als als max is steeds minder dan min.

598
00:41:58,000 --> 00:42:00,000
Ik heb het.

599
00:42:00,000 --> 00:42:04,000
[Sam] Of als als max is niet minder dan min of iets dergelijks,

600
00:42:04,000 --> 00:42:06,000
want dat zou betekenen dat je alles doorzocht.

601
00:42:06,000 --> 00:42:13,000
>> Ja, dus wat klinkt het max en min verwees naar?

602
00:42:13,000 --> 00:42:16,000
[Sam] Waarden die-gehele getallen die gaan veranderen

603
00:42:16,000 --> 00:42:18,000
ten opzichte van waar we het middelpunt.

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

605
00:42:20,000 --> 00:42:24,000
[Sam] Op dat moment gaat het om [onverstaanbaar] berekenen de max en min.

606
00:42:24,000 --> 00:42:29,000
Middelpunt is dit max en min idee.

607
00:42:29,000 --> 00:42:35,000
Heeft dat zin om mensen?

608
00:42:35,000 --> 00:42:39,000
Als we gaan kijken naar hoe we dit gaan iteratie te doen,

609
00:42:39,000 --> 00:42:43,000
je bent helemaal gelijk dat we willen een soort van do-while-lus te gebruiken.

610
00:42:43,000 --> 00:42:49,000
Maar ik denk dat als we ons herinneren wat er op de plaats van deze array

611
00:42:49,000 --> 00:42:53,000
en wat er daadwerkelijk gebeurt-Ik ga schrijven hier-

612
00:42:53,000 --> 00:42:58,000
bij de eerste iteratie van binair zoeken, hebben we-

613
00:42:58,000 --> 00:43:05,000
Ik ga naar b en e te gebruiken om het begin aan te duiden.

614
00:43:05,000 --> 00:43:10,000
En dan het einde van ons aanbod.

615
00:43:10,000 --> 00:43:14,000
We weten dat het begin ligt op 4 recht over hier,

616
00:43:14,000 --> 00:43:18,000
en we weten dat het einde is bij 108.

617
00:43:18,000 --> 00:43:23,000
Zeggen dat we op zoek naar het nummer 15.

618
00:43:23,000 --> 00:43:27,000
De eerste keer dat we dit doen, zoals we eerder zagen,

619
00:43:27,000 --> 00:43:30,000
het middelpunt is ofwel gaat worden 16 of 23

620
00:43:30,000 --> 00:43:34,000
afhankelijk van hoe berekenen we dingen uit.

621
00:43:34,000 --> 00:43:37,000
Sinds gelijkmatig te verdelen in het midden zou ons deze ruimte

622
00:43:37,000 --> 00:43:42,000
tussen 16 en 23, kunnen we niet gelijkmatig verdelen

623
00:43:42,000 --> 00:43:47,000
of verdeel het en krijgen op een echte middelpunt.

624
00:43:47,000 --> 00:43:49,000
We kijken naar 16.

625
00:43:49,000 --> 00:43:55,000
We beseffen: "He, 16> 15, dat we op zoek zijn."

626
00:43:55,000 --> 00:43:59,000
Om vervolgens naar de linkerhelft van de array

627
00:43:59,000 --> 00:44:03,000
wat we uiteindelijk doen is zich ontdoen van

628
00:44:03,000 --> 00:44:07,000
deze gehele bovenste gedeelte

629
00:44:07,000 --> 00:44:16,000
en zegt: "Oke, nu onze eindpunt gaat om hier te zijn."

630
00:44:16,000 --> 00:44:22,000
De volgende iteratie van onze lus, we nu kijken naar deze array,

631
00:44:22,000 --> 00:44:25,000
effectief te hebben weggegooid dit deel, want nu

632
00:44:25,000 --> 00:44:30,000
Als we nemen het midden van het verschil tussen het begin en het einde zijn,

633
00:44:30,000 --> 00:44:34,000
vinden we onze middelpunt te zijn 8,

634
00:44:34,000 --> 00:44:40,000
die we kunnen dan testen 8 om te zien waar het in verhouding tot het aantal die we zoeken,

635
00:44:40,000 --> 00:44:44,000
15, vinden dat 15 groter is,

636
00:44:44,000 --> 00:44:49,000
zodat we naar rechts deel van de lijst,

637
00:44:49,000 --> 00:44:51,000
waarvan we weten dat omdat we mensen, en we kunnen het zien.

638
00:44:51,000 --> 00:44:54,000
We weten dat het rechter gedeelte gaat worden waar we het vinden,

639
00:44:54,000 --> 00:45:01,000
maar de computer niet weet dat, dus wat we zullen doen is zullen we eigenlijk

640
00:45:01,000 --> 00:45:04,000
hebben deze omhoog gaan, en nu het begin en het einde

641
00:45:04,000 --> 00:45:11,000
zijn dezelfde plek, zodat het midden wordt het enige nummer in de lijst op dat moment,

642
00:45:11,000 --> 00:45:16,000
die is 15, en we hebben het gevonden.

643
00:45:16,000 --> 00:45:21,000
Is dat enig licht werpen op waar dit hele max en min-notatie gaat,

644
00:45:21,000 --> 00:45:24,000
het bijhouden van de eindpunten van de array om erachter te komen

645
00:45:24,000 --> 00:45:35,000
hoe om dingen te beperken?

646
00:45:35,000 --> 00:45:42,000
>> Wat zou er gebeuren als dit niet gelijk aan 15 nu?

647
00:45:42,000 --> 00:45:52,000
Wat als we waren op zoek naar 15 en in plaats daarvan dit nummer waren ook 16?

648
00:45:52,000 --> 00:45:54,000
Wij zouden zeggen: "Oh, het is groter.

649
00:45:54,000 --> 00:45:57,000
We willen om terug te gaan naar links. "

650
00:45:57,000 --> 00:46:01,000
En we gaan onze e naar rechts,

651
00:46:01,000 --> 00:46:06,000
op welk punt we een eindpunt dat zou tegenstrijdig.

652
00:46:06,000 --> 00:46:09,000
Het zou niet mogelijk om te zoeken naar meer elementen

653
00:46:09,000 --> 00:46:13,000
want nu hebben we onze eindpunt en ons begin punt,

654
00:46:13,000 --> 00:46:16,000
onze max en onze min, zijn nu omgedraaid.

655
00:46:16,000 --> 00:46:23,000
Wij zoeken in de volledige array. We kunnen niets vinden.

656
00:46:23,000 --> 00:46:27,000
Dat is het punt waarop we zouden willen zeggen: "Oke, we gaan dit algoritme te stoppen.

657
00:46:27,000 --> 00:46:34,000
We hebben niets gevonden. We weten dat het niet hier. "

658
00:46:34,000 --> 00:46:36,000
Hoe gaat dit?

659
00:46:36,000 --> 00:46:40,000
[Student] Hoe precies is de computer schakelt het einde?

660
00:46:40,000 --> 00:46:45,000
Hoe werkt het eind eindigen vóór het begin?

661
00:46:45,000 --> 00:46:48,000
Het einde eindigt vóór het begin

662
00:46:48,000 --> 00:46:54,000
als gevolg van de wiskunde die we gaan elke keer dat we dit doen doen.

663
00:46:54,000 --> 00:47:00,000
De manier waarop we ruilen is als je kijkt naar de eerste keer dat we deze swap te doen

664
00:47:00,000 --> 00:47:03,000
waar we het begin bij 4 en het uiteinde

665
00:47:03,000 --> 00:47:13,000
helemaal bij 108 en onze middelpunt, bijvoorbeeld op 16 -

666
00:47:13,000 --> 00:47:20,000
Ik ga dit terug te zetten naar 15-als we op zoek naar de 15,

667
00:47:20,000 --> 00:47:25,000
wisten we dat wat we deden toen we de 16 en zag dat het groter was

668
00:47:25,000 --> 00:47:28,000
en wilde de gehele rechter gedeelte van de lijst te verwijderen,

669
00:47:28,000 --> 00:47:36,000
zagen we dat wat we wilden doen is deze e bewegen hier.

670
00:47:36,000 --> 00:47:44,000
Effectief, werd de e verplaatst naar een voor het midden.

671
00:47:44,000 --> 00:47:48,000
Ook toen we deze iteratie van het algoritme

672
00:47:48,000 --> 00:47:51,000
en het middelpunt was 8,

673
00:47:51,000 --> 00:47:55,000
vonden we dat 8 <15, dus we wilden de b te verplaatsen

674
00:47:55,000 --> 00:48:00,000
een voorbij het midden.

675
00:48:00,000 --> 00:48:07,000
Nu het begin en het einde worden samen in dit 15.

676
00:48:07,000 --> 00:48:10,000
>> Als we er gebeurd om te zoeken naar een andere waarde, niet 15,

677
00:48:10,000 --> 00:48:14,000
of indien dit 15 had plaats geweest 16,

678
00:48:14,000 --> 00:48:20,000
zouden we hebben gevonden dat de e willen we een verplaatsen voordat het middelpunt.

679
00:48:20,000 --> 00:48:33,000
Nu de e zou er omgedraaid minder dan de b.

680
00:48:33,000 --> 00:48:39,000
Laten we lopen door de manier waarop we eigenlijk omhoog beëindigen codering dit algoritme.

681
00:48:39,000 --> 00:48:44,000
We weten dat we willen dit middelpunt berekening hebben.

682
00:48:44,000 --> 00:48:48,000
We weten ook dat we willen het begin en het einde van de array te volgen

683
00:48:48,000 --> 00:48:51,000
van onze huidige array, zodat we kunnen achterhalen

684
00:48:51,000 --> 00:48:56,000
waar dit linkerhelft van de lijst is en waar de rechter helft van de lijst is.

685
00:48:56,000 --> 00:49:03,000
Dat doen we met ofwel beginnen en eindigen,

686
00:49:03,000 --> 00:49:07,000
of we kunnen noemen ze min en max.

687
00:49:07,000 --> 00:49:10,000
Ik gebruik beginnen en eindigen deze keer.

688
00:49:10,000 --> 00:49:15,000
Wanneer we beginnen, als we kijken terug op ons voorbeeld hier beneden,

689
00:49:15,000 --> 00:49:20,000
ons begin was ingesteld op het begin van de array, als natuurlijke.

690
00:49:20,000 --> 00:49:25,000
Wat index was dit? Wat moet onze beginnen te worden?

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

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

693
00:49:30,000 --> 00:49:37,000
[Nate] Ja, dus we konden stel deze gelijk aan hooiberg [0].

694
00:49:37,000 --> 00:49:40,000
Het probleem is echter dat dit geeft ons niet de positie van het eerste element.

695
00:49:40,000 --> 00:49:45,000
Het geeft ons de index van het eerste element of de werkelijke waarde op dat eerste positie.

696
00:49:45,000 --> 00:49:47,000
[Student] Dat zal converteren naar 0,20?

697
00:49:47,000 --> 00:49:52,000
[Nate] Wat dit zal doen is, nou ja, het zal geen schade omzetten.

698
00:49:52,000 --> 00:49:56,000
Wat het zal doen, is het een 4 op te slaan in beginnen,

699
00:49:56,000 --> 00:49:59,000
en dan zal het moeilijk zijn om vergelijkingen te maken tegen beginnen

700
00:49:59,000 --> 00:50:03,000
omdat Begin wordt die de waarde van 4

701
00:50:03,000 --> 00:50:06,000
die het begin van de array,

702
00:50:06,000 --> 00:50:08,000
maar we willen de indices in de array te volgen

703
00:50:08,000 --> 00:50:11,000
in tegenstelling tot de waarden.

704
00:50:11,000 --> 00:50:17,000
We zullen daadwerkelijk gebruik maken van een 0, als dat.

705
00:50:17,000 --> 00:50:20,000
Voor het einde van de array-Charlotte bracht dit een beetje eerder.

706
00:50:20,000 --> 00:50:23,000
Dit is waar we rekening houden met de nul indexeren.

707
00:50:23,000 --> 00:50:25,000
>> Charlotte, wat is het einde van de array?

708
00:50:25,000 --> 00:50:28,000
Wat is de index van het einde?

709
00:50:28,000 --> 00:50:30,000
[Charlotte] Size - 1.

710
00:50:30,000 --> 00:50:32,000
Ja, en welke maat moeten we gebruiken?

711
00:50:32,000 --> 00:50:35,000
Moeten we gebruik maken van het kapitaal grootte of kleine letters maat?

712
00:50:35,000 --> 00:50:37,000
Kapitaal grootte.

713
00:50:37,000 --> 00:50:42,000
In dit geval kunnen we de hoofdletter grootte.

714
00:50:42,000 --> 00:50:45,000
Als we wilden deze functie om draagbaar

715
00:50:45,000 --> 00:50:48,000
en gebruik deze functie in andere programma's,

716
00:50:48,000 --> 00:50:50,000
kunnen we daadwerkelijk gebruik maken van kleine omvang.

717
00:50:50,000 --> 00:50:52,000
Het is ook goed.

718
00:50:52,000 --> 00:51:01,000
Maar Charlotte is helemaal gelijk dat we willen omvang hebben - 1.

719
00:51:01,000 --> 00:51:03,000
Op dit punt-

720
00:51:03,000 --> 00:51:05,000
[Student] Hoe komt het dat u kunt gebruiken hoofdletters maat?

721
00:51:05,000 --> 00:51:07,000
Hoe komt het dat we kunnen gebruiken hoofdletters maat?

722
00:51:07,000 --> 00:51:13,000
Het blijkt dat deze # definieert zijn echt,

723
00:51:13,000 --> 00:51:19,000
onder de motorkap, een tekst zoals zoeken en vervangen, als dat zinvol is.

724
00:51:19,000 --> 00:51:24,000
Wanneer u uw code te compileren, de voorbewerking fase

725
00:51:24,000 --> 00:51:27,000
de compiler doorloopt het bestand

726
00:51:27,000 --> 00:51:31,000
en het ziet er voor overal dat u het kapitaal formaat geschreven,

727
00:51:31,000 --> 00:51:39,000
en het vervangt de tekst letterlijk met een 8, net als dat.

728
00:51:39,000 --> 00:51:42,000
In die zin is dit heel anders dan een variabele.

729
00:51:42,000 --> 00:51:45,000
Het neemt niet elke ruimte in het geheugen.

730
00:51:45,000 --> 00:51:52,000
Het is een eenvoudige tekst te vervangen truc.

731
00:51:52,000 --> 00:51:57,000
In dit geval gaan we op maat te gebruiken.

732
00:51:57,000 --> 00:52:01,000
Vanaf hier gaan we willen een soort van herhaling doen,

733
00:52:01,000 --> 00:52:03,000
en we zijn op de goede weg met onze do-while-lus.

734
00:52:03,000 --> 00:52:08,000
We willen iets doen tot een voorwaarde niet meer te houden,

735
00:52:08,000 --> 00:52:12,000
en zoals we eerder zagen, zagen we dat deze voorwaarde

736
00:52:12,000 --> 00:52:19,000
was inderdaad dat we niet het einde willen

737
00:52:19,000 --> 00:52:24,000
minder dan beginnen.

738
00:52:24,000 --> 00:52:26,000
>> Dit is onze stoppen toestand.

739
00:52:26,000 --> 00:52:35,000
Als dit gebeurt, willen we om te stoppen en te verklaren als: "He, we hebben niets gevonden."

740
00:52:35,000 --> 00:52:43,000
Om dit uit te drukken, willen we een soort van lus te gebruiken.

741
00:52:43,000 --> 00:52:49,000
In dit geval zou het een do-while-lus, een lus, een while-lus?

742
00:52:49,000 --> 00:52:51,000
We hebben een do-while-lus hier.

743
00:52:51,000 --> 00:52:53,000
Hebben jullie dat soort aanpak?

744
00:52:53,000 --> 00:52:59,000
Denk je dat we moeten een andere aanpak proberen?

745
00:52:59,000 --> 00:53:01,000
Kevin, alle gedachten?

746
00:53:01,000 --> 00:53:06,000
We kunnen een while-lus, omdat we weten dat een maximale

747
00:53:06,000 --> 00:53:11,000
groter zijn dan min bij aanvang anyways.

748
00:53:11,000 --> 00:53:14,000
Ja, dus er is geen initialisatie dat moet gebeuren.

749
00:53:14,000 --> 00:53:17,000
Die do-while loops zijn groot wanneer je iets moet initialiseren

750
00:53:17,000 --> 00:53:21,000
voor die tijd testen, terwijl hier

751
00:53:21,000 --> 00:53:26,000
we weten dat we niet gaan houden initialiseren van zowel beginnen en eindigen

752
00:53:26,000 --> 00:53:28,000
elke ronde van de lus.

753
00:53:28,000 --> 00:53:32,000
We weten dat we hen willen initialiseren, controleer dan onze toestand.

754
00:53:32,000 --> 00:53:38,000
In dit geval, zal ik daadwerkelijk te gaan met een simpele while lus.

755
00:53:38,000 --> 00:53:44,000
Het blijkt dat do-while loops zijn vrij weinig gebruikt.

756
00:53:44,000 --> 00:53:49,000
Een heleboel plekken zelfs niet leren doen terwijl loops.

757
00:53:49,000 --> 00:53:53,000
Ze zijn goed voor het omgaan met input van de gebruiker, dus we hebben veel gezien van hen tot nu toe.

758
00:53:53,000 --> 00:53:59,000
Maar normaal en terwijl loops zijn veel vaker voor.

759
00:53:59,000 --> 00:54:03,000
Het blijkt dat deze voorwaarde als geschreven

760
00:54:03,000 --> 00:54:09,000
zal niet echt doen ons veel goed, en waarom is dat?

761
00:54:09,000 --> 00:54:11,000
Het spijt me, ik weet het niet je naam.

762
00:54:11,000 --> 00:54:13,000
Ik ben Jerry. >> Sorry?

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

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

765
00:54:18,000 --> 00:54:23,000
Ik zie niet in je op mijn lijst.

766
00:54:23,000 --> 00:54:26,000
Oh, het is omdat-oh, dat is logisch.

767
00:54:26,000 --> 00:54:31,000
Heb je een idee van waarom dit while loop kan niet werken zoals bedoeld,

768
00:54:31,000 --> 00:54:38,000
zoals geschreven met de aandoening?

769
00:54:38,000 --> 00:54:43,000
[Jerry] Je bedoelt zoals u wilt dat alle de spullen na het in de-?

770
00:54:43,000 --> 00:54:46,000
Ja, dus dat is een.

771
00:54:46,000 --> 00:54:49,000
Misschien moeten we dit alles spullen in de while-lus, dat is helemaal waar.

772
00:54:49,000 --> 00:54:55,000
Het andere ding dat is een beetje problematischer is echter dat deze voorwaarde niet werkt.

773
00:54:55,000 --> 00:54:57,000
[Student] Je moet het omdraaien.

774
00:54:57,000 --> 00:55:04,000
Juist, dus deze voorwaarde zal nooit in eerste instantie waar de manier waarop we over gepraat.

775
00:55:04,000 --> 00:55:08,000
We willen iets doen tot eind <beginnen,

776
00:55:08,000 --> 00:55:13,000
maar we willen iets doen, terwijl

777
00:55:13,000 --> 00:55:21,000
beginnen ≤ end.

778
00:55:21,000 --> 00:55:24,000
>> Er is dat omkering van de logica daar.

779
00:55:24,000 --> 00:55:27,000
Ik ben schuldig aan het maken van die fouten de hele tijd.

780
00:55:27,000 --> 00:55:31,000
[Student] Waarom moet het minder dan of gelijk aan?

781
00:55:31,000 --> 00:55:33,000
Omdat herinner u het geval is, dat we bij

782
00:55:33,000 --> 00:55:36,000
waar er slechts een element, en we waren naar beneden,

783
00:55:36,000 --> 00:55:43,000
en we waren op zoek naar alleen de 15 in ons aanbod?

784
00:55:43,000 --> 00:55:47,000
En ons begin en ons einde waren hetzelfde element.

785
00:55:47,000 --> 00:55:50,000
We willen ervoor zorgen dat we die zaak te behandelen.

786
00:55:50,000 --> 00:55:54,000
Als we een rechte minder dan,

787
00:55:54,000 --> 00:55:58,000
we alleen kunnen de slag om een ​​2-element array.

788
00:55:58,000 --> 00:56:06,000
Toen we eenmaal op neer dat laatste element, als dat ons element, we nooit zou vinden.

789
00:56:06,000 --> 00:56:10,000
Nu hier, kunnen we precies doen zoals je zei.

790
00:56:10,000 --> 00:56:15,000
We kunnen beginnen plopping spul in het midden van onze while-lus.

791
00:56:15,000 --> 00:56:20,000
We kunnen plop in onze midden.

792
00:56:20,000 --> 00:56:24,000
We kunnen al deze if-statements,

793
00:56:24,000 --> 00:56:30,000
trek ze uit deze do-while-lus,

794
00:56:30,000 --> 00:56:34,000
plop ze binnen,

795
00:56:34,000 --> 00:56:39,000
schoon dingen een beetje,

796
00:56:39,000 --> 00:56:48,000
en ik zal verder gaan en op te slaan deze herziening.

797
00:56:48,000 --> 00:56:53,000
En op dit punt, we zijn aardig in de buurt.

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

799
00:56:55,000 --> 00:56:58,000
Ik denk dat je ook moet int midden hebben = maat - 1/2.

800
00:56:58,000 --> 00:57:01,000
Ik heb het, grootte - 1/2.

801
00:57:01,000 --> 00:57:05,000
Is er nog iets anders dat we moeten veranderen over die lijn?

802
00:57:05,000 --> 00:57:10,000
Dat was een goede vangst.

803
00:57:10,000 --> 00:57:14,000
>> Wat doet afmetingen doen? Zijn we steeds veranderende maat?

804
00:57:14,000 --> 00:57:17,000
Om de regel als houden we de grootte te wijzigen.

805
00:57:17,000 --> 00:57:21,000
We moeten het formaat te wijzigen elke keer dat we rond het gaan for-lus.

806
00:57:21,000 --> 00:57:25,000
Maar vergeet niet toen we door ons voorbeeld een beetje eerder,

807
00:57:25,000 --> 00:57:30,000
en we hadden het begin op 4

808
00:57:30,000 --> 00:57:33,000
en het einde helemaal op bij 108?

809
00:57:33,000 --> 00:57:35,000
Hoe hebben we berekenen het midden?

810
00:57:35,000 --> 00:57:38,000
Waren we met behulp van de maat?

811
00:57:38,000 --> 00:57:40,000
Of we gebruikten beginnen en eindigen in plaats daarvan?

812
00:57:40,000 --> 00:57:42,000
Het is het verschil tussen het eind en het begin.

813
00:57:42,000 --> 00:57:50,000
Precies, en hoe precies moet ik schrijven dat, Charlotte?

814
00:57:50,000 --> 00:57:52,000
Gewoon het einde - te beginnen.

815
00:57:52,000 --> 00:57:55,000
Je zou het niet nodig om de do - 1

816
00:57:55,000 --> 00:57:58,000
omdat de - 1 is opgenomen in het einde en de reeds beginnen.

817
00:57:58,000 --> 00:58:00,000
[Nate] Geweldig, je bent helemaal gelijk.

818
00:58:00,000 --> 00:58:03,000
We hoeven niet te doen van de - 1, want dat - 1 is opgenomen

819
00:58:03,000 --> 00:58:08,000
en rekening houden bij het initialiseren we het einde variabele.

820
00:58:08,000 --> 00:58:11,000
>> Is er iets anders ik moet syntactisch doen om deze lijn logisch?

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

822
00:58:13,000 --> 00:58:15,000
[Student] Aan het einde.

823
00:58:15,000 --> 00:58:20,000
Omdat het alleen berekend helft van de lengte.

824
00:58:20,000 --> 00:58:26,000
Je moet naar het begin toe te voegen.

825
00:58:26,000 --> 00:58:31,000
[Nate] Wat zou dit te berekenen voor ons?

826
00:58:31,000 --> 00:58:35,000
Als we denken aan het einde van deze eerste iteratie van de lus,

827
00:58:35,000 --> 00:58:40,000
end gaat worden in de positie index 7.

828
00:58:40,000 --> 00:58:43,000
Begin in stand 0 staat.

829
00:58:43,000 --> 00:58:47,000
Vergeet niet, we zijn op zoek voor een van beide

830
00:58:47,000 --> 00:58:52,000
positie 3 of positie 4.

831
00:58:52,000 --> 00:58:56,000
Als we kijken naar deze wiskunde, om maar maken het een beetje meer tastbaar,

832
00:58:56,000 --> 00:59:02,000
hier zet een aantal nummers, hebben we 7, 0,

833
00:59:02,000 --> 00:59:10,000
dus 7 - 0, en daarna / 2

834
00:59:10,000 --> 00:59:19,000
is 3 in deling van gehele getallen, dat is.

835
00:59:19,000 --> 00:59:26,000
Dan hebben we nodig om en voeg dan terug onze beginnen?

836
00:59:26,000 --> 00:59:28,000
Dat doen we niet in dit geval.

837
00:59:28,000 --> 00:59:31,000
Op de eerste iteratie zal het goed omdat beginnen is 0.

838
00:59:31,000 --> 00:59:36,000
Maar als we de vooruitgang, we doen echt alles moet gewoon

839
00:59:36,000 --> 00:59:42,000
end - begin / 2.

840
00:59:42,000 --> 00:59:46,000
Er is nog een andere truc hier, en dat is namelijk een van voorrang.

841
00:59:46,000 --> 00:59:49,000
[Student] Moeten we haakjes?

842
00:59:49,000 --> 00:59:53,000
[Nate] Precies, en dat is omdat als we niet zet deze haakjes,

843
00:59:53,000 --> 00:59:58,000
dan is deze lijn zal in plaats daarvan worden geïnterpreteerd

844
00:59:58,000 --> 01:00:09,000
als (eind) - (begin / 2), die we zeker niet willen.

845
01:00:09,000 --> 01:00:11,000
Kijk uit voor die voorrang regels.

846
01:00:11,000 --> 01:00:15,000
[Student] Waarom is het niet eindigen + beginnen?

847
01:00:15,000 --> 01:00:17,000
Waarom is het niet eindigen + beginnen?

848
01:00:17,000 --> 01:00:19,000
[Student] Waarom is het dat niet?

849
01:00:19,000 --> 01:00:24,000
Waarom zou het +?

850
01:00:24,000 --> 01:00:26,000
Ik denk dat je gelijk hebt.

851
01:00:26,000 --> 01:00:28,000
[Student] Omdat het gemiddelde is?

852
01:00:28,000 --> 01:00:31,000
[Nate] Einde + beginnen, je hebt helemaal gelijk.

853
01:00:31,000 --> 01:00:34,000
Wow, ik ben het helemaal goofed. Je hebt gelijk.

854
01:00:34,000 --> 01:00:39,000
Als we aan het doen waren de min, zouden we willen naar de achterkant te beginnen binnen toe te voegen

855
01:00:39,000 --> 01:00:43,000
In dit geval, je bent heel goed dat we willen het gemiddelde van de twee te nemen,

856
01:00:43,000 --> 01:00:45,000
dus we willen ze toe te voegen, in tegenstelling tot hen af ​​te trekken.

857
01:00:45,000 --> 01:00:49,000
[Student] Het zou ook werken als je heb uiteindelijk - begin / 2 + beginnen.

858
01:00:49,000 --> 01:00:55,000
Het zou als we dat doen, ik denk het wel.

859
01:00:55,000 --> 01:01:00,000
>> Bijvoorbeeld, als we waren op zoek naar beginnen,

860
01:01:00,000 --> 01:01:04,000
en we verschoven het hier

861
01:01:04,000 --> 01:01:08,000
het 15.

862
01:01:08,000 --> 01:01:12,000
Begint nu op positie 2.

863
01:01:12,000 --> 01:01:15,000
End is op positie 7.

864
01:01:15,000 --> 01:01:21,000
Als we aftrekken hen, krijgen we 5.

865
01:01:21,000 --> 01:01:24,000
Verdeel dat door 2, krijgen we 2.

866
01:01:24,000 --> 01:01:27,000
En dan voegen we 2 terug in,

867
01:01:27,000 --> 01:01:30,000
en dat brengt ons naar de 4e positie,

868
01:01:30,000 --> 01:01:33,000
die hier, het middelpunt.

869
01:01:33,000 --> 01:01:36,000
[Student] Moeten we zorgen verpakking?

870
01:01:36,000 --> 01:01:39,000
In welke zin hebben we nodig om te zorgen voor inpakken?

871
01:01:39,000 --> 01:01:43,000
Als de som of het verschil tussen

872
01:01:43,000 --> 01:01:45,000
afhankelijk van hoe we dat doen is niet een even getal.

873
01:01:45,000 --> 01:01:49,000
Dan is de computer in de war raakt of wanneer het 2,5;

874
01:01:49,000 --> 01:01:52,000
u naar links of naar rechts te bepalen welke het middelpunt?

875
01:01:52,000 --> 01:01:54,000
Ik heb het.

876
01:01:54,000 --> 01:01:56,000
Het blijkt dat met gehele divisie

877
01:01:56,000 --> 01:01:59,000
we niet ooit deze floating point getallen.

878
01:01:59,000 --> 01:02:01,000
We krijgen nooit de komma.

879
01:02:01,000 --> 01:02:04,000
Het is helemaal weggegooid.

880
01:02:04,000 --> 01:02:08,000
Als u een computer deelt twee int variabelen,

881
01:02:08,000 --> 01:02:11,000
en een is 7, en de andere is 2,

882
01:02:11,000 --> 01:02:13,000
krijgt u geen 3,5 als resultaat.

883
01:02:13,000 --> 01:02:16,000
Het zal 3.

884
01:02:16,000 --> 01:02:19,000
De rest zal worden weggegooid, dus het is effectief afronding

885
01:02:19,000 --> 01:02:24,000
niet een ronde maar een verdieping, als jullie bekend bent met die in wiskunde,

886
01:02:24,000 --> 01:02:27,000
waar u volledig te ontdoen van de decimale,

887
01:02:27,000 --> 01:02:31,000
en dus je bent wezen afkappen het naar beneden naar het dichtstbijzijnde

888
01:02:31,000 --> 01:02:33,000
Totaal posities, op het dichtstbijzijnde gehele getal.

889
01:02:33,000 --> 01:02:38,000
[Student] Maar dan is dat problematisch, omdat als je een array van 7 elementen

890
01:02:38,000 --> 01:02:43,000
dan is dat automatisch de 3e element uit het midden in plaats van de 4e.

891
01:02:43,000 --> 01:02:46,000
Hoe gaan we daarmee om?

892
01:02:46,000 --> 01:02:49,000
Het is problematisch omdat als we een serie van 7,

893
01:02:49,000 --> 01:02:54,000
het zou halen de 3e plaats van de 4e.

894
01:02:54,000 --> 01:02:56,000
Kunt u uitleggen een beetje meer?

895
01:02:56,000 --> 01:02:59,000
[Student] Want als je 7 elementen dan de 4e element

896
01:02:59,000 --> 01:03:04,000
zou het middelpunt zijn, toch?

897
01:03:04,000 --> 01:03:07,000
Vergeet niet uw beoordeling over nul geïndexeerd, dat wel.

898
01:03:07,000 --> 01:03:10,000
[Student] Ja, dus in stand 3. Dat zou het middelpunt zijn.

899
01:03:10,000 --> 01:03:12,000
Ja.

900
01:03:12,000 --> 01:03:16,000
Oh, oke. Ik zie wat je bedoelt.

901
01:03:16,000 --> 01:03:19,000
Het is een beetje raar, want we wennen aan dit hele idee van

902
01:03:19,000 --> 01:03:22,000
het wegwerken van decimalen.

903
01:03:22,000 --> 01:03:26,000
Dat is een groot punt.

904
01:03:26,000 --> 01:03:30,000
Laten we dit afmaken op.

905
01:03:30,000 --> 01:03:32,000
We hebben berekend ons midden.

906
01:03:32,000 --> 01:03:37,000
>> We testen om te zien of onze naald is gelijk aan de middelste waarde.

907
01:03:37,000 --> 01:03:41,000
We afdrukt dat we het gevonden, maar echt, wat willen we doen in deze situatie?

908
01:03:41,000 --> 01:03:46,000
We hebben het gevonden, dus we willen laten de beller weten dat we het gevonden.

909
01:03:46,000 --> 01:03:49,000
We hebben een functie die een boolean getypte functie.

910
01:03:49,000 --> 01:03:54,000
De manier waarop we het signaal aan de beller van onze functie die we klaar om te gaan

911
01:03:54,000 --> 01:03:58,000
is dat we zeggen: "He, dit waar is."

912
01:03:58,000 --> 01:04:00,000
Hoe zouden we dat doen, Kevin?

913
01:04:00,000 --> 01:04:02,000
Je knikt je hoofd. >> [Kevin] Voeg return true.

914
01:04:02,000 --> 01:04:06,000
[Nate] Precies, return true.

915
01:04:06,000 --> 01:04:12,000
Nu, als het niet gelijk is, hoe zouden we kijken naar de linker helft?

916
01:04:12,000 --> 01:04:16,000
Iemand een idee?

917
01:04:16,000 --> 01:04:18,000
Stella, enig idee?

918
01:04:18,000 --> 01:04:21,000
U moet een nieuwe positie voor het einde in te stellen.

919
01:04:21,000 --> 01:04:23,000
Ja.

920
01:04:23,000 --> 01:04:29,000
Dus moeten we positie van midden doen - het einde.

921
01:04:29,000 --> 01:04:33,000
Geweldig.

922
01:04:33,000 --> 01:04:36,000
We moeten een nieuwe positie in te stellen voor het einde

923
01:04:36,000 --> 01:04:38,000
kijken naar de linkerhelft.

924
01:04:38,000 --> 01:04:41,000
Dat was wat we over hadden voor waar

925
01:04:41,000 --> 01:04:44,000
Ik ga terug naar dit voorbeeld.

926
01:04:44,000 --> 01:04:50,000
Ik heb het hier beginnen, en dan heb ik het einde helemaal hier.

927
01:04:50,000 --> 01:04:53,000
>> Nogmaals, als we op zoek naar 15, en onze middelpunt is op 16,

928
01:04:53,000 --> 01:04:56,000
en we beseffen, "Oeps, 16 is groter.

929
01:04:56,000 --> 01:04:59,000
We willen naar de linkerhelft. "

930
01:04:59,000 --> 01:05:02,000
We zouden dan verhuizen het einde van de 15,

931
01:05:02,000 --> 01:05:06,000
en dat doen we door het nemen van een weg van het midden

932
01:05:06,000 --> 01:05:09,000
en het instellen van dat als onze nieuwe einde.

933
01:05:09,000 --> 01:05:12,000
Evenzo, als we kijken naar de rechter helft, hoe zouden we dat doen?

934
01:05:12,000 --> 01:05:14,000
Heeft u een idee?

935
01:05:14,000 --> 01:05:22,000
[Student] Je hoeft alleen ingesteld beginnen te + 1 Midpoint.

936
01:05:22,000 --> 01:05:24,000
[Nate] Grote.

937
01:05:24,000 --> 01:05:29,000
En nu in het geval dat we niet alles vinden,

938
01:05:29,000 --> 01:05:32,000
betekent dat je verzorgd voor ons?

939
01:05:32,000 --> 01:05:36,000
Daniel, doet die krijgen verzorgd voor ons?

940
01:05:36,000 --> 01:05:38,000
[Daniel] Nee.

941
01:05:38,000 --> 01:05:40,000
[Nate] Als we het door de hele array en we niets vinden,

942
01:05:40,000 --> 01:05:42,000
waar zou dat worden opgevangen, of moeten we zorgen voor het?

943
01:05:42,000 --> 01:05:44,000
[Daniel] De while conditie.

944
01:05:44,000 --> 01:05:48,000
[Nate] Ja, die tijd staat, precies.

945
01:05:48,000 --> 01:05:51,000
Het zal zorgen voor het doornemen van de hele array als we niets vinden.

946
01:05:51,000 --> 01:05:53,000
Dit terwijl lus zal eindigen.

947
01:05:53,000 --> 01:05:56,000
We zullen nooit hebben ondervonden deze aandoening,

948
01:05:56,000 --> 01:06:03,000
en we kunnen return false.

949
01:06:03,000 --> 01:06:10,000
We kunnen dit ook als hier in als dit

950
01:06:10,000 --> 01:06:14,000
want als dit if-statement waar is,

951
01:06:14,000 --> 01:06:16,000
en onze functie zal terugkeren,

952
01:06:16,000 --> 01:06:21,000
en dus zullen we in wezen af ​​te breken deze functie op dit moment

953
01:06:21,000 --> 01:06:24,000
wanneer we terug waar.

954
01:06:24,000 --> 01:06:28,000
Maar wat gebeurt er met deze structuur hier?

955
01:06:28,000 --> 01:06:34,000
Zal dit geheel werken, of is er een logische fout in?

956
01:06:34,000 --> 01:06:37,000
>> Er is enige logische fout in daar, met de manier waarop het opgezet.

957
01:06:37,000 --> 01:06:40,000
Wat zou het zijn?

958
01:06:40,000 --> 01:06:43,000
[Student] Waarom heb je de - en + 1s?

959
01:06:43,000 --> 01:06:47,000
Dat zet ons aanbod aan onze nieuwe linkerhelft en rechterhelft.

960
01:06:47,000 --> 01:06:51,000
[Student] Maar waarom zou je het niet doen zonder de - 1s en + 1s?

961
01:06:51,000 --> 01:06:53,000
[Nate] We kunnen stellen dat gelijk is aan het midden?

962
01:06:53,000 --> 01:07:04,000
Wat kan problematisch zijn dat?

963
01:07:04,000 --> 01:07:08,000
[Student] Ik denk dat het inefficiënt is omdat je het controleren van een waarde die al zijn gecontroleerd.

964
01:07:08,000 --> 01:07:11,000
[Nate] Precies, dus Sam is helemaal gelijk.

965
01:07:11,000 --> 01:07:15,000
Als u het einde en het begin gelijk is aan het midden

966
01:07:15,000 --> 01:07:18,000
in plaats van - 1 en + 1 reflectief,

967
01:07:18,000 --> 01:07:22,000
op een bepaald punt in de toekomst zullen we uiteindelijk het controleren van het midden weer.

968
01:07:22,000 --> 01:07:26,000
[Student] ben ik begonnen met de PSET, en toen had ik zoiets

969
01:07:26,000 --> 01:07:30,000
waar ik vergat de + 1, en het kwam vast te zitten in een oneindige lus.

970
01:07:30,000 --> 01:07:34,000
Juist, omdat op een gegeven moment dat je nooit meer gaat krijgen beginnen en eindigen

971
01:07:34,000 --> 01:07:39,000
daadwerkelijk overlappen.

972
01:07:39,000 --> 01:07:41,000
Cool.

973
01:07:41,000 --> 01:07:44,000
Er is nog een logische fout, en dat is dat dit moet zeker

974
01:07:44,000 --> 01:07:48,000
een else if.

975
01:07:48,000 --> 01:07:55,000
Waarom zou dat zijn?

976
01:07:55,000 --> 01:07:59,000
>> De reden is als het niet een anders als-heb je het gezien, Kevin?

977
01:07:59,000 --> 01:08:02,000
[Kevin] Ja, omdat je het eindpunt aan het veranderen.

978
01:08:02,000 --> 01:08:05,000
[Nate] Precies.

979
01:08:05,000 --> 01:08:07,000
We veranderen het eindpunt,

980
01:08:07,000 --> 01:08:12,000
en als het is geschreven als dit-we zullen maken spaties tussen-

981
01:08:12,000 --> 01:08:14,000
het zal controleren dit geval.

982
01:08:14,000 --> 01:08:18,000
Deze zaak, als het lukt, zal afbreken van de functie.

983
01:08:18,000 --> 01:08:21,000
Dan zal dit controleren volgende zaak,

984
01:08:21,000 --> 01:08:24,000
en indien dit succesvol is, zal het aanpassen eindpunt

985
01:08:24,000 --> 01:08:28,000
en dan zal het verder op en controleer deze zaak.

986
01:08:28,000 --> 01:08:31,000
Maar op dit punt, we willen niet dat het blijven controleren.

987
01:08:31,000 --> 01:08:35,000
Gelukkig hebben we hier niet opnieuw het middelpunt,

988
01:08:35,000 --> 01:08:39,000
en we weten dat dit geval niet zal slagen.

989
01:08:39,000 --> 01:08:44,000
Maar we zeker willen het anders zetten als daar

990
01:08:44,000 --> 01:08:48,000
ook al is dat misschien in dit geval

991
01:08:48,000 --> 01:08:52,000
omdat we niet het aanpassen van het midden, zou dat een verschil maken?

992
01:08:52,000 --> 01:08:54,000
Nee, omdat deze gevallen zijn exclusief.

993
01:08:54,000 --> 01:08:58,000
Nogmaals, mijn fout.

994
01:08:58,000 --> 01:09:01,000
Wij niet, denk ik, moet dit else if.

995
01:09:01,000 --> 01:09:05,000
We kunnen het eens proberen en voer het uit en kijk wat er gebeurt.

996
01:09:05,000 --> 01:09:08,000
Gebouw is een fout opgetreden.

997
01:09:08,000 --> 01:09:12,000
Het is waarschijnlijk omdat ik verliet deze b en e in hier.

998
01:09:12,000 --> 01:09:14,000
Moet ik nog meer van die omhoog naar de top?

999
01:09:14,000 --> 01:09:16,000
Het maakt niet uit alsof het.

1000
01:09:16,000 --> 01:09:20,000
We uitzoomen, bouwen,

1001
01:09:20,000 --> 01:09:24,000
daar gaat, dus nu als we zoeken naar 15,

1002
01:09:24,000 --> 01:09:28,000
Ja.

1003
01:09:28,000 --> 01:09:30,000
Laat me zoomen

1004
01:09:30,000 --> 01:09:33,000
15, ja. We kunnen opnieuw draaien.

1005
01:09:33,000 --> 01:09:36,000
Het uploaden van de broncode, de bouw, hardlopen.

1006
01:09:36,000 --> 01:09:41,000
Wij kunnen zoeken naar iets als 13,

1007
01:09:41,000 --> 01:09:45,000
en krijgen we niet alles af te drukken, zodat het niet met de conclusie dat voor ons.

1008
01:09:45,000 --> 01:09:51,000
Dat is geweldig, want het is niet in onze lijst.

1009
01:09:51,000 --> 01:09:53,000
>> We zijn nu geen tijd meer.

1010
01:09:53,000 --> 01:09:55,000
Dat zal zij het voor deze week.

1011
01:09:55,000 --> 01:10:00,000
Bedankt voor het meedoen, en tot ziens.

1012
01:10:00,000 --> 01:10:02,000
>> [CS50.TV]