1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Abschnitt 3] [weniger komfortabel]

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

3
00:00:05,000 --> 00:00:08,000
>> [Dies ist CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Alles klar, lasst uns loslegen.

5
00:00:10,000 --> 00:00:13,000
Willkommen in Woche 4 der CS50.

6
00:00:13,000 --> 00:00:19,000
Wenn euch öffnen Sie einen Webbrowser und öffnen pset 3,

7
00:00:19,000 --> 00:00:23,000
Scramble mit CS50, werden wir beginnen werde

8
00:00:23,000 --> 00:00:26,000
durch den Abschnitt von Fragen gibt.

9
00:00:26,000 --> 00:00:32,000
Genau wie letzte Woche, werden wir in CS50 Spaces arbeiten,

10
00:00:32,000 --> 00:00:35,000
wenn du auch ziehen, dass als gut,

11
00:00:35,000 --> 00:00:43,000
und wenn Sie voran gehen und besuchen Sie diesen Link, ich habe hier oben an der Spitze.

12
00:00:43,000 --> 00:00:45,000
Es ist Zeit, um loszulegen.

13
00:00:45,000 --> 00:00:51,000
Wir haben unser kleines hallo Programm hier. Nichts verrückt.

14
00:00:51,000 --> 00:00:55,000
Eines der ersten Dinge, die ich will mit euch tun, ist heute gehen über ein paar Lösungen

15
00:00:55,000 --> 00:00:58,000
zum Problem Set 1, Art B. Lösungen,

16
00:00:58,000 --> 00:01:03,000
nur so können Sie ein Gefühl dafür bekommen, welche Arten von Codeteilung schreibt,

17
00:01:03,000 --> 00:01:07,000
welche Arten von Code anderen Studenten sind Schreiben,

18
00:01:07,000 --> 00:01:10,000
und haben Sie einen Blick auf sie, weil ich weiß, es ist komisch

19
00:01:10,000 --> 00:01:14,000
wenn Sie übermitteln eine Lösung für ein Problem, set-und get Kommentare

20
00:01:14,000 --> 00:01:18,000
auf eigene Version, aber manchmal ist es hilfreich zu sehen, wie andere Leute es getan hat,

21
00:01:18,000 --> 00:01:22,000
vor allem diejenigen, die nett sind suchen.

22
00:01:22,000 --> 00:01:27,000
Zum größten Teil, ich war wirklich mit den Lösungen, die euch produziert beeindruckt.

23
00:01:27,000 --> 00:01:31,000
Ich habe noch nicht angefangen, bei Ihrem Problem Set 2s, aber wenn sie so etwas wie die erste,

24
00:01:31,000 --> 00:01:34,000
es bedeutet nur Gutes.

25
00:01:34,000 --> 00:01:40,000
>> Wenn Sie auf meine Revisionen sehen, beginnen wir den ganzen Weg hinunter auf Revision 1,

26
00:01:40,000 --> 00:01:47,000
und wir werden, um einen schnellen Blick auf eine Mario-Lösung zu nehmen.

27
00:01:47,000 --> 00:01:54,000
Wenn Sie diese nach oben ziehen, sind diese Programme, dass wir gehen zu präsentieren korrekt.

28
00:01:54,000 --> 00:01:56,000
Es gab keine Korrektheit Probleme mit diesen Problemen, sondern

29
00:01:56,000 --> 00:01:59,000
wollen wir ein wenig über die verschiedenen Design-Themen zu sprechen

30
00:01:59,000 --> 00:02:03,000
Das waren hier zum Einsatz.

31
00:02:03,000 --> 00:02:08,000
Eines der Dinge, die interessant war über die Lösung

32
00:02:08,000 --> 00:02:11,000
ist, dass es dieses neue Konstrukt namens Pfund definieren verwendet,

33
00:02:11,000 --> 00:02:15,000
manchmal auch als ein Hash definieren bezeichnet.

34
00:02:15,000 --> 00:02:18,000
Lassen Sie mich zoomen Sie es hier.

35
00:02:18,000 --> 00:02:24,000
A # define können Sie die Namen auf diese Zahlen in Ihrem Programm zu geben.

36
00:02:24,000 --> 00:02:28,000
In diesem Fall ist die maximale Höhe der Pyramide in Mario

37
00:02:28,000 --> 00:02:34,000
wurde 23 und und anstatt 23 in meinem Code-

38
00:02:34,000 --> 00:02:37,000
wir würden, dass so hart Codierung 23 beziehen -

39
00:02:37,000 --> 00:02:43,000
Statt dies gibt den Namen MAX_HEIGHT zu dieser Nummer,

40
00:02:43,000 --> 00:02:48,000
, so dass sich hier in meinem do-while-Schleife

41
00:02:48,000 --> 00:02:51,000
Sie können tatsächlich MAX_HEIGHT beziehen

42
00:02:51,000 --> 00:02:55,000
anstatt die Nummer 23 in.

43
00:02:55,000 --> 00:02:57,000
[Student] Was ist der Vorteil, das zu tun?

44
00:02:57,000 --> 00:02:59,000
Das ist eine große Frage.

45
00:02:59,000 --> 00:03:03,000
Einer ist die Lesbarkeit.

46
00:03:03,000 --> 00:03:08,000
Ein Vorteil der Verwendung dieses # define die Lesbarkeit.

47
00:03:08,000 --> 00:03:11,000
Wenn ich lese diesen Code, kann ich sehen, was los ist.

48
00:03:11,000 --> 00:03:15,000
>> Ich kann in diesem Zustand sehen, dass wir testen

49
00:03:15,000 --> 00:03:19,000
für die Höhe ist <0, die wir auch definiert haben könnte

50
00:03:19,000 --> 00:03:22,000
eine minimale Höhe oder eine min Höhe.

51
00:03:22,000 --> 00:03:25,000
Der andere Vorteil ist, dass ich dann lesen Sie den Rest der Zeile zu sehen

52
00:03:25,000 --> 00:03:30,000
dass wir auch die Überprüfung, um sicherzustellen, dass die Höhe nicht größer ist als die maximale Höhe,

53
00:03:30,000 --> 00:03:35,000
da werden wir fortsetzen, während die Höhe größer ist als die maximale Höhe.

54
00:03:35,000 --> 00:03:40,000
Der andere Vorteil ist, wenn ich zoomen ein bisschen hier-

55
00:03:40,000 --> 00:03:49,000
wenn ich dieses Programm und ich führen Sie es, sagen wir, mit 23 gerade jetzt,

56
00:03:49,000 --> 00:03:52,000
Es gibt alle 23 Zeilen einfach so.

57
00:03:52,000 --> 00:03:54,000
Aber sagen wollte ich die max Höhe zu ändern,

58
00:03:54,000 --> 00:03:57,000
und jetzt will ich die maximale Höhe der Pyramiden zu begrenzen

59
00:03:57,000 --> 00:04:06,000
nur sagen-Mann, das flippige war.

60
00:04:06,000 --> 00:04:14,000
# Include, # define MAX_HEIGHT,

61
00:04:14,000 --> 00:04:18,000
und lassen Sie uns sagen, dass wir wollten es gleich 10 gesetzt.

62
00:04:18,000 --> 00:04:22,000
An diesem Punkt war alles, was ich zu tun hatte, ändern Sie es in diesem einen Standort.

63
00:04:22,000 --> 00:04:27,000
Ich kann den Code neu kompilieren, und jetzt, wenn ich versuche, in 12 geben,

64
00:04:27,000 --> 00:04:30,000
es wird Sie auffordern mich wieder.

65
00:04:30,000 --> 00:04:33,000
In diesem Fall sind wir nur mit MAX_HEIGHT einmal.

66
00:04:33,000 --> 00:04:37,000
Es ist nicht so große Mühe zu gehen

67
00:04:37,000 --> 00:04:40,000
und ändern Sie es in der while-Schleife, wenn Sie benötigen.

68
00:04:40,000 --> 00:04:44,000
Aber in Programme, wo man sich auf die gleiche magische Zahl sind

69
00:04:44,000 --> 00:04:47,000
immer und immer wieder, diese # define-Mechanismus ist wirklich praktisch

70
00:04:47,000 --> 00:04:52,000
weil Sie nur ändern, einmal am Anfang der Datei-it ist in der Regel, wo du sie-

71
00:04:52,000 --> 00:04:57,000
und die Änderung sickert durch den Rest der Datei.

72
00:04:57,000 --> 00:05:02,000
>> Andere Dinge, die ich wollte in dieser Zuordnung beachten Sie, dass ich dachte, sah wirklich schön,

73
00:05:02,000 --> 00:05:05,000
war die Benennung der Variablen.

74
00:05:05,000 --> 00:05:14,000
Sie sehen hier, dass wir Integer-Variablen als Zeilen-und genannte Höhe haben.

75
00:05:14,000 --> 00:05:20,000
Spaces, Hashes, hilft es, den Code ein wenig mehr lesbar,

76
00:05:20,000 --> 00:05:25,000
macht es ein wenig besser verständlich, was eigentlich vor sich geht.

77
00:05:25,000 --> 00:05:31,000
Dies steht im Gegensatz zur Verwendung von, sagen wir, Zufallsbuchstaben

78
00:05:31,000 --> 00:05:35,000
oder einfach nur Kauderwelsch insgesamt.

79
00:05:35,000 --> 00:05:39,000
Eine letzte Sache, ich darauf hinweisen müssen, ist, dass in for-Schleifen,

80
00:05:39,000 --> 00:05:45,000
oft sind diese Iteratorvariablen, diese Zähler, die Sie verwenden in Ihrem for-Schleifen,

81
00:05:45,000 --> 00:05:51,000
Es ist Standard und üblich, sie entweder mit i und dann j beginnen und dann k

82
00:05:51,000 --> 00:05:54,000
und gehen von dort aus, wenn Sie mehr Variablen müssen,

83
00:05:54,000 --> 00:05:56,000
und dies ist nur eine Konvention.

84
00:05:56,000 --> 00:05:58,000
Es gibt viele Konventionen.

85
00:05:58,000 --> 00:06:00,000
Es hängt von der Programmiersprache Sie verwenden.

86
00:06:00,000 --> 00:06:04,000
Aber in C, wir beginnen üblicherweise mit i.

87
00:06:04,000 --> 00:06:08,000
Es macht keinen Sinn zu verwenden, sagen wir, a oder b

88
00:06:08,000 --> 00:06:13,000
je nach Situation.

89
00:06:13,000 --> 00:06:15,000
Das ist es für diese ein.

90
00:06:15,000 --> 00:06:25,000
Wenn Sie ziehen nun Revision 2, werden Sie sehen, ein weiteres Mario,

91
00:06:25,000 --> 00:06:29,000
und dieses ist ähnlich zu dem anderen, dass wir gerade gesehen,

92
00:06:29,000 --> 00:06:32,000
aber es tut etwas irgendwie cool.

93
00:06:32,000 --> 00:06:38,000
Wenn wir in diesem Bereich hier zu sehen in der inneren for-Schleife,

94
00:06:38,000 --> 00:06:44,000
sie sind mit ein paar verrückte suchen Syntax hier rechts in dieser Zeile.

95
00:06:44,000 --> 00:06:47,000
Dies nennt man eine ternäre Operator.

96
00:06:47,000 --> 00:06:53,000
Es ist eine if else-Anweisung in einer Zeile zusammengefasst.

97
00:06:53,000 --> 00:06:57,000
Die Bedingung ist dieser Teil in Klammern.

98
00:06:57,000 --> 00:07:05,000
Es ist gleichbedeutend mit der Aussage, wenn j <height - i - 1.

99
00:07:05,000 --> 00:07:10,000
Und dann, was der Inhalt, dass, wenn Block wäre es der Raum

100
00:07:10,000 --> 00:07:16,000
und dann die Inhalte dessen, was der andere wäre es diese #.

101
00:07:16,000 --> 00:07:20,000
Es ist im Wesentlichen die Zuordnung einen Raum, um diese Variable.

102
00:07:20,000 --> 00:07:24,000
Es Putting einen Platz in den Inhalt des Blocks variable,

103
00:07:24,000 --> 00:07:29,000
wenn diese Bedingung erfüllt ist, und wenn die Bedingung nicht erfüllt ist,

104
00:07:29,000 --> 00:07:32,000
dann wird der Block Variable erhält this #.

105
00:07:32,000 --> 00:07:37,000
Und dann, natürlich, anstatt den Aufbau eines gesamten Strings

106
00:07:37,000 --> 00:07:43,000
und Drucken alles am Ende diese Lösung druckt sie ein Zeichen in einer Zeit.

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

108
00:07:48,000 --> 00:07:53,000
>> Noch ein paar Dinge zu sehen. Wir fahren Sie mit gierig.

109
00:07:53,000 --> 00:07:58,000
Nun, wenn wir gierig schauen, diese erste Lösung

110
00:07:58,000 --> 00:08:00,000
nutzt diese # definiert eine ganze Menge.

111
00:08:00,000 --> 00:08:06,000
Wir haben ein Konstante für jede der unterschiedlichen Zahlen in dieser Programm definiert.

112
00:08:06,000 --> 00:08:12,000
Wir haben eine für Cent pro Dollar, eine für die Quartale, Groschen, Nickels und Pfennige,

113
00:08:12,000 --> 00:08:15,000
und jetzt, wenn wir nach unten scrollen und lesen Sie den Code,

114
00:08:15,000 --> 00:08:22,000
können wir sehen, ein Standard-do-while-Schleife Druck alles aus.

115
00:08:22,000 --> 00:08:25,000
Art der Kern dieses Problem wurde klar, dass

116
00:08:25,000 --> 00:08:29,000
Sie benötigt, um den Schwimmer zu konvertieren, dass Sie in vom Benutzer zu lesen, um eine ganze

117
00:08:29,000 --> 00:08:32,000
genau die Mathematik zu tun, und das ist, weil

118
00:08:32,000 --> 00:08:36,000
mit Fließkommazahlen, wie wir darüber gesprochen in der Vorlesung kurz

119
00:08:36,000 --> 00:08:41,000
es ist nicht möglich, genau zu repräsentieren jeden einzelnen Wert auf der Zahlengeraden

120
00:08:41,000 --> 00:08:47,000
denn es gibt unendlich viele Werte zwischen 3 und, sagen wir, 3,1 sogar.

121
00:08:47,000 --> 00:08:54,000
Sie können 3,01 und 3,001 und 3,0001, und Sie können weitermachen.

122
00:08:54,000 --> 00:09:00,000
Es stellt sich heraus, wenn Sie mit dem Geld arbeiten, Sie wollen oft zu konvertieren

123
00:09:00,000 --> 00:09:05,000
in Integer-Format, so dass Sie nicht verlieren Pfennige und solche Sachen.

124
00:09:05,000 --> 00:09:09,000
Dadurch, dass und Rundung war der Schlüssel.

125
00:09:09,000 --> 00:09:14,000
Diese Lösung verwendet eine vollkommen unkompliziert, große Algorithmus

126
00:09:14,000 --> 00:09:17,000
die dekrementiert die Anzahl der Cent übrig, zuerst durch Quartalen

127
00:09:17,000 --> 00:09:19,000
dann durch Groschen, dann Nickels, dann durch ein paar Cent,

128
00:09:19,000 --> 00:09:24,000
und Addieren der Anzahl von Münzen jeder Zeit.

129
00:09:24,000 --> 00:09:31,000
>> Eine andere Lösung, dass wir sehen, wie ich zoomen und gehen Sie zu Revision 4,

130
00:09:31,000 --> 00:09:40,000
hatte eine sehr ähnliche Beginn, sondern verwendet div und mod

131
00:09:40,000 --> 00:09:44,000
hier drüben für die Berechnung der Anzahl der Cent.

132
00:09:44,000 --> 00:09:50,000
Dies ist die Anzahl von Vierteln gleich der Anzahl von Cents durch 25 geteilt,

133
00:09:50,000 --> 00:09:53,000
und der Grund, das funktioniert, weil wir zu tun Ganzzahldivision sind,

134
00:09:53,000 --> 00:09:58,000
so ist es zu verwerfen jegliche Reste.

135
00:09:58,000 --> 00:10:02,000
[Student] Haben wir die Suche kommentieren?

136
00:10:02,000 --> 00:10:05,000
Es hängt wirklich davon.

137
00:10:05,000 --> 00:10:08,000
[Student] Du kommentieren mehr als Code direkt hier.

138
00:10:08,000 --> 00:10:16,000
Ja, und so gibt es eine Reihe von unterschiedlichen Philosophien zu diesem Thema.

139
00:10:16,000 --> 00:10:21,000
Meine persönliche Philosophie ist, dass Ihr Code ist wirklich die Wahrheit,

140
00:10:21,000 --> 00:10:24,000
wie Ihr Code ist, was tatsächlich ausgeführt auf dem Computer,

141
00:10:24,000 --> 00:10:29,000
und so sollte der Code so lesbar wie möglich, nicht so viele Kommentare erfordern.

142
00:10:29,000 --> 00:10:33,000
Das heißt, wenn Sie Dinge tun, die Art sind schwierig mathematisch

143
00:10:33,000 --> 00:10:38,000
oder algorithmisch, es ist gut für diejenigen, so dass Sie kommentieren

144
00:10:38,000 --> 00:10:43,000
eine zusätzliche Dimension, eine zusätzliche Schicht wer liest den Code.

145
00:10:43,000 --> 00:10:49,000
In diesen Lösungen oft sind sie stärker, nur weil kommentierte

146
00:10:49,000 --> 00:10:52,000
Wir wollen in der Lage sein, sie zu verteilen und haben die Menschen abholen

147
00:10:52,000 --> 00:10:56,000
und lesen sie ziemlich leicht.

148
00:10:56,000 --> 00:11:05,000
Aber auf jeden Fall würde ich zustimmen, dass dies schwer ist.

149
00:11:05,000 --> 00:11:07,000
[Student] Aber wenn Sie Zweifel haben, gehen Sie schwerer?

150
00:11:07,000 --> 00:11:10,000
Wenn Sie Zweifel haben, gehen schwerer.

151
00:11:10,000 --> 00:11:17,000
Einige Leute werden sagen manchmal return 0 oder so ähnlich.

152
00:11:17,000 --> 00:11:20,000
Ich denke, das ist eine lächerliche Kommentar.

153
00:11:20,000 --> 00:11:22,000
Klar, dass ist das, was passiert ist.

154
00:11:22,000 --> 00:11:25,000
Ich brauche nicht Deutsch zu mir sagen.

155
00:11:25,000 --> 00:11:28,000
Manchmal sind die Leute schreibt Sachen wie "kthxbai!"

156
00:11:28,000 --> 00:11:32,000
Das ist irgendwie süß, aber auch nicht-

157
00:11:32,000 --> 00:11:35,000
das ist nicht so den Unterschied zwischen kommentieren Punkte oder nicht.

158
00:11:35,000 --> 00:11:41,000
Diese Art von Kommentaren sind nur ha, ha.

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

160
00:11:43,000 --> 00:11:48,000
>> An dieser Stelle wollen wir die Arbeit an dem Problem Set 3 Abschnitt Fragen.

161
00:11:48,000 --> 00:11:52,000
Wenn euch ziehen diese wieder auf,

162
00:11:52,000 --> 00:11:55,000
wie letzte Woche, werden wir nicht die Shorts in diesem Abschnitt zu sehen.

163
00:11:55,000 --> 00:12:00,000
Wir lassen euch tun, dass auf Ihrer eigenen Zeit und sprechen über die Fragen.

164
00:12:00,000 --> 00:12:05,000
Aber jetzt in diesem Abschnitt werden wir ein wenig mehr Zeit damit verbringen,

165
00:12:05,000 --> 00:12:11,000
sprechen weniger von den kodierenden Grundlagen

166
00:12:11,000 --> 00:12:15,000
wie wir letzte Woche getan hat, und stattdessen werden wir mehr konzentrieren

167
00:12:15,000 --> 00:12:22,000
ein bisschen mehr der Theorie, so reden binäre Suche und dann sortieren.

168
00:12:22,000 --> 00:12:27,000
Von diejenigen, die verfolgt haben zusammen mit dem Vortrag,

169
00:12:27,000 --> 00:12:30,000
kann mir jemand eine Zusammenfassung von dem, was der Unterschied ist

170
00:12:30,000 --> 00:12:35,000
zwischen Binär-Suche und lineare Suche?

171
00:12:35,000 --> 00:12:37,000
Was ist los? Sure.

172
00:12:37,000 --> 00:12:42,000
Lineare Suche durchsucht jedes Element in der sortierten Liste

173
00:12:42,000 --> 00:12:45,000
nacheinander durch eine nach der anderen durch ein,

174
00:12:45,000 --> 00:12:50,000
und binäre Suche teilt die Liste in zwei Gruppen,

175
00:12:50,000 --> 00:12:57,000
prüft, ob der Schlüssel-Wert, dass Sie für die Suche ist größer oder kleiner als der Mittelpunkt-Wert

176
00:12:57,000 --> 00:13:00,000
dass Sie gerade gefunden, und wenn es weniger als ist, geht es mit der unteren Liste

177
00:13:00,000 --> 00:13:03,000
und teilt sich dann noch einmal, hat die gleiche Funktion

178
00:13:03,000 --> 00:13:07,000
ganz nach unten bis er die Mitte findet, daß sie gleich dem Wert sich.

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

180
00:13:10,000 --> 00:13:12,000
>> Warum kümmern wir uns?

181
00:13:12,000 --> 00:13:20,000
Warum wir über binäre Suche Vergleich lineare Suche reden?

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

183
00:13:22,000 --> 00:13:24,000
Binary ist viel schneller, wenn Sie die Größe des Problems verdoppeln

184
00:13:24,000 --> 00:13:27,000
es dauert noch ein Schritt eher als doppelt so viele.

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

186
00:13:29,000 --> 00:13:31,000
Das ist eine tolle Antwort.

187
00:13:31,000 --> 00:13:36,000
Lineare Suche ist sehr Überprüfung ein Element zu einem Zeitpunkt,

188
00:13:36,000 --> 00:13:39,000
und als wir sahen, schon am ersten Tag der Vorlesung

189
00:13:39,000 --> 00:13:42,000
wenn David ging durch seinen Telefonbuch Beispiel

190
00:13:42,000 --> 00:13:45,000
und herausgerissen eine Seite des Telefonbuchs zu einer Zeit,

191
00:13:45,000 --> 00:13:47,000
und hielt dabei, dass immer und immer und immer wieder,

192
00:13:47,000 --> 00:13:51,000
es wird nehmen ihn eine wirklich lange Zeit mit niemandem im Telefonbuch zu finden,

193
00:13:51,000 --> 00:13:55,000
es sei denn natürlich, er suche jemanden ganz am Anfang des Alphabets.

194
00:13:55,000 --> 00:14:00,000
Mit binären Suche, können Sie viel schneller gehen,

195
00:14:00,000 --> 00:14:05,000
und es ist nicht nur doppelt so schnell oder 3 mal so schnell oder 4 mal so schnell.

196
00:14:05,000 --> 00:14:13,000
Aber das Problem immer kleiner und kleiner viel schneller.

197
00:14:13,000 --> 00:14:17,000
Um dies zu veranschaulichen, werden wir darüber zu reden, was los ist

198
00:14:17,000 --> 00:14:21,000
wenn wir binäre Suche schreiben.

199
00:14:21,000 --> 00:14:27,000
Das Problem bei der Hand ist, dass wenn ich eine Reihe von Zahlen,

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

201
00:14:40,000 --> 00:14:47,000
und dann 9 mit einer Tonne von 0s nach,

202
00:14:47,000 --> 00:14:52,000
Wir wollen in der Lage sein, um herauszufinden, wirklich schnell, was in

203
00:14:52,000 --> 00:14:57,000
Dieses Array von Zahlen.

204
00:14:57,000 --> 00:15:00,000
Ich weiß, das scheint ein wenig albern und ein wenig gekünstelt,

205
00:15:00,000 --> 00:15:02,000
denn im Moment ist es.

206
00:15:02,000 --> 00:15:05,000
Wir haben ein Array, das nicht sehr viele Elemente in ihr,

207
00:15:05,000 --> 00:15:08,000
und wenn ich einer von euch fragen, um herauszufinden, ob

208
00:15:08,000 --> 00:15:11,000
23 ist in dem Array, können Sie das ziemlich schnell tun

209
00:15:11,000 --> 00:15:16,000
nur durch einen Blick auf diese und sagt mir ja oder nein.

210
00:15:16,000 --> 00:15:20,000
Der analoge zu prüfen, ist vorstellbar, wenn diese, sagen wir,

211
00:15:20,000 --> 00:15:27,000
eine Excel-Tabelle mit 10.000 Zeilen, 20.000 Zeilen.

212
00:15:27,000 --> 00:15:31,000
Natürlich können Sie den Befehl F oder die Kontrolle F und schauen etwas.

213
00:15:31,000 --> 00:15:33,000
Sie können auch die Filter und die Suche stuff,

214
00:15:33,000 --> 00:15:37,000
aber wenn Sie mussten durch diese Datei Zeile für Zeile für Zeile suchen,

215
00:15:37,000 --> 00:15:40,000
es würde Sie eine lange Zeit, es zu finden.

216
00:15:40,000 --> 00:15:42,000
Es ist ein bisschen wie im Telefonbuch beispielsweise auch, wo

217
00:15:42,000 --> 00:15:44,000
niemand schaut durch ein Telefonbuch einer Seite zu einem Zeitpunkt.

218
00:15:44,000 --> 00:15:47,000
Typischerweise haben sie ihn in der Mitte zu öffnen,

219
00:15:47,000 --> 00:15:50,000
oder in dem Fall einer Vielzahl von Telefondiensten Pfund und Wörterbücher, wo

220
00:15:50,000 --> 00:15:54,000
Sie tatsächlich haben es auf den ersten Buchstaben eingegeben haben,

221
00:15:54,000 --> 00:16:01,000
Sie weiter zur ersten Buchstaben umdrehen und öffnen und durchlaufen dort.

222
00:16:01,000 --> 00:16:03,000
>> Erinnern mich an deinen Namen wieder. >> Sam.

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

224
00:16:05,000 --> 00:16:11,000
Wie Sam sagte, ist, dass lineare Suchprozess wird wirklich langsam,

225
00:16:11,000 --> 00:16:15,000
und stattdessen mit binären Suche ist der Weg das funktioniert, dass

226
00:16:15,000 --> 00:16:21,000
jedes Mal, wenn wir durch eine Iteration der Suchalgorithmus,

227
00:16:21,000 --> 00:16:27,000
wir gehen, um die Liste in der Hälfte teilen, im Wesentlichen

228
00:16:27,000 --> 00:16:33,000
in zwei kleinere Listen.

229
00:16:33,000 --> 00:16:39,000
Und dann auf der nächsten Iteration der Schleife, werden wir es wieder trennen

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

231
00:16:44,000 --> 00:16:48,000
Wie Sie sehen können, hält das Problem immer kleiner

232
00:16:48,000 --> 00:16:55,000
denn wir halten Verwerfen Hälfte der Liste jede einzelne Zeit.

233
00:16:55,000 --> 00:16:59,000
Wie funktioniert das discard Arbeit?

234
00:16:59,000 --> 00:17:05,000
Nur zur Erinnerung, was wir tun, wenn wir einen Computer waren

235
00:17:05,000 --> 00:17:11,000
und wir waren, sagen wir, auf der Suche nach der Nummer 5 in dieser Liste

236
00:17:11,000 --> 00:17:15,000
ist, dass wir eine Zahl in der Mitte holen.

237
00:17:15,000 --> 00:17:26,000
In der Mitte dieser Liste, denn es sind 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 Zahlen,

238
00:17:26,000 --> 00:17:32,000
würden wir die Zahl entweder am vierten Position oder an der fünften Position holen,

239
00:17:32,000 --> 00:17:38,000
und wir nennen würde, dass die Mitte unserer Liste.

240
00:17:38,000 --> 00:17:42,000
Pick-Nummer in Mitte.

241
00:17:42,000 --> 00:17:51,000
Dann, genau wie Sam sagte, wir testen, um zu sehen, ob diese Zahl ist gleich

242
00:17:51,000 --> 00:17:59,000
die Zahl, die wir erhalten möchten oder unsere gewünschte Nummer.

243
00:17:59,000 --> 00:18:06,000
Wenn er gleich ist, dann haben wir es gefunden. Wir gewinnen.

244
00:18:06,000 --> 00:18:12,000
Wenn es nicht gleich, dann gibt es ein paar Fälle.

245
00:18:12,000 --> 00:18:15,000
Die zwei Fälle sind entweder die Anzahl größer als die Anzahl Wir denken beispielsweise hat,

246
00:18:15,000 --> 00:18:19,000
oder es ist weniger als.

247
00:18:19,000 --> 00:18:25,000
Wenn es größer ist, werden wir nach rechts zu bewegen.

248
00:18:25,000 --> 00:18:33,000
Und wenn es weniger ist, bewegen wir uns auf der linken Seite.

249
00:18:33,000 --> 00:18:41,000
Und dann wiederholen wir den ganzen Prozess

250
00:18:41,000 --> 00:18:48,000
entweder auf der rechten Hälfte oder der linken Hälfte der Liste.

251
00:18:48,000 --> 00:18:51,000
>> Das erste Problem in der heutigen Abschnitts ist es, herauszufinden,

252
00:18:51,000 --> 00:18:55,000
wie können wir tatsächlich beginnen, dies in C-Code auszudrücken.

253
00:18:55,000 --> 00:18:58,000
Wir haben den Pseudocode hier.

254
00:18:58,000 --> 00:19:04,000
Was fangen wir tun, ist Ich ziehe einen brand-neuen Raum,

255
00:19:04,000 --> 00:19:09,000
speichern Sie diese Revision, so dass wir diese Hinweise für haben später

256
00:19:09,000 --> 00:19:20,000
wir löschen alles, und dann kopieren und aus dem Problem-Set

257
00:19:20,000 --> 00:19:26,000
diese Informationen in unsere Räume, und hoffentlich nicht zu brechen.

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

259
00:19:28,000 --> 00:19:33,000
Wenn ihr all das zu tun, kopieren und fügen Sie diesen Code in Ihren neuen Raum,

260
00:19:33,000 --> 00:19:43,000
in ein leeres ein.

261
00:19:43,000 --> 00:19:47,000
Lassen Sie uns versuchen Daniel. Wenn Sie kompilieren und ausführen dieses Programms funktioniert es?

262
00:19:47,000 --> 00:19:49,000
Nein >> Wie ist es da?

263
00:19:49,000 --> 00:19:53,000
Er sagt, die Steuerung erreicht Ende einer Nicht-void-Funktion.

264
00:19:53,000 --> 00:19:55,000
Yeah, so lassen Sie mich versuchen Sie es.

265
00:19:55,000 --> 00:19:59,000
Habt ihr das schon mal gesehen? Weißt du, was das bedeutet?

266
00:19:59,000 --> 00:20:01,000
Okay, lasst uns sezieren diese ein wenig.

267
00:20:01,000 --> 00:20:10,000
Es ist bei file.c sagen on line 9, Spalte 1 haben wir einen Fehler haben, genau wie du gesagt hast,

268
00:20:10,000 --> 00:20:16,000
und er sagt, dass es von dem Fehler Warnung und dem Rückgabetyp Warnung stammen.

269
00:20:16,000 --> 00:20:18,000
Es sieht aus wie etwas los ist mit dem Rückgabetyp, was Sinn macht.

270
00:20:18,000 --> 00:20:21,000
Wir haben eine nicht-void-Funktion, was bedeutet, dass wir haben eine Funktion

271
00:20:21,000 --> 00:20:24,000
das bedeutet nicht void zurückgeben.

272
00:20:24,000 --> 00:20:27,000
Ein Hohlraum ist eine Funktion, die wie folgt aussieht:

273
00:20:27,000 --> 00:20:35,000
void foo (), und es ist nichtig, weil der Rückgabetyp void,

274
00:20:35,000 --> 00:20:38,000
was bedeutet, dass, wenn wir etwas hier

275
00:20:38,000 --> 00:20:45,000
wie return 1, würden wir einen Compiler-Fehler für diese.

276
00:20:45,000 --> 00:20:49,000
Allerdings haben wir eine nicht-void-Funktion.

277
00:20:49,000 --> 00:20:51,000
Unsere nicht-void-Funktion ist in diesem Fall unsere Suchfunktion

278
00:20:51,000 --> 00:20:56,000
weil es eine Rückgabetyp bool.

279
00:20:56,000 --> 00:20:59,000
Wenn es zu sagen, dass die Steuerung das Ende eines nicht-void Funktion erreicht,

280
00:20:59,000 --> 00:21:02,000
es ist, weil search keinen return-Anweisung.

281
00:21:02,000 --> 00:21:04,000
Es ist nicht wieder alles vom Typ bool.

282
00:21:04,000 --> 00:21:09,000
>> Wir beheben können, dass und was denkt ihr

283
00:21:09,000 --> 00:21:13,000
Suche sollte standardmäßig zurückkehren?

284
00:21:13,000 --> 00:21:16,000
Was sollte die Standard-Rückgabewert der Suche sein?

285
00:21:16,000 --> 00:21:19,000
Denn das ist, was wir am Ende zu setzen.

286
00:21:19,000 --> 00:21:21,000
Charlotte, haben Sie any-?

287
00:21:21,000 --> 00:21:23,000
Wahr oder falsch? >> Wahr oder falsch.

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

289
00:21:26,000 --> 00:21:28,000
Falsch. Ich weiß nicht.

290
00:21:28,000 --> 00:21:30,000
False? Lass es uns versuchen.

291
00:21:30,000 --> 00:21:32,000
Warum sagst du return false? Das ist toll Intuition.

292
00:21:32,000 --> 00:21:35,000
[Charlotte] Ich weiß es nicht.

293
00:21:35,000 --> 00:21:39,000
Wir werden wieder in diesem Fall falsch, weil dies unser Standard sein wird

294
00:21:39,000 --> 00:21:44,000
wenn aus irgendeinem Grund die Liste leer ist oder die Nadel

295
00:21:44,000 --> 00:21:46,000
dass wir für die ist leider nicht vorhanden.

296
00:21:46,000 --> 00:21:50,000
Dann ganz am Ende, wenn wir nicht wahr früher wieder in dieser Funktion

297
00:21:50,000 --> 00:21:55,000
wissen wir immer, dass diese Funktion sage Nein, es ist nicht im Array.

298
00:21:55,000 --> 00:21:58,000
Es ist nicht im Heuhaufen.

299
00:21:58,000 --> 00:22:03,000
Wenn wir nun kompilieren und ausführen it-lass mich speichern Sie diese, so dass wir es nach oben ziehen.

300
00:22:03,000 --> 00:22:08,000
Wenn wir nun kompilieren und ausführen unserem Programm, es baut.

301
00:22:08,000 --> 00:22:12,000
Wir bekommen unsere kleinen prompt.

302
00:22:12,000 --> 00:22:20,000
Wenn ich getroffen 4-uh-oh.

303
00:22:20,000 --> 00:22:25,000
Es hat überhaupt nichts aus. Es sieht aus wie alles endete okay.

304
00:22:25,000 --> 00:22:35,000
Wir haben dies in. füllen

305
00:22:35,000 --> 00:22:39,000
Wir sprachen über den Algorithmus in Pseudocode ein wenig vor.

306
00:22:39,000 --> 00:22:44,000
Lassen Sie mich sehen, speichern Sie diese,

307
00:22:44,000 --> 00:22:49,000
und ich werde diesen Algorithmus zurück ziehen wieder an.

308
00:22:49,000 --> 00:22:51,000
Lassen Sie uns treffen diesen Kerl. Nope.

309
00:22:51,000 --> 00:22:58,000
Da ist es.

310
00:22:58,000 --> 00:23:03,000
Wie machen wir das?

311
00:23:03,000 --> 00:23:11,000
Was wäre eine gute Strategie für das Anfahren diesen Code sein?

312
00:23:11,000 --> 00:23:16,000
Sie müssen eine Zahl in der Mitte holen.

313
00:23:16,000 --> 00:23:23,000
Wie holen wir eine Zahl in der Mitte eines Feldes?

314
00:23:23,000 --> 00:23:25,000
Irgendwelche Vorschläge?

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

316
00:23:27,000 --> 00:23:32,000
Strlen durch 2 geteilt. Das ist ein großer.

317
00:23:32,000 --> 00:23:35,000
Strlen arbeitet mit speziellen Arten von Arrays.

318
00:23:35,000 --> 00:23:38,000
Welche Arten von Arrays?

319
00:23:38,000 --> 00:23:44,000
String-Arrays, Zeichen-Arrays.

320
00:23:44,000 --> 00:23:48,000
Es ist die gleiche Art von Konzept, das wir anwenden möchten,

321
00:23:48,000 --> 00:23:52,000
aber wir können nicht strlen, weil wir nicht über ein Array von Zeichen.

322
00:23:52,000 --> 00:23:55,000
Wir haben eine Reihe von ints.

323
00:23:55,000 --> 00:23:58,000
Aber was bedeutet strlen für uns?

324
00:23:58,000 --> 00:24:01,000
Weißt du, was es für uns bekommt?

325
00:24:01,000 --> 00:24:03,000
[Student] strlen bringt uns die Länge.

326
00:24:03,000 --> 00:24:05,000
Genau, es wird uns die Länge.

327
00:24:05,000 --> 00:24:09,000
Strlen bekommt die Länge des Arrays für uns.

328
00:24:09,000 --> 00:24:14,000
>> Wie bekommen wir, dass in unserer binäre Suche Programm?

329
00:24:14,000 --> 00:24:18,000
Wie würden Sie die Länge eines Arrays?

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

331
00:24:20,000 --> 00:24:25,000
Sie können die Länge eines korrekt formatiert C-String Array mit strlen bekommen.

332
00:24:25,000 --> 00:24:31,000
Das Problem ist allerdings, dass wir nicht mit einem String-Array.

333
00:24:31,000 --> 00:24:36,000
Wenn wir wieder in diesem Code aussehen, haben wir diese Integer-Array.

334
00:24:36,000 --> 00:24:38,000
Woher wissen wir, wie lange es ist?

335
00:24:38,000 --> 00:24:44,000
[Student] Gibt es ein Äquivalent eines für Endpunkt, wie int l, oder was?

336
00:24:44,000 --> 00:24:49,000
Es stellt sich heraus es tatsächlich nicht, und dies in einer Weise, ist dies

337
00:24:49,000 --> 00:24:52,000
eines jener Dinge, die einfach ist gut, über C wissen,

338
00:24:52,000 --> 00:24:57,000
dass es keine Möglichkeit gibt, um die Länge eines Arrays zu erhalten

339
00:24:57,000 --> 00:24:59,000
wenn alles, was ich geben kann ist das Array.

340
00:24:59,000 --> 00:25:02,000
Der Grund, es funktioniert mit Streichern, der Grund strlen Werke,

341
00:25:02,000 --> 00:25:06,000
Denn wenn ein String ist richtig formatiert,

342
00:25:06,000 --> 00:25:12,000
es wird dieses spezielle \ 0 Zeichen am Ende haben.

343
00:25:12,000 --> 00:25:16,000
>> Sie können sich auch vorstellen, wenn Sie eine falsch formatierte Zeichenfolge haben

344
00:25:16,000 --> 00:25:20,000
und es gibt keine \ 0 Zeichen gibt, dann ist die ganze Sache nicht funktioniert.

345
00:25:20,000 --> 00:25:22,000
[Student] Können Sie das \ 0?

346
00:25:22,000 --> 00:25:24,000
Wir könnten in diesem Fall.

347
00:25:24,000 --> 00:25:29,000
Wir könnten hinzufügen, irgendeine Art von \ 0

348
00:25:29,000 --> 00:25:33,000
oder irgendeine Art von bedeutet Charakter und dann verwenden Sie diese.

349
00:25:33,000 --> 00:25:36,000
Aber das ist nicht ganz zur Arbeit gehen

350
00:25:36,000 --> 00:25:40,000
weil die \ 0 ist für einen char-Typ,

351
00:25:40,000 --> 00:25:43,000
und hier haben wir ints.

352
00:25:43,000 --> 00:25:46,000
Die andere Sache ist, wenn wir einen besonderen Wert nutzen konnten

353
00:25:46,000 --> 00:25:49,000
wie -1 zu markieren das Ende eines Arrays

354
00:25:49,000 --> 00:25:54,000
dann könnten wir nie speichern eine -1 in unserer Integer-Arrays.

355
00:25:54,000 --> 00:25:56,000
Wir würden geklebt werden.

356
00:25:56,000 --> 00:26:00,000
Es stellt sich heraus, dass der einzige Weg, um die Länge zu bekommen

357
00:26:00,000 --> 00:26:03,000
einer Anordnung in C ist, um tatsächlich daran erinnern

358
00:26:03,000 --> 00:26:08,000
Wenn Sie es einrichten und dann weiterzugeben, um mit dem Array

359
00:26:08,000 --> 00:26:14,000
so dass, wenn ich eine Funktion haben, die gehen einige Arbeit zu tun ist

360
00:26:14,000 --> 00:26:18,000
auf einem Array von ganzen Zahlen oder Schwimmer oder verdoppelt oder was haben Sie,

361
00:26:18,000 --> 00:26:22,000
Ich muss auch geben die Funktion die Array-Länge,

362
00:26:22,000 --> 00:26:26,000
und das ist genau das, was wir hier in der Suche-Funktion.

363
00:26:26,000 --> 00:26:30,000
Wenn Sie schauen, was wir getan haben, wenn wir in unser Angebot hier vorbei,

364
00:26:30,000 --> 00:26:36,000
wir auch in der Länge, die Größe passieren.

365
00:26:36,000 --> 00:26:41,000
Es passiert einfach, dass wir diese Variable namens hier

366
00:26:41,000 --> 00:26:43,000
dieser Parameter oder Argument.

367
00:26:43,000 --> 00:26:46,000
Dies ist eine Funktion die Liste der Argumente oder Parameter-Liste genannt wird,

368
00:26:46,000 --> 00:26:51,000
und diese werden auch als Argumente oder Parameter.

369
00:26:51,000 --> 00:26:53,000
Menschen verwenden unterschiedliche Begriffe zu unterschiedlichen Zeiten.

370
00:26:53,000 --> 00:26:55,000
Ich habe manchmal vertauschen sie selber.

371
00:26:55,000 --> 00:27:00,000
Es passiert einfach so, dass diese Variable hier ebenfalls genannt wird

372
00:27:00,000 --> 00:27:03,000
dies # define hier oben.

373
00:27:03,000 --> 00:27:06,000
Aber sie sind nicht das Gleiche.

374
00:27:06,000 --> 00:27:11,000
Die Kapitalisierung nicht egal.

375
00:27:11,000 --> 00:27:14,000
>> Wenn man sieht, was hier passiert, schauen, erklären wir

376
00:27:14,000 --> 00:27:18,000
unserer int-Array, das wir nannten Zahlen haben.

377
00:27:18,000 --> 00:27:23,000
Wir haben ihm unsere Größe, die unsere # define an der Spitze entspricht.

378
00:27:23,000 --> 00:27:27,000
Es wird 8 sein.

379
00:27:27,000 --> 00:27:35,000
Und dann, wenn wir rufen Sie dann unsere Suchfunktion unten,

380
00:27:35,000 --> 00:27:40,000
passieren wir die Zahl wollen wir suchen, was wir dazu aufgefordert werden,

381
00:27:40,000 --> 00:27:43,000
bekommen vom Benutzer.

382
00:27:43,000 --> 00:27:46,000
Wir passieren im Array, diese Zahlen,

383
00:27:46,000 --> 00:27:51,000
und dann müssen wir auch in der Größe der Anordnung vorbei,

384
00:27:51,000 --> 00:27:57,000
und dann der Wert der Größe 8 wird gespeichert

385
00:27:57,000 --> 00:28:01,000
oder auf diese Integer-Variable namens Größe übergeben.

386
00:28:01,000 --> 00:28:08,000
Wir haben die Größe des Arrays.

387
00:28:08,000 --> 00:28:11,000
Wenn wir nun zurück zu dem, was wir über früher reden,

388
00:28:11,000 --> 00:28:14,000
Ich denke, Missy brachte den Punkt, dass, was wir brauchten zu tun ist, die Länge des Arrays

389
00:28:14,000 --> 00:28:20,000
und teilen sie durch 2, und das wird uns den Mittelpunkt.

390
00:28:20,000 --> 00:28:22,000
Mal sehen.

391
00:28:22,000 --> 00:28:25,000
Kann ich jemanden schreibe dies und speichern Sie sie in ihrem Raum?

392
00:28:25,000 --> 00:28:27,000
Wie wäre es mit Leila?

393
00:28:27,000 --> 00:28:31,000
Kann ich Ihnen schreibe diese in?

394
00:28:31,000 --> 00:28:35,000
Schreiben Sie die erste Zeile, wo Sie die Länge des Arrays zu nehmen und den Mittelpunkt

395
00:28:35,000 --> 00:28:41,000
und speichern Sie es in einer neuen Variable.

396
00:28:41,000 --> 00:28:44,000
Ich gebe Ihnen ein paar Sekunden. Sind Sie bereit?

397
00:28:44,000 --> 00:28:46,000
[Schüler unhörbar]

398
00:28:46,000 --> 00:28:50,000
Klar, konnte ich berechnen Sie den Mittelpunkt

399
00:28:50,000 --> 00:28:55,000
den Heuhaufen Array innerhalb der Suchfunktion

400
00:28:55,000 --> 00:29:03,000
über die Länge des Heuhaufen Array, das ist der Größe variabel?

401
00:29:03,000 --> 00:29:08,000
Nichts tricky hier.

402
00:29:08,000 --> 00:29:12,000
[Leila] Just Größe / 2 und just-

403
00:29:12,000 --> 00:29:17,000
Und speichern Sie sie, und klicken Sie auf die Schaltfläche Speichern hier an der Spitze,

404
00:29:17,000 --> 00:29:19,000
und wir nach oben ziehen.

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

406
00:29:22,000 --> 00:29:28,000
Dort gehen wir. Awesome.

407
00:29:28,000 --> 00:29:30,000
>> Wie es aussieht, wird dies zu kompilieren?

408
00:29:30,000 --> 00:29:32,000
[Leila] Nein, muss es höher zu sein.

409
00:29:32,000 --> 00:29:34,000
[Nate] Ja, so was brauchen wir tun?

410
00:29:34,000 --> 00:29:36,000
[Leila] Wie int Mittelpunkt oder so etwas.

411
00:29:36,000 --> 00:29:41,000
Awesome. Ja, lasst uns das tun, int Mittelpunkt = Größe.

412
00:29:41,000 --> 00:29:44,000
Wird diese kompilieren?

413
00:29:44,000 --> 00:29:47,000
Lassen Sie löschen diesen Kommentar und bekommen es aus dem Weg.

414
00:29:47,000 --> 00:29:50,000
Was wird darüber nicht kompilieren?

415
00:29:50,000 --> 00:29:52,000
Wir machen nicht alles mit integer,

416
00:29:52,000 --> 00:29:55,000
so müssen wir es oder etwas Ähnliches zu drucken.

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

418
00:29:58,000 --> 00:30:00,000
Wir kriegen eine unbenutzte Variablen.

419
00:30:00,000 --> 00:30:02,000
Was wird nicht über das funktionieren?

420
00:30:02,000 --> 00:30:06,000
Ich glaube, Sie sagten etwas, Sam. Semikolon.

421
00:30:06,000 --> 00:30:08,000
Ja, ich bin fehlen diese Semikolon.

422
00:30:08,000 --> 00:30:14,000
Es wird ein konstanter was im Laufe der Laufzeit sein.

423
00:30:14,000 --> 00:30:17,000
Das letzte, was ich tun werde ist werde ich etwas Leerraum auf beiden Seiten gelegt

424
00:30:17,000 --> 00:30:23,000
dieses Operators hier, da die in der Regel ist, wie wir es tun

425
00:30:23,000 --> 00:30:26,000
nach unseren Styleguide.

426
00:30:26,000 --> 00:30:29,000
Wir haben den Mittelpunkt unserer Array.

427
00:30:29,000 --> 00:30:32,000
Wenn wir nun zurück zu unserem Algorithmus erinnern,

428
00:30:32,000 --> 00:30:37,000
was war der zweite Schritt, den wir tun, wenn wir den Mittelpunkt gehabt haben?

429
00:30:37,000 --> 00:30:42,000
[Student] Wenn er größer ist [unverständlich].

430
00:30:42,000 --> 00:30:48,000
Ja, so haben wir eine Art von Vergleich zu tun, und was vergleichen wir hier?

431
00:30:48,000 --> 00:30:53,000
Du hast gesagt, wenn er größer als ist. Was ist in diesem Satz auf?

432
00:30:53,000 --> 00:30:57,000
Die Zahl, die aufkommt, wenn es das ist größer als der Mittelpunkt, dann gehen Sie zu dem Array?

433
00:30:57,000 --> 00:31:05,000
Genau, so die Zahl, die kommt, wenn wir-

434
00:31:05,000 --> 00:31:10,000
Die Nadel, so dass wir an der Nadel Vergleichen,

435
00:31:10,000 --> 00:31:12,000
und was machen wir den Vergleich gegen die Nadel?

436
00:31:12,000 --> 00:31:15,000
Da die Nadel ist das, was wir suchen.

437
00:31:15,000 --> 00:31:18,000
Wir Vergleich mit dem Mittelpunkt zu bekommen.

438
00:31:18,000 --> 00:31:21,000
>> Aber macht es Sinn, zu überprüfen, um zu sehen,

439
00:31:21,000 --> 00:31:27,000
wenn die Nadel legen = Mittelpunkt?

440
00:31:27,000 --> 00:31:32,000
Macht das Sinn?

441
00:31:32,000 --> 00:31:35,000
Hat jemand widersprechen?

442
00:31:35,000 --> 00:31:40,000
Geben wir es zu versuchen, wenn (Nadel == Mittelpunkt).

443
00:31:40,000 --> 00:31:42,000
[Student] Sie printf Sie es gefunden.

444
00:31:42,000 --> 00:31:51,000
[Nate] printf ("Wir fanden es \ n");

445
00:31:51,000 --> 00:31:56,000
Ansonsten-ich bin bald anfangen etwas anderes zu tun hier.

446
00:31:56,000 --> 00:32:00,000
Ich werde damit beginnen, Klammern um if-Anweisungen die ganze Zeit

447
00:32:00,000 --> 00:32:05,000
nur weil, wenn wir mehr Zeug, dann

448
00:32:05,000 --> 00:32:07,000
bekommen wir nicht die Compiler.

449
00:32:07,000 --> 00:32:09,000
Ja, Sam. Du hast einen Punkt.

450
00:32:09,000 --> 00:32:12,000
Das Problem ist, dass ein Mittelpunkt Position in der Anordnung repräsentiert,

451
00:32:12,000 --> 00:32:15,000
aber man kann es um den Wert in dieser Position des Arrays darstellen.

452
00:32:15,000 --> 00:32:17,000
Das ist ein großer Punkt.

453
00:32:17,000 --> 00:32:19,000
Haben alle hören, was Sam gesagt hat?

454
00:32:19,000 --> 00:32:22,000
Er sagte, dass Mittelpunkt wie

455
00:32:22,000 --> 00:32:28,000
stellt nur eine Position in der Anordnung, aber es ist nicht die eigentliche Element in dem Array.

456
00:32:28,000 --> 00:32:30,000
Wenn Sie darüber nachdenken, den Code so geschrieben gerade jetzt,

457
00:32:30,000 --> 00:32:35,000
wenn wir dieses Array hier unten aussehen, hat die 8 Elemente in ihr,

458
00:32:35,000 --> 00:32:39,000
was ist der Wert des Mittelpunktes würde in dieser Funktion sein?

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
Wenn wir uns für die Zahl 4 -

462
00:32:51,000 --> 00:32:54,000
und wir können nur diesen Code ausführen und legte ein kleines trauriges Gesicht hier

463
00:32:54,000 --> 00:32:58,000
weil wir es nicht finden, wenn wir diesen Code ausführen

464
00:32:58,000 --> 00:33:04,000
wie gerade jetzt, Hochladen, Gebäude, lassen Sie mich nach unten scrollen,

465
00:33:04,000 --> 00:33:09,000
und wenn wir für die Zahl 4,

466
00:33:09,000 --> 00:33:18,000
fanden wir es, aber wir haben nicht dies printf ja.

467
00:33:18,000 --> 00:33:23,000
Ein Grund dafür ist, dass wir nicht wieder wahr,

468
00:33:23,000 --> 00:33:26,000
aber wir haben wirklich die Nummer 4?

469
00:33:26,000 --> 00:33:28,000
Und Sam ist nicht selbstverständlich.

470
00:33:28,000 --> 00:33:31,000
Was haben wir zu finden?

471
00:33:31,000 --> 00:33:35,000
Wir fanden den Mittelpunkt, die, wenn wir uns mit dem Array hier unten,

472
00:33:35,000 --> 00:33:38,000
es geht um das Element mit dem Index 4, dass wir auf der Suche,

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

474
00:33:42,000 --> 00:33:46,000
>> Wie können wir tatsächlich das Element in der Mitte

475
00:33:46,000 --> 00:33:48,000
und nicht nur der Mittelpunkt selbst?

476
00:33:48,000 --> 00:33:52,000
[Student] Wir würden uns geben char oder so etwas?

477
00:33:52,000 --> 00:33:55,000
Was würde das tun, nur aus Neugier?

478
00:33:55,000 --> 00:33:57,000
Können Sie erarbeiten ein wenig mehr?

479
00:33:57,000 --> 00:34:02,000
Sie haben, um die Position in der Zahl zu verwandeln,

480
00:34:02,000 --> 00:34:05,000
so mußt du um irgendeine Verbindung, ich glaube, es ist char, aber es könnte nicht sein.

481
00:34:05,000 --> 00:34:07,000
Ja, das ist ein guter Punkt.

482
00:34:07,000 --> 00:34:12,000
Wir haben dabei eine Menge dieser Umwandlung Positionen in Zeichen, diese Zeichen,

483
00:34:12,000 --> 00:34:14,000
in den ersten beiden Problem-Sets.

484
00:34:14,000 --> 00:34:18,000
Es stellt sich heraus, dass hier das fast ähnlich ist

485
00:34:18,000 --> 00:34:24,000
Zugriff auf das i-te Zeichen in einem String, wenn das Sinn macht.

486
00:34:24,000 --> 00:34:30,000
Hier wollen wir den Mittelpunkt Element zugreifen.

487
00:34:30,000 --> 00:34:34,000
Wie machen wir das?

488
00:34:34,000 --> 00:34:39,000
Kevin, haben Sie irgendwelche Vorschläge, wie wir das tun könnte?

489
00:34:39,000 --> 00:34:44,000
Sie könnten Heuhaufen zu tun, geschlossen offen Halterung, Mitte, Halterung.

490
00:34:44,000 --> 00:34:46,000
Können Sie das für uns?

491
00:34:46,000 --> 00:34:51,000
Speichern Sie es hier, und wir werden diesen nach oben ziehen.

492
00:34:51,000 --> 00:34:56,000
Wir in dieser Zeile 9 suchen,

493
00:34:56,000 --> 00:34:59,000
und wir erkennen, dass wir nicht wollen, um die Nadel in der Mitte zu vergleichen,

494
00:34:59,000 --> 00:35:03,000
sondern, wir wollen, um die Nadel zu vergleichen

495
00:35:03,000 --> 00:35:07,000
auf das Element an Position Mittelpunkt in unserem Heuhaufen Array.

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

497
00:35:10,000 --> 00:35:12,000
Dort gehen wir.

498
00:35:12,000 --> 00:35:15,000
Ja, das sieht ziemlich gut, wenn (Nadel == Heuhaufen [Mittelpunkt]).

499
00:35:15,000 --> 00:35:18,000
Wir fanden es.

500
00:35:18,000 --> 00:35:22,000
Nun, wenn wir den Code ausführen-wir kommen wieder ein wenig bit-

501
00:35:22,000 --> 00:35:26,000
kompiliert, es läuft, und jetzt, wenn wir uns für 4,

502
00:35:26,000 --> 00:35:30,000
wir haben es nicht finden, weil wir jetzt eigentlich immer sind die Nummer 23.

503
00:35:30,000 --> 00:35:33,000
Wir bekommen den Wert 23, und das ist, was wir für unsere Nadel verglichen.

504
00:35:33,000 --> 00:35:35,000
Aber das ist gut. Das ist ein Schritt in die richtige Richtung.

505
00:35:35,000 --> 00:35:37,000
>> Das ist, was wir zu tun versuchen.

506
00:35:37,000 --> 00:35:40,000
Wir versuchen nicht, die Nadel gegen Positionen im Array vergleichen

507
00:35:40,000 --> 00:35:44,000
sondern gegen die eigentlichen Elemente im Array.

508
00:35:44,000 --> 00:35:49,000
Wenn wir wieder schauen nun auf den nächsten Schritt in unserem Algorithmus,

509
00:35:49,000 --> 00:35:51,000
Was ist der nächste Schritt?

510
00:35:51,000 --> 00:35:57,000
Leila bereits erwähnt sie kurz.

511
00:35:57,000 --> 00:36:00,000
[Student] Überprüfen Sie, ob sie größer oder kleiner als ist und dann entscheiden, welchen Weg sich zu bewegen.

512
00:36:00,000 --> 00:36:03,000
[Nate] Ja, das würde so, wie wir das tun?

513
00:36:03,000 --> 00:36:07,000
Kann man in einem gewissen-Ich legte speichern Sie diese Revision,

514
00:36:07,000 --> 00:36:13,000
und dann, wenn Sie setzen in einigen Linien, die das tun wird.

515
00:36:13,000 --> 00:36:15,000
Yeah, Charlotte. >> Ich habe eine Frage.

516
00:36:15,000 --> 00:36:19,000
Sollte es nicht Mittelpunkt sein - 1, da die erste Sache ist,

517
00:36:19,000 --> 00:36:26,000
es ist 0 indiziert, so dass, wenn wir 4 gesetzt, das ist eigentlich nicht der Charakter, den wir suchen?

518
00:36:26,000 --> 00:36:30,000
Ja, und das andere Problem mit diesem ist-

519
00:36:30,000 --> 00:36:35,000
Das ist ein großer Fang, denn was wird am Ende geschieht möglicherweise

520
00:36:35,000 --> 00:36:42,000
wenn wir uns bewegen und halten wir nicht immer zunächst einstellen?

521
00:36:42,000 --> 00:36:46,000
Ich denke, was wir am Ende tut zuzugreifen versucht

522
00:36:46,000 --> 00:36:49,000
das Element an der achten Position des Arrays,

523
00:36:49,000 --> 00:36:53,000
die in diesem Fall nicht vorhanden.

524
00:36:53,000 --> 00:36:56,000
Wir wollen eine Art der Bilanzierung von der Tatsache zu tun

525
00:36:56,000 --> 00:36:59,000
dass wir einige Null-Indizierung.

526
00:36:59,000 --> 00:37:05,000
[Charlotte] Sorry, ich meinte Mittelpunkt - 1 in den eckigen Klammern.

527
00:37:05,000 --> 00:37:08,000
Wir können das tun.

528
00:37:08,000 --> 00:37:10,000
Wir kommen auf diese Frage zurückzukommen in nur ein bisschen.

529
00:37:10,000 --> 00:37:13,000
Sobald wir beginnen, auf die tatsächliche Looping zu bekommen,

530
00:37:13,000 --> 00:37:16,000
das ist, wenn wir wirklich sehen, diese ins Spiel kommen.

531
00:37:16,000 --> 00:37:21,000
Zur Zeit können wir dies tun, aber du bist völlig richtig.

532
00:37:21,000 --> 00:37:28,000
Das Null-Indizierung wird eine Wirkung, die wir zur Rechenschaft ziehen müssen.

533
00:37:28,000 --> 00:37:30,000
Mal sehen.

534
00:37:30,000 --> 00:37:34,000
>> Wie ist die größer und kleiner als-?

535
00:37:34,000 --> 00:37:36,000
[Student] ich, wie die größer und kleiner als Teil tun.

536
00:37:36,000 --> 00:37:41,000
Ich war mir nicht sicher, was zu drucken, wenn Sie, dass es weniger als Heuhaufen Mittelpunkt oder größer ist als zu finden.

537
00:37:41,000 --> 00:37:43,000
Hier kann ich retten, was ich habe-

538
00:37:43,000 --> 00:37:47,000
[Nate] Ja, wenn Sie sparen, was du hast, und wir werden es nach oben ziehen.

539
00:37:47,000 --> 00:37:49,000
Dort gehen wir.

540
00:37:49,000 --> 00:37:51,000
[Student] Und ich legte Fragezeichen für das, was ich nicht wusste.

541
00:37:51,000 --> 00:37:54,000
[Nate] Das sieht gut aus.

542
00:37:54,000 --> 00:37:58,000
Hier haben wir Fragezeichen haben, weil wir noch nicht wissen,

543
00:37:58,000 --> 00:38:06,000
was wir ganz noch nicht.

544
00:38:06,000 --> 00:38:12,000
Was würden wir tun wollen-oops, wir haben einige Klammern alle funky auf uns.

545
00:38:12,000 --> 00:38:15,000
Wir korrigieren diese Klammern.

546
00:38:15,000 --> 00:38:19,000
Dort gehen wir.

547
00:38:19,000 --> 00:38:22,000
Und was wollen wir tun, nach unserem Algorithmus,

548
00:38:22,000 --> 00:38:27,000
wenn wir nicht finden die Nadel?

549
00:38:27,000 --> 00:38:32,000
Sprich im Fall, dass die Nadel weniger als das, was wir sehen, ist. Kevin.

550
00:38:32,000 --> 00:38:34,000
Nur an der linken Hälfte zu suchen.

551
00:38:34,000 --> 00:38:40,000
Richtig, also wir stellen einen Kommentar hier, der sagt "am linken Hälfte sehen."

552
00:38:40,000 --> 00:38:46,000
Und wenn die Nadel größer ist als der Heuhaufen in der Mitte, was wir tun wollen?

553
00:38:46,000 --> 00:38:48,000
[Student] Dann auf der rechten Hälfte zu suchen.

554
00:38:48,000 --> 00:38:53,000
Schauen Sie sich die rechte Hälfte "an rechten Hälfte sehen."

555
00:38:53,000 --> 00:38:58,000
Nicht zu schäbig.

556
00:38:58,000 --> 00:39:05,000
Okay, so an diesem Punkt, sieht es ziemlich gut.

557
00:39:05,000 --> 00:39:13,000
Das Problem mit dem Code geschrieben ist, was als?

558
00:39:13,000 --> 00:39:15,000
[Student] Sie haben noch Endpunkte für den Hälften.

559
00:39:15,000 --> 00:39:18,000
Richtig, wir haben keine Endpunkte für den Hälften.

560
00:39:18,000 --> 00:39:20,000
Wir sind auch nur gehen, um durch diese sofort gehen.

561
00:39:20,000 --> 00:39:23,000
Wir sind nur gehen, um ein Mittelpunkt zu suchen.

562
00:39:23,000 --> 00:39:27,000
Entweder das Element da ist, oder es ist nicht.

563
00:39:27,000 --> 00:39:34,000
Um dies zu bewerkstelligen, müssen wir irgendeine Art von Wiederholung zu tun.

564
00:39:34,000 --> 00:39:39,000
Wir müssen immer wiederholen, bis wir feststellen, dass

565
00:39:39,000 --> 00:39:43,000
entweder das Element in dort, weil wir nach unten und habe verengt es dann endlich gefunden,

566
00:39:43,000 --> 00:39:46,000
oder es ist nicht da, weil wir durch all die Dinge sah

567
00:39:46,000 --> 00:39:52,000
in den entsprechenden Hälften der Anordnung und festgestellt, dass nichts vorhanden ist.

568
00:39:52,000 --> 00:39:56,000
>> Wann immer wir haben diese Wiederholung los ist, was machen wir zu benutzen?

569
00:39:56,000 --> 00:39:58,000
[Student] Eine Schleife.

570
00:39:58,000 --> 00:40:00,000
Irgendeine Art von Schleife. Ja.

571
00:40:00,000 --> 00:40:03,000
[Student] Können wir eine do-while-Schleife und haben es tun, und dann, während

572
00:40:03,000 --> 00:40:10,000
die Nadel nicht gleich-ich bin nicht sicher, wo ich mit, dass geht.

573
00:40:10,000 --> 00:40:18,000
Aber Art wie das tun, solange er nicht gleich dem Wert, den die Benutzereingabe.

574
00:40:18,000 --> 00:40:21,000
Yeah, also schauen wir mal, wie könnte dies selbst schreiben?

575
00:40:21,000 --> 00:40:23,000
Du hast gesagt, verwenden wir eine do-while-Schleife.

576
00:40:23,000 --> 00:40:26,000
Woher kommt das tun, start?

577
00:40:26,000 --> 00:40:33,000
[Student] Gleich nach der Größe / 2.

578
00:40:33,000 --> 00:40:42,000
[Nate] Okay, und was sollen wir tun?

579
00:40:42,000 --> 00:40:44,000
Wir werden in der Zeit später zu füllen.

580
00:40:44,000 --> 00:40:46,000
Was sollen wir tun?

581
00:40:46,000 --> 00:40:49,000
[Student] Wollen wir nicht alle das Zeug haben wir in der if Teil?

582
00:40:49,000 --> 00:40:52,000
[Nate] Mögen all dieses Zeug, great.

583
00:40:52,000 --> 00:40:55,000
Copy und Paste.

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

585
00:40:59,000 --> 00:41:03,000
Mal sehen, ob das funktioniert, wenn wir können tab dieses vorbei.

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

587
00:41:08,000 --> 00:41:16,000
Okay, und wir speichern Sie diese, so dass Sie Jungs es haben.

588
00:41:16,000 --> 00:41:21,000
Alles klar, und wir werden dies tun, während-

589
00:41:21,000 --> 00:41:25,000
was war das, während Bedingung, die Sie nach waren?

590
00:41:25,000 --> 00:41:31,000
[Student] Während die Nadel nicht gleich, so wie das Ausrufezeichen.

591
00:41:31,000 --> 00:41:37,000
Aber ich bin nicht sicher, was genau das noch ist.

592
00:41:37,000 --> 00:41:39,000
[Nate] Ja, das ist ein Weg, es zu tun.

593
00:41:39,000 --> 00:41:41,000
Sam, hast du einen Kommentar?

594
00:41:41,000 --> 00:41:43,000
[Sam] Ich erinnerte mich, als ich die Videos sah,

595
00:41:43,000 --> 00:41:48,000
Ich nahm einen Screenshot von einer der-artigen, wenn wir den Pseudocode tat für sie,

596
00:41:48,000 --> 00:41:52,000
es gab einige Beziehung zwischen max und min.

597
00:41:52,000 --> 00:41:58,000
Ich denke, es war so etwas wie, wenn max ist immer weniger als min.

598
00:41:58,000 --> 00:42:00,000
Got it.

599
00:42:00,000 --> 00:42:04,000
[Sam] Oder wie wenn max nicht weniger als min oder so ähnlich,

600
00:42:04,000 --> 00:42:06,000
denn das würde bedeuten, dass Sie alles, was gesucht.

601
00:42:06,000 --> 00:42:13,000
>> Ja, so wie sieht es max und min wurden beziehe klingen?

602
00:42:13,000 --> 00:42:16,000
[Sam] Werte, die-ganze Zahlen, die sich ändern werden

603
00:42:16,000 --> 00:42:18,000
bezogen auf wo wir den Mittelpunkt.

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

605
00:42:20,000 --> 00:42:24,000
[Sam] An diesem Punkt ist es [unverständlich] Berechnung der max und min. Gehen

606
00:42:24,000 --> 00:42:29,000
Midpoint ist max und min Idee.

607
00:42:29,000 --> 00:42:35,000
Macht das Sinn, um die Leute?

608
00:42:35,000 --> 00:42:39,000
Wenn wir beginnen, wie werden wir diese Iteration tun hatten,

609
00:42:39,000 --> 00:42:43,000
Sie sind völlig richtig, dass wir irgendeine Art von do-while-Schleife verwenden möchten.

610
00:42:43,000 --> 00:42:49,000
Aber ich denke, wenn wir uns erinnern, was passiert an der Stelle dieses Arrays

611
00:42:49,000 --> 00:42:53,000
und was tatsächlich passiert-ich bin nun schreiben hier-

612
00:42:53,000 --> 00:42:58,000
bei der ersten Iteration der binären Suche, haben-wir

613
00:42:58,000 --> 00:43:05,000
Ich werde b und e verwenden, um den Anfang zu bezeichnen.

614
00:43:05,000 --> 00:43:10,000
Und dann das Ende unserer Array.

615
00:43:10,000 --> 00:43:14,000
Wir wissen, dass der Anfang bei 4 rechts ist hier drüben,

616
00:43:14,000 --> 00:43:18,000
und wir wissen, dass das Ende bei 108 ist.

617
00:43:18,000 --> 00:43:23,000
Sagen, dass wir für die Zahl 15 suchen.

618
00:43:23,000 --> 00:43:27,000
Das erste Mal, dass wir dies tun, wie wir gesehen haben,

619
00:43:27,000 --> 00:43:30,000
der Mittelpunkt ist entweder zu 16 oder 23 zu sein

620
00:43:30,000 --> 00:43:34,000
je nachdem, wie berechnen wir die Dinge aus.

621
00:43:34,000 --> 00:43:37,000
Da gleichmäßig geteilt in der Mitte würde uns diesen Raum

622
00:43:37,000 --> 00:43:42,000
zwischen 16 und 23, können wir nicht gleichmäßig teilen sie

623
00:43:42,000 --> 00:43:47,000
oder teilen und Sie erhalten in einem echten Mittelpunkt.

624
00:43:47,000 --> 00:43:49,000
Wir bei 16 aussehen.

625
00:43:49,000 --> 00:43:55,000
Wir werden erkennen, "Hey, 16> 15, dass wir suchen."

626
00:43:55,000 --> 00:43:59,000
Um dann bei der linken Hälfte des Arrays aussehen

627
00:43:59,000 --> 00:44:03,000
was wir am Ende tun, ist zu verwerfen

628
00:44:03,000 --> 00:44:07,000
Dieses gesamte obere Abschnitt

629
00:44:07,000 --> 00:44:16,000
und sagen: "Okay, jetzt unsere Endpunkt wird hier sein."

630
00:44:16,000 --> 00:44:22,000
Die nächste Iteration der Schleife, wir jetzt nach diesem Array

631
00:44:22,000 --> 00:44:25,000
effektiv mit diesen Teil verworfen, weil jetzt

632
00:44:25,000 --> 00:44:30,000
wenn wir unter den Mittelpunkt, um die Differenz zwischen dem Anfang und dem Ende,

633
00:44:30,000 --> 00:44:34,000
finden wir unsere Mitte zu 8 betragen,

634
00:44:34,000 --> 00:44:40,000
die können wir dann testen 8 zu sehen, wo es in Bezug auf die Zahl, die wir suchen, ist,

635
00:44:40,000 --> 00:44:44,000
15, finden Sie, dass 15 größer ist,

636
00:44:44,000 --> 00:44:49,000
so müssen wir auf dem rechten Teil der Liste zu verschieben,

637
00:44:49,000 --> 00:44:51,000
denen wir wissen, weil wir Menschen sind, und wir können es sehen.

638
00:44:51,000 --> 00:44:54,000
Wir wissen, dass der rechte Teil sein wird, wo wir es finden,

639
00:44:54,000 --> 00:45:01,000
aber der Computer nicht weiß, dass, so, was wir tun wir eigentlich

640
00:45:01,000 --> 00:45:04,000
haben diese gehen, und jetzt der Anfang und das Ende

641
00:45:04,000 --> 00:45:11,000
sind die gleichen Stelle, so der Mittelpunkt wird die einzige Nummer in der Liste an diesem Punkt,

642
00:45:11,000 --> 00:45:16,000
die ist 15, und wir haben es gefunden.

643
00:45:16,000 --> 00:45:21,000
Heißt das etwas Licht auf, wo diese ganze max und min-Notation wird,

644
00:45:21,000 --> 00:45:24,000
Verfolgen von den Endpunkten des Arrays, um herauszufinden

645
00:45:24,000 --> 00:45:35,000
how, um gezieltere Dinge nach unten?

646
00:45:35,000 --> 00:45:42,000
>> Was würde passieren, wenn das nicht gleich 15 jetzt?

647
00:45:42,000 --> 00:45:52,000
Was, wenn wir für 15 und stattdessen suchten, waren diese Zahl auch 16?

648
00:45:52,000 --> 00:45:54,000
Wir würden sagen, "Oh, er größer ist.

649
00:45:54,000 --> 00:45:57,000
Wir wollen zurück nach links. "

650
00:45:57,000 --> 00:46:01,000
Und wir würden unsere E nach rechts zu bewegen,

651
00:46:01,000 --> 00:46:06,000
An diesem Punkt haben wir einen Endpunkt, der in Konflikt würde.

652
00:46:06,000 --> 00:46:09,000
Es wäre nicht in der Lage, für jede mehrere Elemente durchsuchen

653
00:46:09,000 --> 00:46:13,000
denn jetzt haben wir unsere Endpunkt und unseren Anfangspunkt,

654
00:46:13,000 --> 00:46:16,000
unsere max und unsere min, sind jetzt umgedreht.

655
00:46:16,000 --> 00:46:23,000
Wir durch das gesamte Array zu suchen. Wir können nichts finden.

656
00:46:23,000 --> 00:46:27,000
Das ist der Punkt, an dem wir sagen wollen: "Okay, wir werden diesen Algorithmus stoppen würde.

657
00:46:27,000 --> 00:46:34,000
Wir haben nichts gefunden. Wir wissen, dass es hier nicht. "

658
00:46:34,000 --> 00:46:36,000
Wie soll das?

659
00:46:36,000 --> 00:46:40,000
[Student] Wie genau funktioniert der Computer automatisch das Ende?

660
00:46:40,000 --> 00:46:45,000
Wie funktioniert das Ende am Ende vor dem Anfang?

661
00:46:45,000 --> 00:46:48,000
Das Ende endet vor Beginn

662
00:46:48,000 --> 00:46:54,000
wegen der Mathematik, dass wir gehen jedes Mal tun wir dies tun.

663
00:46:54,000 --> 00:47:00,000
Die Art und Weise wir tauschen ist, wenn man sich das erste Mal sehen wir diese Swap tun

664
00:47:00,000 --> 00:47:03,000
wo wir den Anfang bei 4 und das Ende

665
00:47:03,000 --> 00:47:13,000
den ganzen Weg hinunter auf 108 und unser Mittelpunkt, sagen wir, bei 16 -

666
00:47:13,000 --> 00:47:20,000
Ich werde diese wieder zurückzusetzen 15-wenn wir für die 15 suchen,

667
00:47:20,000 --> 00:47:25,000
wir wussten, dass das, was wir, wenn wir die 16 geprüft habe und sah, dass es größer war

668
00:47:25,000 --> 00:47:28,000
und wollte die ganze rechte Teil der Liste zu verwerfen,

669
00:47:28,000 --> 00:47:36,000
sahen wir, dass das, was wir tun wollten, ist diese E hier bewegen.

670
00:47:36,000 --> 00:47:44,000
Effektiv wurde die E zu einem vor der Mitte bewegt.

671
00:47:44,000 --> 00:47:48,000
Ebenso, wenn wir machten diese Iteration des Algorithmus

672
00:47:48,000 --> 00:47:51,000
und der Mittelpunkt war 8,

673
00:47:51,000 --> 00:47:55,000
wir festgestellt, dass 8 <15, so dass wir die b bewegen wollte

674
00:47:55,000 --> 00:48:00,000
ein hinter dem Mittelpunkt.

675
00:48:00,000 --> 00:48:07,000
Nun sind der Anfang und das Ende sowohl miteinander an diesem 15.

676
00:48:07,000 --> 00:48:10,000
>> Wenn wir würden geschehen, um einen anderen Wert, nicht 15 sehen,

677
00:48:10,000 --> 00:48:14,000
oder, wenn dies 15 hatte statt eine 16,

678
00:48:14,000 --> 00:48:20,000
würden wir festgestellt, dass die e wir ein, bevor der Mitte verschieben wollen haben.

679
00:48:20,000 --> 00:48:33,000
Nun ist die e wäre es klappte weniger als die b.

680
00:48:33,000 --> 00:48:39,000
Lassen Sie uns durch, wie wir tatsächlich am Ende Kodierung diesen Algorithmus zu gehen.

681
00:48:39,000 --> 00:48:44,000
Wir wissen, dass wir diesen Mittelpunkt Berechnung haben wollen.

682
00:48:44,000 --> 00:48:48,000
Wir wissen auch, dass wir den Anfang und das Ende des Arrays verfolgen möchten

683
00:48:48,000 --> 00:48:51,000
unserer aktuellen Array, so dass wir herausfinden können,

684
00:48:51,000 --> 00:48:56,000
wo diese linke Hälfte der Liste ist und wo die rechte Hälfte der Liste ist.

685
00:48:56,000 --> 00:49:03,000
Wir tun das entweder mit Anfang und Ende,

686
00:49:03,000 --> 00:49:07,000
oder wir können sie min und max.

687
00:49:07,000 --> 00:49:10,000
Ich benutze beginnen und enden diese Zeit.

688
00:49:10,000 --> 00:49:15,000
Wenn wir anfangen, wenn wir blicken zurück auf unser Beispiel hier unten,

689
00:49:15,000 --> 00:49:20,000
unseren Anfängen wurde an den Anfang des Arrays gesetzt, wie natürlich.

690
00:49:20,000 --> 00:49:25,000
Welche Index war das? Was sollte unsere beginnen?

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, so könnten wir es gleich Heuhaufen [0].

694
00:49:37,000 --> 00:49:40,000
Das Problem ist jedoch, dass dies nicht gibt uns die Position des ersten Elements.

695
00:49:40,000 --> 00:49:45,000
Es gibt uns den Index des ersten Elementes oder dem tatsächlichen Wert an dieser ersten Position befindet.

696
00:49:45,000 --> 00:49:47,000
[Student] Das wird zu 0,20 konvertieren?

697
00:49:47,000 --> 00:49:52,000
[Nate] Was wird dies tun wird-gut, es wird nichts Verarbeitung.

698
00:49:52,000 --> 00:49:56,000
Was wird es tun, ist es eine 4 in beginnen zu speichern,

699
00:49:56,000 --> 00:49:59,000
und dann wird es schwer sein, Vergleiche mit Beginn machen

700
00:49:59,000 --> 00:50:03,000
weil begin werden Halten des Wertes von 4,

701
00:50:03,000 --> 00:50:06,000
das ist der Beginn unseres Array,

702
00:50:06,000 --> 00:50:08,000
aber wir wollen die Indizes im Array zu verfolgen

703
00:50:08,000 --> 00:50:11,000
im Gegensatz zu den Werten entgegengesetzt.

704
00:50:11,000 --> 00:50:17,000
Wir eigentlich eine 0, so.

705
00:50:17,000 --> 00:50:20,000
Für das Ende des Array-Charlotte brachte diese bis ein wenig früher.

706
00:50:20,000 --> 00:50:23,000
Dies ist, wo wir berücksichtigen nehme die Null Indizierung.

707
00:50:23,000 --> 00:50:25,000
>> Charlotte, was ist das Ende des Arrays?

708
00:50:25,000 --> 00:50:28,000
Was ist der Index des Endes?

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

710
00:50:30,000 --> 00:50:32,000
Ja, und welche Größe sollten wir verwenden?

711
00:50:32,000 --> 00:50:35,000
Sollten wir Kapital Größe oder Kleinbuchstaben Größe?

712
00:50:35,000 --> 00:50:37,000
Kapital Größe.

713
00:50:37,000 --> 00:50:42,000
In diesem Fall könnten wir Kapital Größe.

714
00:50:42,000 --> 00:50:45,000
Wenn wir wollten diese Funktion tragbar sein

715
00:50:45,000 --> 00:50:48,000
und verwenden Sie diese Funktion in anderen Programmen

716
00:50:48,000 --> 00:50:50,000
können wir tatsächlich nutzen Kleinbuchstaben Größe.

717
00:50:50,000 --> 00:50:52,000
Es ist auch in Ordnung.

718
00:50:52,000 --> 00:51:01,000
Aber Charlotte ist völlig richtig, dass wir die Größe haben wollen - 1.

719
00:51:01,000 --> 00:51:03,000
An diesem Punkt-

720
00:51:03,000 --> 00:51:05,000
[Student] Wie ist es, dass Sie Großbuchstaben Größe zu verwenden?

721
00:51:05,000 --> 00:51:07,000
Wie kommt es, dass wir in Großbuchstaben Größe zu verwenden?

722
00:51:07,000 --> 00:51:13,000
Es stellt sich heraus, dass diese # definiert sind wirklich,

723
00:51:13,000 --> 00:51:19,000
unter der Haube, finden Sie einen Text wie und zu ersetzen, wenn das Sinn macht.

724
00:51:19,000 --> 00:51:24,000
Wenn Sie Ihren Code zu kompilieren, der Vorlaufphase

725
00:51:24,000 --> 00:51:27,000
der Compiler durchläuft der Datei,

726
00:51:27,000 --> 00:51:31,000
und es sieht für überall, dass Sie Kapital Größe geschrieben,

727
00:51:31,000 --> 00:51:39,000
und ersetzt den Text buchstäblich mit einer 8, einfach so.

728
00:51:39,000 --> 00:51:42,000
In diesem Sinne ist etwas ganz anderes als eine Variable.

729
00:51:42,000 --> 00:51:45,000
Es dauert nicht keinen Platz im Speicher.

730
00:51:45,000 --> 00:51:52,000
Es ist ein einfaches Text zu ersetzen Trick.

731
00:51:52,000 --> 00:51:57,000
In diesem Fall werden wir Größe zu verwenden.

732
00:51:57,000 --> 00:52:01,000
Von hier aus wollen, um irgendeine Art von Wiederholung zu tun,

733
00:52:01,000 --> 00:52:03,000
und wir sind auf dem richtigen Weg mit unserer do-while-Schleife.

734
00:52:03,000 --> 00:52:08,000
Wir wollen etwas tun, bis eine Bedingung nicht mehr zu halten,

735
00:52:08,000 --> 00:52:12,000
und wie wir bereits gesehen haben, sahen wir, dass diese Bedingung

736
00:52:12,000 --> 00:52:19,000
war in der Tat, dass wir nicht wollen, das Ende

737
00:52:19,000 --> 00:52:24,000
kleiner sein als das zu beginnen.

738
00:52:24,000 --> 00:52:26,000
>> Dies ist unser Stoppbedingung.

739
00:52:26,000 --> 00:52:35,000
Wenn dies der Fall ist, wollen wir stoppen und wie erklären "Hey, wir haben nichts gefunden."

740
00:52:35,000 --> 00:52:43,000
Um dies auszudrücken, wollen wir eine Art Schleife verwenden.

741
00:52:43,000 --> 00:52:49,000
In diesem Fall würde es sich um eine do-while-Schleife sein, eine for-Schleife, eine while-Schleife?

742
00:52:49,000 --> 00:52:51,000
Wir haben eine do-while-Schleife hier.

743
00:52:51,000 --> 00:52:53,000
Sie Kerle wie dieser Ansatz?

744
00:52:53,000 --> 00:52:59,000
Meinst du, wir sollten einen anderen Ansatz zu versuchen?

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

746
00:53:01,000 --> 00:53:06,000
Wir könnten eine while-Schleife, weil wir wissen, maximale

747
00:53:06,000 --> 00:53:11,000
größer wäre als min an den Start sowieso.

748
00:53:11,000 --> 00:53:14,000
Ja, es gibt also keine Initialisierung, geschehen muss.

749
00:53:14,000 --> 00:53:17,000
Diese do-while-Schleifen sind toll, wenn Sie etwas zu initialisieren

750
00:53:17,000 --> 00:53:21,000
bevor dann testen, wobei hier

751
00:53:21,000 --> 00:53:26,000
wir wissen, dass wir nicht zu halten Reinitialisierung beginnen und enden

752
00:53:26,000 --> 00:53:28,000
jeder Runde der Schleife.

753
00:53:28,000 --> 00:53:32,000
Wir wissen, dass wir sie initialisieren möchten, dann besuchen Sie unsere Bedingung.

754
00:53:32,000 --> 00:53:38,000
In diesem Fall werde ich tatsächlich mit einem einfachen while-Schleife gehen.

755
00:53:38,000 --> 00:53:44,000
Es stellt sich heraus, dass do-while-Schleifen relativ selten verwendet werden.

756
00:53:44,000 --> 00:53:49,000
Viele Orte haben nicht einmal lehren, while-Schleifen.

757
00:53:49,000 --> 00:53:53,000
Sie sind gut für den Umgang mit Benutzereingaben, so haben wir eine Menge von ihnen bisher gesehen.

758
00:53:53,000 --> 00:53:59,000
Aber normal und while-Schleifen sind viel häufiger.

759
00:53:59,000 --> 00:54:03,000
Es stellt sich heraus, dass diese Bedingung als schriftliche

760
00:54:03,000 --> 00:54:09,000
nicht wirklich tun uns viel Gutes, und warum ist das so?

761
00:54:09,000 --> 00:54:11,000
Es tut mir leid, ich weiß nicht, Ihren Namen.

762
00:54:11,000 --> 00:54:13,000
Ich bin Jerry. >> Sorry?

763
00:54:13,000 --> 00:54:15,000
Es ist in der 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
Ich sehe dich nicht auf meiner Liste.

766
00:54:23,000 --> 00:54:26,000
Oh, es ist, weil-oh, das macht Sinn.

767
00:54:26,000 --> 00:54:31,000
Haben Sie eine Idee, warum diese while-Schleife möglicherweise nicht wie vorgesehen funktioniert,

768
00:54:31,000 --> 00:54:38,000
Als mit der Bedingung geschrieben?

769
00:54:38,000 --> 00:54:43,000
[Jerry] Du meinst, wie du all das Zeug, nachdem sie in Not the-?

770
00:54:43,000 --> 00:54:46,000
Ja, das ist so, dass man.

771
00:54:46,000 --> 00:54:49,000
Vielleicht müssen wir all diese Sachen in der while-Schleife, die völlig wahr ist gestellt.

772
00:54:49,000 --> 00:54:55,000
Die andere Sache, die ein wenig problematisch ist allerdings, dass diese Bedingung nicht funktioniert.

773
00:54:55,000 --> 00:54:57,000
[Student] Sie benötigen, um es umzudrehen.

774
00:54:57,000 --> 00:55:04,000
Richtig, so ist diese Bedingung nicht immer wahr sein zunächst die Art, wie wir darüber gesprochen.

775
00:55:04,000 --> 00:55:08,000
Wir wollen etwas tun, bis Ende <Anfang,

776
00:55:08,000 --> 00:55:13,000
aber wir wollen etwas Weile zu tun

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

778
00:55:21,000 --> 00:55:24,000
>> Es ist das Umkehrung der Logik gibt.

779
00:55:24,000 --> 00:55:27,000
Ich bin schuldig gemacht, diese Fehler die ganze Zeit.

780
00:55:27,000 --> 00:55:31,000
[Student] Warum muss es auf weniger als oder gleich?

781
00:55:31,000 --> 00:55:33,000
Da haben Sie erinnern den Fall, dass wir bekamen

782
00:55:33,000 --> 00:55:36,000
wo es nur ein Element, und wir waren unten,

783
00:55:36,000 --> 00:55:43,000
und wir waren nur die 15 in unser Angebot suchen?

784
00:55:43,000 --> 00:55:47,000
Und unser Anfang und unser Ende waren die gleichen Element.

785
00:55:47,000 --> 00:55:50,000
Wir wollen sicherstellen, dass wir diesen Fall zu behandeln.

786
00:55:50,000 --> 00:55:54,000
Wenn wir das täten eine gerade kleiner,

787
00:55:54,000 --> 00:55:58,000
würden wir nur in der Lage sein, sich auf eine 2-Element-Array.

788
00:55:58,000 --> 00:56:06,000
Einmal bekamen wir bis zu dieser letzten Element, wäre das unser Element, würden wir nie finden.

789
00:56:06,000 --> 00:56:10,000
Hier können wir genau das tun, wie du gesagt hast.

790
00:56:10,000 --> 00:56:15,000
Wir können anfangen Plopp Zeug rechts in der Mitte unserer while-Schleife.

791
00:56:15,000 --> 00:56:20,000
Wir können plop in unserer Mitte.

792
00:56:20,000 --> 00:56:24,000
Wir können all diese nehmen, wenn Aussagen,

793
00:56:24,000 --> 00:56:30,000
ziehen sie aus dieser do-while-Schleife,

794
00:56:30,000 --> 00:56:34,000
plop sie in,

795
00:56:34,000 --> 00:56:39,000
aufräumen ein wenig,

796
00:56:39,000 --> 00:56:48,000
und ich werde weitermachen und speichern Sie diese Revision.

797
00:56:48,000 --> 00:56:53,000
Und an diesem Punkt sind wir schon ziemlich nahe.

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

799
00:56:55,000 --> 00:56:58,000
Ich glaube, Sie haben auch zu haben int Mittelpunkt = Größe - 1/2.

800
00:56:58,000 --> 00:57:01,000
Got it, Größe - 1/2.

801
00:57:01,000 --> 00:57:05,000
Gibt es etwas, was wir brauchen, um über dieser Linie ändern?

802
00:57:05,000 --> 00:57:10,000
Das war ein guter Fang.

803
00:57:10,000 --> 00:57:14,000
>> Was bedeutet Größe zu tun? Werden wir jemals Größe ändern?

804
00:57:14,000 --> 00:57:17,000
Um die Zeile wie diese zu halten, müssen wir die Größe zu ändern.

805
00:57:17,000 --> 00:57:21,000
Wir haben zur Veränderung der Größe jedes Mal, wenn wir um die for-Schleife.

806
00:57:21,000 --> 00:57:25,000
Aber denken Sie daran, wenn wir durch unser Beispiel gehen nur ein bisschen früher,

807
00:57:25,000 --> 00:57:30,000
und wir hatten den Anfang bei 4

808
00:57:30,000 --> 00:57:33,000
und das Ende den ganzen Weg über bei 108?

809
00:57:33,000 --> 00:57:35,000
Wie haben wir berechnen den Mittelpunkt?

810
00:57:35,000 --> 00:57:38,000
Wurden wir mit der Größe?

811
00:57:38,000 --> 00:57:40,000
Oder wir wurden mit Beginn und Ende statt?

812
00:57:40,000 --> 00:57:42,000
Es ist die Differenz zwischen dem Ende und dem Anfang.

813
00:57:42,000 --> 00:57:50,000
Genau, und wie genau soll ich schreiben, dass Charlotte?

814
00:57:50,000 --> 00:57:52,000
Nur am Ende - zu beginnen.

815
00:57:52,000 --> 00:57:55,000
Sie müssten nicht die tun - 1

816
00:57:55,000 --> 00:57:58,000
weil der - 1 hat am Ende aufgenommen werden und der bereits beginnen.

817
00:57:58,000 --> 00:58:00,000
[Nate] Great, bist du völlig Recht.

818
00:58:00,000 --> 00:58:03,000
Wir haben nicht die tun - 1, weil das - 1 aufgenommen hat

819
00:58:03,000 --> 00:58:08,000
und bilanziert, wenn wir zu initialisieren das Ende variabel.

820
00:58:08,000 --> 00:58:11,000
>> Gibt es etwas, was ich brauchen, um syntaktisch zu tun haben diese Linie sinnvoll?

821
00:58:11,000 --> 00:58:13,000
[Schüler] Plus beginnen. >> Plus-beginnen?

822
00:58:13,000 --> 00:58:15,000
[Student] Am Ende.

823
00:58:15,000 --> 00:58:20,000
Weil es nur die Hälfte der Länge berechnet.

824
00:58:20,000 --> 00:58:26,000
Sie müssen den Beginn hinzuzufügen.

825
00:58:26,000 --> 00:58:31,000
[Nate] Was würde das für uns berechnen?

826
00:58:31,000 --> 00:58:35,000
Wenn wir über Ende dieser ersten Iteration der Schleife denken,

827
00:58:35,000 --> 00:58:40,000
Ende wird in der Position index 7 sein.

828
00:58:40,000 --> 00:58:43,000
Beginnen Sie in der Position 0 ist.

829
00:58:43,000 --> 00:58:47,000
Denken Sie daran, wir sind für beide suchen

830
00:58:47,000 --> 00:58:52,000
Position 3 oder Position 4.

831
00:58:52,000 --> 00:58:56,000
Wenn wir an diesem Mathematik aussehen, nur um es ein wenig greifbarer,

832
00:58:56,000 --> 00:59:02,000
legte einige Zahlen hier, wir haben 7, 0,

833
00:59:02,000 --> 00:59:10,000
so 7 - 0, und dann / 2

834
00:59:10,000 --> 00:59:19,000
ist 3 in ganzzahligen Division, das ist.

835
00:59:19,000 --> 00:59:26,000
Dann müssen wir fügen Sie dann wieder unsere beginnen?

836
00:59:26,000 --> 00:59:28,000
Wir wollen nicht in diesem Fall.

837
00:59:28,000 --> 00:59:31,000
Auf der ersten Iteration, wird es in Ordnung sein, weil begin 0 ist.

838
00:59:31,000 --> 00:59:36,000
Aber wie wir Fortschritte machen wir wirklich alles brauchen

839
00:59:36,000 --> 00:59:42,000
end - begin / 2.

840
00:59:42,000 --> 00:59:46,000
Es gibt einen anderen Trick, und das ist nämlich eine der Vorrang.

841
00:59:46,000 --> 00:59:49,000
[Student] Müssen wir Klammern?

842
00:59:49,000 --> 00:59:53,000
[Nate] Genau, und das ist, weil, wenn wir nichts dagegen unternehmen, diese Klammern

843
00:59:53,000 --> 00:59:58,000
dann wird diese Linie statt interpretiert werden

844
00:59:58,000 --> 01:00:09,000
as (Ende) - (Beginn / 2), die wir definitiv nicht wollen.

845
01:00:09,000 --> 01:00:11,000
Achten Sie auf die Vorrangregeln.

846
01:00:11,000 --> 01:00:15,000
[Student] Warum ist es nicht enden + beginnen?

847
01:00:15,000 --> 01:00:17,000
Warum ist es nicht enden + beginnen?

848
01:00:17,000 --> 01:00:19,000
[Student] Warum ist es nicht so, dass?

849
01:00:19,000 --> 01:00:24,000
Warum wäre es + sein?

850
01:00:24,000 --> 01:00:26,000
Ich denke, du hast Recht.

851
01:00:26,000 --> 01:00:28,000
[Student] Weil es durchschnittlich ist?

852
01:00:28,000 --> 01:00:31,000
[Nate] End + beginnen, bist du völlig Recht.

853
01:00:31,000 --> 01:00:34,000
Wow, ich total vermasselt. Sie haben Recht.

854
01:00:34,000 --> 01:00:39,000
Wenn wir taten das Minus, würden wir wollen, um die Rückseite zu beginnen in. hinzuzufügen

855
01:00:39,000 --> 01:00:43,000
In diesem Fall sind Sie sehr richtig, dass wir den Durchschnitt der beiden nehmen wollen,

856
01:00:43,000 --> 01:00:45,000
so wir wollen, um sie hinzuzufügen, im Gegensatz zu ihnen zu subtrahieren.

857
01:00:45,000 --> 01:00:49,000
[Student] Es würde auch funktionieren, wenn Sie am Ende tat - begin / 2 + zu beginnen.

858
01:00:49,000 --> 01:00:55,000
Es wäre, wenn wir-ich glaube so.

859
01:00:55,000 --> 01:01:00,000
>> Zum Beispiel, wenn wir am Beginn der Suche,

860
01:01:00,000 --> 01:01:04,000
und wir verschoben es hier

861
01:01:04,000 --> 01:01:08,000
auf die 15.

862
01:01:08,000 --> 01:01:12,000
Jetzt beginnen die Position 2.

863
01:01:12,000 --> 01:01:15,000
Ende ist an Position 7.

864
01:01:15,000 --> 01:01:21,000
Wenn wir sie subtrahieren, erhalten wir 5.

865
01:01:21,000 --> 01:01:24,000
Kluft, die durch 2, erhalten wir 2.

866
01:01:24,000 --> 01:01:27,000
Und dann fügen wir 2 wieder an,

867
01:01:27,000 --> 01:01:30,000
und dass bringt uns zum vierten Position,

868
01:01:30,000 --> 01:01:33,000
was ist hier genau richtig, das ist der Mittelpunkt.

869
01:01:33,000 --> 01:01:36,000
[Student] Müssen wir kümmern Verpackung nehmen?

870
01:01:36,000 --> 01:01:39,000
In welchem ​​Sinne brauchen wir die Pflege Einwickeln nehmen?

871
01:01:39,000 --> 01:01:43,000
Wenn die Summe oder die Differenz zwischen

872
01:01:43,000 --> 01:01:45,000
je nachdem, wie wir tun, ist es nicht eine gerade Zahl ist.

873
01:01:45,000 --> 01:01:49,000
Dann wird der Computer wird, ob, wenn es 2,5 verwirrt;

874
01:01:49,000 --> 01:01:52,000
Sie nach links oder nach rechts, um zu bestimmen, welche der Mittelpunkt bewegen?

875
01:01:52,000 --> 01:01:54,000
Got it.

876
01:01:54,000 --> 01:01:56,000
Es stellt sich heraus, dass mit Integer-Division,

877
01:01:56,000 --> 01:01:59,000
wir nicht immer bekommen diese Gleitkommazahlen.

878
01:01:59,000 --> 01:02:01,000
Wir nie das Dezimalsystem.

879
01:02:01,000 --> 01:02:04,000
Es ist völlig verworfen.

880
01:02:04,000 --> 01:02:08,000
Wenn Sie einen Computer teilen zwei int-Variablen,

881
01:02:08,000 --> 01:02:11,000
und ein 7 ist, und das andere ist 2,

882
01:02:11,000 --> 01:02:13,000
Sie werden nicht 3,5 als Ergebnis.

883
01:02:13,000 --> 01:02:16,000
Es wird noch 3.

884
01:02:16,000 --> 01:02:19,000
Der Rest werden verworfen, so dass es effektiv Rundung

885
01:02:19,000 --> 01:02:24,000
keine runde, sondern eine Etage, wenn euch vertraut mit, dass in der Mathematik sind,

886
01:02:24,000 --> 01:02:27,000
wo Sie komplett verwerfen dezimal,

887
01:02:27,000 --> 01:02:31,000
und so du Wesentlichen abzuschneiden, auf die nächste

888
01:02:31,000 --> 01:02:33,000
ganze Position, auf die nächste ganze Zahl auf.

889
01:02:33,000 --> 01:02:38,000
[Student] Aber dann ist das problematisch, weil, wenn Sie ein Array von 7 Elemente

890
01:02:38,000 --> 01:02:43,000
dann ist automatisch die dritte Element aus dem Mittelpunkt anstelle der vierten.

891
01:02:43,000 --> 01:02:46,000
Wie gehen wir damit um?

892
01:02:46,000 --> 01:02:49,000
Es ist problematisch, denn wenn wir eine Reihe von 7 hatte,

893
01:02:49,000 --> 01:02:54,000
es würde wählen Sie die dritte Stelle der vierte.

894
01:02:54,000 --> 01:02:56,000
Könnten Sie erklären, ein wenig mehr?

895
01:02:56,000 --> 01:02:59,000
[Student] Denn wenn man 7 Elemente dann das vierte Element

896
01:02:59,000 --> 01:03:04,000
würde der Mittelpunkt sein, richtig?

897
01:03:04,000 --> 01:03:07,000
Angemeldet Ihren Kommentar zu gleich Null indiziert, though.

898
01:03:07,000 --> 01:03:10,000
[Student] Ja, so in Position 3. Das wäre der Mittelpunkt sein.

899
01:03:10,000 --> 01:03:12,000
Yeah.

900
01:03:12,000 --> 01:03:16,000
Oh, okay. Ich sehe, was du meinst.

901
01:03:16,000 --> 01:03:19,000
Es ist irgendwie seltsam, wie wir uns an dieser ganzen Vorstellung verwendet

902
01:03:19,000 --> 01:03:22,000
loszuwerden Dezimalstellen.

903
01:03:22,000 --> 01:03:26,000
Das ist ein großer Punkt.

904
01:03:26,000 --> 01:03:30,000
Wir beenden diese auf.

905
01:03:30,000 --> 01:03:32,000
Wir haben unsere Mittelpunkt berechnet.

906
01:03:32,000 --> 01:03:37,000
>> Wir testen, um zu sehen, ob unsere Nadel ist gleich dem mittleren Wert.

907
01:03:37,000 --> 01:03:41,000
Wir Bedrucken, dass wir es gefunden, aber wirklich, was wollen wir in dieser Situation tun?

908
01:03:41,000 --> 01:03:46,000
Wir haben es gefunden, so dass wir möchten, dass der Anrufer wissen, dass wir es gefunden.

909
01:03:46,000 --> 01:03:49,000
Wir haben eine Funktion, die ein boolean typisierte Funktion ist.

910
01:03:49,000 --> 01:03:54,000
Die Art, wie wir an den Anrufer unserer Funktion, dass wir bereit sind zu gehen

911
01:03:54,000 --> 01:03:58,000
wird man sagen, "Hey, das ist wahr."

912
01:03:58,000 --> 01:04:00,000
Wie würden wir das tun, Kevin?

913
01:04:00,000 --> 01:04:02,000
Sie nicken. >> [Kevin] In return true.

914
01:04:02,000 --> 01:04:06,000
[Nate] Genau, true zurückgeben.

915
01:04:06,000 --> 01:04:12,000
Nun, wenn es nicht gleich, wie würden wir an der linken Hälfte aussehen?

916
01:04:12,000 --> 01:04:16,000
Irgendwelche Ideen?

917
01:04:16,000 --> 01:04:18,000
Stella, irgendwelche Ideen?

918
01:04:18,000 --> 01:04:21,000
Sie müssen eine neue Position für Ende gesetzt.

919
01:04:21,000 --> 01:04:23,000
Yeah.

920
01:04:23,000 --> 01:04:29,000
So haben wir die Position des Mittelpunkts zu tun - das Ende.

921
01:04:29,000 --> 01:04:33,000
Great.

922
01:04:33,000 --> 01:04:36,000
Wir müssen eine neue Position für das Ende gesetzt

923
01:04:36,000 --> 01:04:38,000
auf der linken Hälfte betrachten.

924
01:04:38,000 --> 01:04:41,000
Das war, was wir gesprochen haben, bevor, wo

925
01:04:41,000 --> 01:04:44,000
I keep going back diesem Beispiel.

926
01:04:44,000 --> 01:04:50,000
Ich habe das hier zu beginnen, und dann habe ich am Ende alle den Weg hierher.

927
01:04:50,000 --> 01:04:53,000
>> Auch wenn wir für 15 suchen, und unser Mittelpunkt ist bei 16,

928
01:04:53,000 --> 01:04:56,000
und wir erkennen, "Oops, 16 größer ist.

929
01:04:56,000 --> 01:04:59,000
Wir wollen auf die linke Hälfte zu bewegen. "

930
01:04:59,000 --> 01:05:02,000
Wir würden dann den Ende der 15,

931
01:05:02,000 --> 01:05:06,000
Und das tun wir, indem man sich von der Mitte

932
01:05:06,000 --> 01:05:09,000
und Einstellung, dass als neuer Ende.

933
01:05:09,000 --> 01:05:12,000
Ebenso, wenn wir auf der rechten Hälfte aussehen wollen, wie würden wir das tun?

934
01:05:12,000 --> 01:05:14,000
Haben Sie eine Idee?

935
01:05:14,000 --> 01:05:22,000
[Student] Sie legen beginnen, + 1 Mittelpunkt.

936
01:05:22,000 --> 01:05:24,000
[Nate] Great.

937
01:05:24,000 --> 01:05:29,000
Und jetzt, im Fall, dass wir nichts finden,

938
01:05:29,000 --> 01:05:32,000
bedeutet, dass sich gekümmert für uns?

939
01:05:32,000 --> 01:05:36,000
Daniel, ist, dass Pflege für uns genommen werden?

940
01:05:36,000 --> 01:05:38,000
[Daniel] Nr.

941
01:05:38,000 --> 01:05:40,000
[Nate] Wenn wir es durch das gesamte Array und wir nichts finden,

942
01:05:40,000 --> 01:05:42,000
wo würden, dass gesorgt werden, oder sollten wir kümmern uns darum?

943
01:05:42,000 --> 01:05:44,000
[Daniel] Die while-Bedingung.

944
01:05:44,000 --> 01:05:48,000
[Nate] Ja, die while-Bedingung, genau.

945
01:05:48,000 --> 01:05:51,000
Es kümmert gehen durch das gesamte Array nehmen, wenn wir nichts finden.

946
01:05:51,000 --> 01:05:53,000
Diese while-Schleife wird beendet.

947
01:05:53,000 --> 01:05:56,000
Wir werden nie diesen Zustand erlebt haben,

948
01:05:56,000 --> 01:06:03,000
und wir können false zurück.

949
01:06:03,000 --> 01:06:10,000
Wir können auch verlassen Sie dies, wenn hier wie folgt

950
01:06:10,000 --> 01:06:14,000
denn wenn diese if-Anweisung wahr ist,

951
01:06:14,000 --> 01:06:16,000
und unsere Funktion gibt,

952
01:06:16,000 --> 01:06:21,000
und so werden wir im wesentlichen abort diese Funktion an dieser Stelle

953
01:06:21,000 --> 01:06:24,000
wenn wir wieder wahr.

954
01:06:24,000 --> 01:06:28,000
Aber was passiert mit dieser Struktur hier?

955
01:06:28,000 --> 01:06:34,000
Wird diese vollständig funktionieren, oder gibt es einige logische Fehler drin?

956
01:06:34,000 --> 01:06:37,000
>> Es gibt einige logische Fehler drin, mit der Art, es einzurichten ist.

957
01:06:37,000 --> 01:06:40,000
Was könnte es sein?

958
01:06:40,000 --> 01:06:43,000
[Student] Warum brauchen Sie die - und + 1s?

959
01:06:43,000 --> 01:06:47,000
Das setzt unser Angebot bis zu unserem neuen linken Hälfte und rechte Hälfte sein.

960
01:06:47,000 --> 01:06:51,000
[Student] Aber warum konntest du nicht tun, ohne die - 1s und + 1s?

961
01:06:51,000 --> 01:06:53,000
[Nate] Wir könnten es gleich auf den Mittelpunkt?

962
01:06:53,000 --> 01:07:04,000
Was könnte problematisch sein, darüber?

963
01:07:04,000 --> 01:07:08,000
[Student] Ich denke, es ist ineffizient, weil Sie die Kontrolle einen Wert, das bereits eingecheckte.

964
01:07:08,000 --> 01:07:11,000
[Nate] Genau, so Sam ist völlig richtig.

965
01:07:11,000 --> 01:07:15,000
Wenn Sie das Ende und den Beginn gleich der Mittelpunkt

966
01:07:15,000 --> 01:07:18,000
anstelle von - 1 und + 1 nachdenklich,

967
01:07:18,000 --> 01:07:22,000
an einem gewissen Punkt in der Zukunft werden wir am Ende die Überprüfung der Mitte wieder.

968
01:07:22,000 --> 01:07:26,000
[Student] Ich begann die pset, und dann hatte ich so etwas wie, dass

969
01:07:26,000 --> 01:07:30,000
wo ich vergaß die + 1, und es wurde in einer Endlosschleife.

970
01:07:30,000 --> 01:07:34,000
Richtig, weil man irgendwann wirst nie bekommen beginnen und enden

971
01:07:34,000 --> 01:07:39,000
tatsächlich überlappen.

972
01:07:39,000 --> 01:07:41,000
Cool.

973
01:07:41,000 --> 01:07:44,000
Es ist ein logischer Fehler, und das ist, dass dies auf jeden Fall

974
01:07:44,000 --> 01:07:48,000
ein else if.

975
01:07:48,000 --> 01:07:55,000
Woran kann das liegen?

976
01:07:55,000 --> 01:07:59,000
>> Der Grund dafür ist, wenn es nicht ein else if-hast du es, Kevin zu sehen?

977
01:07:59,000 --> 01:08:02,000
[Kevin] Ja, weil Sie ändern den Endpunkt.

978
01:08:02,000 --> 01:08:05,000
[Nate] Genau.

979
01:08:05,000 --> 01:08:07,000
Wir ändern den Endpunkt,

980
01:08:07,000 --> 01:08:12,000
und wenn es wie diese-wir schriftlich zu machen Leerzeichen zwischen-

981
01:08:12,000 --> 01:08:14,000
es prüft diesen Fall.

982
01:08:14,000 --> 01:08:18,000
Dieser Fall, wenn es gelingt, bricht aus der Funktion.

983
01:08:18,000 --> 01:08:21,000
Dann wird es zu überprüfen diese nächste Fall

984
01:08:21,000 --> 01:08:24,000
und wenn dies gelingt, wird es passen den Endpunkt,

985
01:08:24,000 --> 01:08:28,000
und dann wird es weiter auf und prüfen Sie in diesem Fall.

986
01:08:28,000 --> 01:08:31,000
Aber an diesem Punkt haben wir nicht wollen, dass es auch weiterhin überprüfen.

987
01:08:31,000 --> 01:08:35,000
Glücklicherweise haben wir nicht zurückgesetzt den Mittelpunkt hier

988
01:08:35,000 --> 01:08:39,000
und wir wissen, dass dieser Fall wird nicht gelingen.

989
01:08:39,000 --> 01:08:44,000
Aber wir wollen auf jeden Fall das andere zu stellen, wenn dort

990
01:08:44,000 --> 01:08:48,000
obwohl das könnte in diesem Fall

991
01:08:48,000 --> 01:08:52,000
da wir nicht Anpassung sind der Mittelpunkt, würde das einen Unterschied machen?

992
01:08:52,000 --> 01:08:54,000
Nein, denn diese Fälle sind alle exklusiv.

993
01:08:54,000 --> 01:08:58,000
Auch mein schlechtes.

994
01:08:58,000 --> 01:09:01,000
Wir wissen nicht, denke ich, brauchen diese else if.

995
01:09:01,000 --> 01:09:05,000
Wir können es versuchen, und führen Sie es aus und sehen, was passiert.

996
01:09:05,000 --> 01:09:08,000
Building, ist ein Fehler aufgetreten.

997
01:09:08,000 --> 01:09:12,000
Es ist wahrscheinlich, weil ich diese b-und e die links hier.

998
01:09:12,000 --> 01:09:14,000
Muss ich noch mehr von denen an der Spitze?

999
01:09:14,000 --> 01:09:16,000
Es ist nicht so aussehen.

1000
01:09:16,000 --> 01:09:20,000
Wir verkleinern, zu bauen,

1001
01:09:20,000 --> 01:09:24,000
dort geht es, so jetzt, wenn wir für 15 suchen,

1002
01:09:24,000 --> 01:09:28,000
Ja.

1003
01:09:28,000 --> 01:09:30,000
Lassen Sie mich zu vergrößern in.

1004
01:09:30,000 --> 01:09:33,000
15, ja. Wir können es wieder laufen.

1005
01:09:33,000 --> 01:09:36,000
Hochladen Quellcode, Bau, läuft.

1006
01:09:36,000 --> 01:09:41,000
Wir können so etwas wie 13 zu suchen,

1007
01:09:41,000 --> 01:09:45,000
und wir haben nichts bekommen Ausdrucken, so dass es nicht zu finden, dass für uns.

1008
01:09:45,000 --> 01:09:51,000
Das ist toll, weil es nicht in unserer Liste.

1009
01:09:51,000 --> 01:09:53,000
>> Wir sind jetzt die Zeit davon.

1010
01:09:53,000 --> 01:09:55,000
Das wird es sein, für diese Woche.

1011
01:09:55,000 --> 01:10:00,000
Thanks for joining, und wir sehen uns später.

1012
01:10:00,000 --> 01:10:02,000
>> [CS50.TV]