1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [バイナリサーチ]

2
00:00:02,000 --> 00:00:04,000
[パトリック·シュミット - ハーバード大学]

3
00:00:04,000 --> 00:00:07,000
[これはCS50です。 -  CS50.TV]

4
00:00:07,000 --> 00:00:09,000
>> 私はあなたにアルファベット順にディズニーキャラクターの名前のリストを与えた場合

5
00:00:09,000 --> 00:00:11,000
そして、ミッキーマウスを見つけておくようにお願いし

6
00:00:11,000 --> 00:00:13,000
どうやってこれをやって行くか？

7
00:00:13,000 --> 00:00:15,000
自明な方法の1つは、リストを先頭からスキャンすることであろう

8
00:00:15,000 --> 00:00:18,000
それはミッキーもよいかどうかを確認し、すべての名前を確認します。

9
00:00:18,000 --> 00:00:22,000
しかし、あなたがアラジン、アリス、アリエルを読み取るなどのように、

10
00:00:22,000 --> 00:00:25,000
あなたはすぐにリストの先頭から開始するのは良いアイデアではなかったことに気づくでしょう。

11
00:00:25,000 --> 00:00:29,000
さて、多分あなたは、リストの最後から順番に作業を開始する必要があります。

12
00:00:29,000 --> 00:00:33,000
今、あなたは、ターザン、スティッチ、白雪姫などをお読みください。

13
00:00:33,000 --> 00:00:36,000
それでも、これはそれについて移動する最良の方法のように見えません。

14
00:00:36,000 --> 00:00:38,000
>> さて、あなたはこれをやって行くことができる別の方法は絞り込むしようとすることです

15
00:00:38,000 --> 00:00:41,000
あなたが見なければならないことが名前のリスト。

16
00:00:41,000 --> 00:00:43,000
あなたは彼らがアルファベット順になっていることを知っているので、

17
00:00:43,000 --> 00:00:45,000
あなただけのリストの中に名前が見てでした

18
00:00:45,000 --> 00:00:49,000
とミッキーマウスがこの名前の前か後かを確認してください。

19
00:00:49,000 --> 00:00:51,000
2番目の列に姓を見てみる

20
00:00:51,000 --> 00:00:54,000
あなたは、ミッキーのためにMはジャスミンのJの後に来ることを認識したい

21
00:00:54,000 --> 00:00:57,000
ので、単にリストの最初の半分を無視すると思います。

22
00:00:57,000 --> 00:00:59,000
あなたはおそらく最後の列の一番上を見てね

23
00:00:59,000 --> 00:01:02,000
それはラプンツェルで始まっていることを参照してください。

24
00:01:02,000 --> 00:01:06,000
ミッキーはラプンツェルの前に来る、我々は同様に最後の列を無視することができますように見えます。

25
00:01:06,000 --> 00:01:08,000
検索戦略を継続すると、すぐにわかるでしょうミッキー

26
00:01:08,000 --> 00:01:11,000
名前の残りのリストの最初の半分になっている

27
00:01:11,000 --> 00:01:14,000
そして最後にミッキーはマーリンとミニーの間に隠れて見つける。

28
00:01:14,000 --> 00:01:17,000
>> あなただけの何をしたかは、基本的には二分探索であった。

29
00:01:17,000 --> 00:01:22,000
この名前が示すように、それはバイナリの問題で、その探索戦略を実行します。

30
00:01:22,000 --> 00:01:24,000
これはどういう意味ですか？

31
00:01:24,000 --> 00:01:27,000
まあ、ソート項目のリストを指定して、バイナリ·サーチ·アルゴリズムは、バイナリ決定を行います - 

32
00:01:27,000 --> 00:01:33,000
左または右に、より大きいか、小さい、アルファベットの前か後か - 各ポイントで。

33
00:01:33,000 --> 00:01:35,000
今、私たちは、この探索アルゴリズムと一緒に行く名前を持っていること、

34
00:01:35,000 --> 00:01:38,000
別の例を見てみましょうが、ソート番号のリストとこの時間。

35
00:01:38,000 --> 00:01:43,000
我々はソート番号の一覧の中では番号144を探していると言う。

36
00:01:43,000 --> 00:01:46,000
前と同じように、私たちは途中での番号を見つける - 

37
00:01:46,000 --> 00:01:50,000
これは、この場合には13  - と144以上13以下であるかどうかを確認します。

38
00:01:50,000 --> 00:01:54,000
それが13よりも明らかに大きいですので、我々は13以下であるすべてのものを無視することができます

39
00:01:54,000 --> 00:01:57,000
そして残りの半分だけに集中しています。

40
00:01:57,000 --> 00:01:59,000
我々は今、左の項目の偶数を持っているので、

41
00:01:59,000 --> 00:02:01,000
我々は単に真ん中に近い番号を選択します。

42
00:02:01,000 --> 00:02:03,000
この場合、我々は55を選択します。

43
00:02:03,000 --> 00:02:06,000
我々は同じように簡単に89を選択した可能性があります。

44
00:02:06,000 --> 00:02:11,000
オーケー。繰り返しになりますが、144は55よりも大きいので、私たちは右に行く。

45
00:02:11,000 --> 00:02:14,000
幸いにも私たちのために、次の中間数は、144です

46
00:02:14,000 --> 00:02:16,000
私たちが探している1。

47
00:02:16,000 --> 00:02:21,000
だからバイナリ検索を使って144を見つけるために、我々は唯一の3つのステップでそれを見つけることができるしている。

48
00:02:21,000 --> 00:02:24,000
我々がここで線形検索を使用したならば、それは私たちに12の措置を講じていただろう。

49
00:02:24,000 --> 00:02:28,000
実際のところ、以来、この検索方法は、項目の数を半分に

50
00:02:28,000 --> 00:02:31,000
それは、各ステップで見ており、それが探しているアイテムを見つける

51
00:02:31,000 --> 00:02:35,000
リスト内の項目数の約ログインチ

52
00:02:35,000 --> 00:02:37,000
今、私たちは2つの例を見てきましたので、次に見てみましょう

53
00:02:37,000 --> 00:02:41,000
二分探索を実装再帰関数のためのいくつかの擬似コード。

54
00:02:41,000 --> 00:02:44,000
上から順番に、我々は4つの引数を取る関数を見つけなければならないことがわかります。

55
00:02:44,000 --> 00:02:47,000
キー配列、最小値、および最大値。

56
00:02:47,000 --> 00:02:51,000
キーは、前の例でそう144、我々が探しているものです。

57
00:02:51,000 --> 00:02:54,000
配列は、我々が検索している番号のリストです。

58
00:02:54,000 --> 00:02:57,000
minとmaxは最小位置と最大位置のインデックスです

59
00:02:57,000 --> 00:02:59,000
我々は、現在見ている。

60
00:02:59,000 --> 00:03:03,000
だから我々が開始すると、minがゼロになるとmaxは、配列の最大インデックスになります。

61
00:03:03,000 --> 00:03:07,000
我々は、検索を絞り込むように、我々は最小値と最大値を更新します

62
00:03:07,000 --> 00:03:10,000
我々はまだインチ探しているだけ範囲になるように

63
00:03:10,000 --> 00:03:12,000
>> の最初の興味深い部分にスキップしてみましょう。

64
00:03:12,000 --> 00:03:14,000
まず最初にすることは、中間点を見つけることです

65
00:03:14,000 --> 00:03:19,000
我々はまだ検討している配列のminとmaxの中間にあるインデックス。

66
00:03:19,000 --> 00:03:22,000
その後、我々はその中間位置に配列の値を見てみ

67
00:03:22,000 --> 00:03:25,000
我々が探している番号は、そのキーよりも小さい場合とを参照してください。

68
00:03:25,000 --> 00:03:27,000
その位置の数が少ない場合は、

69
00:03:27,000 --> 00:03:31,000
それはキーがその位置の左側にすべての数値よりも大きいことを意味します。

70
00:03:31,000 --> 00:03:33,000
だから我々は、再びバイナリ検索機能を呼び出すことができます。

71
00:03:33,000 --> 00:03:36,000
しかし、今回は半分だけを読むためにminとmaxパラメータを更新

72
00:03:36,000 --> 00:03:40,000
それがより大きいか、または私達はただ見て値に等しくなります。

73
00:03:40,000 --> 00:03:44,000
一方、キーが配列の現在の中点で数よりも少ない場合

74
00:03:44,000 --> 00:03:47,000
我々は左に行くと大きいすべての数字を無視したい。

75
00:03:47,000 --> 00:03:52,000
再び、我々はminとmaxの範囲で更新されたバイナリ·サーチが、今回を呼び出す

76
00:03:52,000 --> 00:03:54,000
ちょうど下半分を含めることができます。

77
00:03:54,000 --> 00:03:57,000
配列内の現在の中点での値がどちらである場合

78
00:03:57,000 --> 00:04:01,000
キーよりも小さいよりも大きい場合は、キーと等しくなければなりません。

79
00:04:01,000 --> 00:04:05,000
したがって、私たちは、単に現在の中点インデックスを返すことができ、我々は完了です。

80
00:04:05,000 --> 00:04:09,000
最後に、ここでは、このチェックは、その数は場合の例です。

81
00:04:09,000 --> 00:04:11,000
我々が検索している数値の配列で、実際にはありません。

82
00:04:11,000 --> 00:04:14,000
もし我々が探している範囲の最大インデックス

83
00:04:14,000 --> 00:04:17,000
我々は行き過ぎだということ最低限、これまでより少なくなります。

84
00:04:17,000 --> 00:04:20,000
番号は入力配列ではありませんでしたので、私たちは-1を返す

85
00:04:20,000 --> 00:04:24,000
それは何も見つからなかったことを示すため。

86
00:04:24,000 --> 00:04:26,000
>> このアルゴリズムのために働くことに気づいたかもしれません、

87
00:04:26,000 --> 00:04:28,000
番号のリストがソートされています。

88
00:04:28,000 --> 00:04:31,000
言い換えれば、我々は唯一の144はバイナリ検索を使って見つけることができます

89
00:04:31,000 --> 00:04:34,000
すべての数字は、最低から最高に順序付けられている場合。

90
00:04:34,000 --> 00:04:38,000
これが事実でなかったら、我々は、各ステップでの数字の半分を除外することができないだろう。

91
00:04:38,000 --> 00:04:40,000
だから我々は2つ​​のオプションがあります。

92
00:04:40,000 --> 00:04:43,000
どちらか我々は、バイナリ検索を使用する前にソートされていないリストを取得し、それを並べ替えることができます

93
00:04:43,000 --> 00:04:48,000
あるいは、我々は我々はそれに数字を追加すると番号のリストがソートされていることを確認することができます。

94
00:04:48,000 --> 00:04:50,000
そこで、代わりに私たちが検索する必要があり、ちょうどその時のソート、

95
00:04:50,000 --> 00:04:53,000
なぜすべての回でソートされたリストを保持しない？

96
00:04:53,000 --> 00:04:57,000
>> 同時に可能にしながら、ソート番号のリストを維持するための一つの方法

97
00:04:57,000 --> 00:04:59,000
このリストから数字を追加したり移動したりするための1

98
00:04:59,000 --> 00:05:02,000
二分探索木と呼ばれるものを使用することです。

99
00:05:02,000 --> 00:05:05,000
二分探索木では、3つのプロパティを持つデータ構造体です。

100
00:05:05,000 --> 00:05:09,000
まず、任意のノードの左のサブツリーには、より少ない値のみを含む

101
00:05:09,000 --> 00:05:11,000
またはノードの値に等しい。

102
00:05:11,000 --> 00:05:15,000
第二に、ノードの右の部分木のみよりも大きい値が含まれています

103
00:05:15,000 --> 00:05:17,000
またはノードの値に等しい。

104
00:05:17,000 --> 00:05:20,000
そして最後に、両方のすべてのノードの左と右のサブツリー

105
00:05:20,000 --> 00:05:23,000
また、二分探索木である。

106
00:05:23,000 --> 00:05:26,000
我々が以前使用したのと同じ数字で例を見てみましょう。

107
00:05:26,000 --> 00:05:30,000
コンピュータサイエンスの木の前に見たことがない人のために、

108
00:05:30,000 --> 00:05:34,000
私はコンピュータサイエンスの木が下向きに生えていることを伝えることから始めましょう。

109
00:05:34,000 --> 00:05:36,000
はい、あなたが慣れている木とは異なり、

110
00:05:36,000 --> 00:05:38,000
コンピュータサイエンスのツリーのルートは、一番上にある

111
00:05:38,000 --> 00:05:41,000
葉は下部にあります。

112
00:05:41,000 --> 00:05:45,000
それぞれの小さなボックスはノードと呼ばれ、ノードはエッジで互いに接続されている。

113
00:05:45,000 --> 00:05:48,000
だから、このツリーのルートは、13という値を持つノードの値です

114
00:05:48,000 --> 00:05:52,000
これは、値5と34と2子ノードを持っています。

115
00:05:52,000 --> 00:05:57,000
サブツリーは、ツリー全体の項を見ただけで形成されている木です。

116
00:05:57,000 --> 00:06:03,000
>> たとえば、ノード3の左側のサブツリーは、ノード0、1、2で作成されたツリーです。

117
00:06:03,000 --> 00:06:06,000
だから、我々は二分探索木の性質に戻ってしまったら、

118
00:06:06,000 --> 00:06:09,000
私たちは、ツリー内の各ノードは、すなわち、すべての3つの特性に適合していることがわかり

119
00:06:09,000 --> 00:06:15,000
左の部分木のみ以下のノードの値に等しい値が含まれます。

120
00:06:15,000 --> 00:06:16,000
すべてのノードの右側のサブツリー

121
00:06:16,000 --> 00:06:19,000
唯一のより大きいか、またはノードの値に等しい値が含まれ、そして

122
00:06:19,000 --> 00:06:25,000
すべてのノードの左と右のサブツリー双方はまた、二分探索木である。

123
00:06:25,000 --> 00:06:28,000
このツリーは異なって見えるが、これは有効な二分探索木である

124
00:06:28,000 --> 00:06:30,000
数字の同じセットのため。

125
00:06:30,000 --> 00:06:32,000
実際のところ、あなたが作成することができる多くの方法はいくつもあります

126
00:06:32,000 --> 00:06:35,000
これらの数値から有効な二分探索木。

127
00:06:35,000 --> 00:06:38,000
さて、のは、我々が作成した最初のものに戻りましょう。

128
00:06:38,000 --> 00:06:40,000
だから我々は、これらの木々に何ができるのでしょうか？

129
00:06:40,000 --> 00:06:44,000
まあ、我々は非常に単純に、最小値と最大値を見つけることができます。

130
00:06:44,000 --> 00:06:46,000
最小値は常に左に行くことによって見つけることができる

131
00:06:46,000 --> 00:06:48,000
訪問することはありません以上のノードが存在するようになるまで。

132
00:06:48,000 --> 00:06:53,000
逆に、最大のものを見つけるためには、単にちょうどたびに右にダウンした。

133
00:06:54,000 --> 00:06:56,000
>> 最小値または最大値はありません他の番号を見つける

134
00:06:56,000 --> 00:06:58,000
同様に簡単です。

135
00:06:58,000 --> 00:07:00,000
私たちは番号89を探していると言う。

136
00:07:00,000 --> 00:07:03,000
我々は、単に、各ノードの値を確認し、左または右に移動します

137
00:07:03,000 --> 00:07:06,000
ノードの値がより小さいか大きいかどうかに応じて、

138
00:07:06,000 --> 00:07:08,000
私たちが探している1。

139
00:07:08,000 --> 00:07:11,000
だから、13のルートから始まる、私たちは、89の方が大きいことがわかり

140
00:07:11,000 --> 00:07:13,000
それで我々は右に行く。

141
00:07:13,000 --> 00:07:16,000
その後、我々は34のノードを見て、再び我々は右に行く。

142
00:07:16,000 --> 00:07:20,000
89はまだ55を超えているので、我々は右に行く続ける。

143
00:07:20,000 --> 00:07:24,000
次に、144の値を持つノードを思い付くと左に移動します。

144
00:07:24,000 --> 00:07:26,000
驚くなかれ、89はすぐそこです。

145
00:07:26,000 --> 00:07:31,000
>> 我々が行うことができますもう一つは、間順走査を行うことで、すべての番号をプリントアウトしています。

146
00:07:31,000 --> 00:07:35,000
間順走査は、左のサブツリー内のすべてをプリントアウトすることを意味します

147
00:07:35,000 --> 00:07:37,000
ノード自体の印刷が続く

148
00:07:37,000 --> 00:07:40,000
をクリックし、右側のサブツリー内のすべてをプリントアウトが続く。

149
00:07:40,000 --> 00:07:43,000
例えば、使用している私たちのお気に入りの二分探索木を取らせ

150
00:07:43,000 --> 00:07:46,000
とソート順に番号をプリントアウト。

151
00:07:46,000 --> 00:07:49,000
我々は13のルートで開始しますが、13を出力する前に、我々は、プリントアウトする必要があります

152
00:07:49,000 --> 00:07:51,000
左のサブツリー内のすべての。

153
00:07:51,000 --> 00:07:55,000
だから我々は5に進みます。我々はまだ、私たちは一番左のノードが見つかるまでツリーに深くダウンに行かなければならない

154
00:07:55,000 --> 00:07:57,000
これはゼロです。

155
00:07:57,000 --> 00:08:00,000
印刷のゼロの後、我々は最大1に戻って、アウトを印刷してください。

156
00:08:00,000 --> 00:08:03,000
その後、我々は2である、右の部分木に移動し、そのアウトを印刷してください。

157
00:08:03,000 --> 00:08:05,000
今、私たちがそのサブツリーで行われていること、

158
00:08:05,000 --> 00:08:07,000
我々は、3に戻って上がると、それをプリントアウトすることができます。

159
00:08:07,000 --> 00:08:11,000
バックアップし続け、我々は5を印刷し、次に8。

160
00:08:11,000 --> 00:08:13,000
今、我々は全体の左側のサブツリーを完了していること、

161
00:08:13,000 --> 00:08:17,000
我々は13をプリントアウトし、右の部分木の上で作業を開始することができます。

162
00:08:17,000 --> 00:08:21,000
我々は34にダウンホップが、印刷前に34我々は、その左の部分木をプリントアウトする必要があります。

163
00:08:21,000 --> 00:08:27,000
だから我々は21をプリントアウトしてから、我々は34をプリントアウトし、その右の部分木を訪問することを得る。

164
00:08:27,000 --> 00:08:31,000
55に左のサブツリーを持っていないので、我々はそれをプリントアウトし、その右の部分木に進みます。

165
00:08:31,000 --> 00:08:36,000
144は左の部分木が付いているので、我々は、144に続いて、89をプリントアウト

166
00:08:36,000 --> 00:08:39,000
233そして最後に一番右のノード。

167
00:08:39,000 --> 00:08:44,000
そこにそれを持って、すべての数字は、最下位から最上位へ順番にプリントアウトされます。

168
00:08:44,000 --> 00:08:47,000
>> 木に何かを追加することなく、比較的簡単です。

169
00:08:47,000 --> 00:08:51,000
我々がしなければならないすべては、我々は3二分探索木の性質に従っていることを確認している

170
00:08:51,000 --> 00:08:53,000
スペースがある場合、その値を挿入します。

171
00:08:53,000 --> 00:08:55,000
Let 'sは、我々は7の値を挿入したいと言う。

172
00:08:55,000 --> 00:08:58,000
7が13未満であるため、我々は左に行く。

173
00:08:58,000 --> 00:09:01,000
しかし、それは5より大きいですので、我々は右へトラバース。

174
00:09:01,000 --> 00:09:04,000
それは8,8がリーフノードであるよりも少ないですので、我々は8の左の子に7を追加します。

175
00:09:04,000 --> 00:09:09,000
出来上がり！私たちは、二分探索木に番号を追加しました。

176
00:09:09,000 --> 00:09:12,000
>> 我々は物事を追加することができます場合、我々はより良​​いだけでなく、物事を削除することができる。

177
00:09:12,000 --> 00:09:14,000
残念なことに私たちのために、削除は、もう少し複雑です - 

178
00:09:14,000 --> 00:09:16,000
はるかが、ほんの少しだけではない。

179
00:09:16,000 --> 00:09:18,000
我々が考慮しなければならない3つのシナリオがあります

180
00:09:18,000 --> 00:09:21,000
二分探索木から要素を削除するとき。

181
00:09:21,000 --> 00:09:24,000
まず、最も簡単な場合は、要素が葉ノードであるということです。

182
00:09:24,000 --> 00:09:27,000
この場合において、我々は単にそれを削除すると、当社の事業に進んでください。

183
00:09:27,000 --> 00:09:30,000
我々は、追加した7を削除したいと言う。

184
00:09:30,000 --> 00:09:34,000
まあ、我々は単にそれを見つけ、それを取り外してから、それはそれだ。

185
00:09:35,000 --> 00:09:37,000
ノードが1つだけの子供を持っている場合は、次の場合です。

186
00:09:37,000 --> 00:09:40,000
ここでは、ノードを削除できますが、我々は最初のことを確認する必要があります

187
00:09:40,000 --> 00:09:42,000
現在、親の残っているサブツリーを接続する

188
00:09:42,000 --> 00:09:44,000
我々だけで削除されたノードの親に。

189
00:09:44,000 --> 00:09:47,000
私たちは木から3を削除してみたいと思います。

190
00:09:47,000 --> 00:09:50,000
私たちは、そのノードの子要素を取得し、ノードの親にそれを添付してください。

191
00:09:50,000 --> 00:09:54,000
このケースでは、我々は今、5から1を装着している。

192
00:09:54,000 --> 00:09:57,000
私たちが知っているので、これは、二分探索木の性質に応じて、問題なく動作

193
00:09:57,000 --> 00:10:01,000
3の左のサブツリー内のすべてのものは、5未満であった。

194
00:10:01,000 --> 00:10:05,000
今3のサブツリーが世話をされていることを、我々はそれを削除することができます。

195
00:10:05,000 --> 00:10:08,000
3番目と最後のケースは、最も複雑です。

196
00:10:08,000 --> 00:10:11,000
我々は、削除するノードが2人の子供を持っている場合、これはそうです。

197
00:10:11,000 --> 00:10:15,000
これを行うためには、まず、次の最大値を持つノードを見つけなければならない

198
00:10:15,000 --> 00:10:18,000
2を交換してから、問題のノードを削除します。

199
00:10:18,000 --> 00:10:22,000
次の最大値を持つノードが2人の子供自体を持つことはできません注意してください

200
00:10:22,000 --> 00:10:26,000
その左の子は、次の最大のための良い候補になるでしょうから。

201
00:10:26,000 --> 00:10:30,000
したがって、2人の子供を持つノードを削除すると、2つのノードのスワッピングにのぼる

202
00:10:30,000 --> 00:10:33,000
その後削除は2前述のルールの1によって処理されます。

203
00:10:33,000 --> 00:10:37,000
たとえば、みましょう我々はルートノード、13を削除したいと言う。

204
00:10:37,000 --> 00:10:39,000
まず最初にすることは私たちがツリー内で2番目に大きい値を見つけることです

205
00:10:39,000 --> 00:10:41,000
これは、この場合には、21です。

206
00:10:41,000 --> 00:10:46,000
次に、13葉と21の中央のグループノードを作って、2つのノードを入れ替える。

207
00:10:46,000 --> 00:10:49,000
今、私たちは単純に13を削除することができます。

208
00:10:50,000 --> 00:10:53,000
>> 以前に触れたように、有効な二分探索木を作る方法はいくつもあります。

209
00:10:53,000 --> 00:10:56,000
残念なことに私たちのために、いくつかは他よりも悪化している。

210
00:10:56,000 --> 00:10:59,000
我々は二分探索木を構築するとき、例えば、何が起こるでしょう

211
00:10:59,000 --> 00:11:01,000
数字のソートされたリストから？

212
00:11:01,000 --> 00:11:04,000
すべての数字は、ちょうど各ステップで右に追加されます。

213
00:11:04,000 --> 00:11:06,000
私たちは番号を検索したいときは、

214
00:11:06,000 --> 00:11:08,000
我々は選択の余地はないが、各ステップで右を見て。

215
00:11:08,000 --> 00:11:11,000
これがすべてでは線形探索よりも優れているわけではない。

216
00:11:11,000 --> 00:11:13,000
我々はここでそれらをカバーしていませんが、より複雑な、他があります

217
00:11:13,000 --> 00:11:16,000
このようなことが起こらないことを確認してデータ構造。

218
00:11:16,000 --> 00:11:18,000
しかし、これを避けるために行うことができます一つのシンプルなものです

219
00:11:18,000 --> 00:11:21,000
ただランダムにシャッフル入力値に。

220
00:11:21,000 --> 00:11:26,000
それは偶然で、数値のシャッフルリストがソートされている可能性は非常に低いです。

221
00:11:26,000 --> 00:11:29,000
この設定が行われた場合、カジノは長くのためのビジネスにとどまらないだろう。

222
00:11:29,000 --> 00:11:31,000
>> そこにそれがある。

223
00:11:31,000 --> 00:11:34,000
これでバイナリ検索とバイナリ検索ツリーを知っている。

224
00:11:34,000 --> 00:11:36,000
私はパトリック·シュミットだが、これはCS50です。

225
00:11:36,000 --> 00:11:38,000
[CS50.TV]

226
00:11:38,000 --> 00:11:43,000
自明な方法の1つからリストをスキャンすることであろう... [ビープ音]

227
00:11:43,000 --> 00:11:46,000
項目の数...うん...

228
00:11:46,000 --> 00:11:50,000
[笑]

229
00:11:50,000 --> 00:11:55,000
234の...ポストノード...キャーッ。

230
00:11:55,000 --> 00:11:58,000
>>イェーイ！それがあった -