1
00:00:00,000 --> 00:00:11,100

2
00:00:11,100 --> 00:00:12,300
>> SPEAKER 1：ちょっとみんな！

3
00:00:12,300 --> 00:00:13,890
セクションに戻っようこそ。

4
00:00:13,890 --> 00:00:17,480
ここにあなたの両方のように多くのを見てとても喜んで、
とオンライン見ている皆。

5
00:00:17,480 --> 00:00:18,760

6
00:00:18,760 --> 00:00:20,920
だから、いつものウェルカムバックとして。

7
00:00:20,920 --> 00:00:24,360
私はあなたのすべてが素敵なを持っていたことを願っています
残りの完全な週末、リラクゼーション。

8
00:00:24,360 --> 00:00:26,026
昨日は出美しかった。

9
00:00:26,026 --> 00:00:27,525
だから、私はあなたがアウトドアを楽しんで願っています。

10
00:00:27,525 --> 00:00:28,840

11
00:00:28,840 --> 00:00:30,610
>> したがって、最初の発表のカップル。

12
00:00:30,610 --> 00:00:31,920

13
00:00:31,920 --> 00:00:32,700
グレーディング。

14
00:00:32,700 --> 00:00:37,350
だから、あなたのほとんどは得ているはず
あなたのスクラッチのPset約私からのメール、

15
00:00:37,350 --> 00:00:39,920
同様のPset 1のためにグレーディング。

16
00:00:39,920 --> 00:00:41,000

17
00:00:41,000 --> 00:00:42,220
だから、ちょうどカップルの事。

18
00:00:42,220 --> 00:00:45,150
style50でcheck50を使用してください。

19
00:00:45,150 --> 00:00:47,250
これらは、であることを意味する
君たちのためのリソース、

20
00:00:47,250 --> 00:00:50,660
あなたが取得していることを確認します
あなたができる限り多くのポイント

21
00:00:50,660 --> 00:00:52,390
不必要にそれらを失うことなく。

22
00:00:52,390 --> 00:00:54,407
だから、スタイルのようなもの
非常に重要です。

23
00:00:54,407 --> 00:00:55,740
我々はそれのために離陸しようとしている。

24
00:00:55,740 --> 00:00:58,115
皆さんの中には、既に持っている可能性
あなたのPsetからその気づいた。

25
00:00:58,115 --> 00:00:58,920

26
00:00:58,920 --> 00:01:01,450
そしてcheck50はちょうどです
確実にする本当に簡単な方法

27
00:01:01,450 --> 00:01:05,050
私たちは実際に何を返していること
ユーザに返される必要がある、

28
00:01:05,050 --> 00:01:06,690
そしてそのすべてが正常に動作しています。

29
00:01:06,690 --> 00:01:08,690

30
00:01:08,690 --> 00:01:12,040
>> 第二了承の上、ご確認してください
正しいフォルダに物事をアップロードする。

31
00:01:12,040 --> 00:01:14,470
それは私の人生だけになり
もう少し難しい

32
00:01:14,470 --> 00:01:18,836
あなたがPsetに1に2のPsetをアップロードした場合
私は物事をダウンロードする際なぜなら、

33
00:01:18,836 --> 00:01:20,085
彼らが正しくダウンロードされません。

34
00:01:20,085 --> 00:01:21,690

35
00:01:21,690 --> 00:01:24,560
そして、私はそれが少しグラグラ知​​っている
システム内に慣れるため、

36
00:01:24,560 --> 00:01:26,950
ちょうどスーパーであること
慎重に、私だけのためであれば、

37
00:01:26,950 --> 00:01:30,080
ようにするには、メールを取得しているとき
2のように午前でと私はグレーディングよ。

38
00:01:30,080 --> 00:01:33,710
発生しない場合は私が見ている
あなたのPsetのためのすべての周り。

39
00:01:33,710 --> 00:01:34,440
涼しい。

40
00:01:34,440 --> 00:01:37,270
>> 私はそれが早いですけど、私
完全ガードを外さしまった

41
00:01:37,270 --> 00:01:40,800
今週の金曜日に起因のエッセイによって、その
私の教授はちょうどええオハイオ州、のようなものでした。

42
00:01:40,800 --> 00:01:42,550
覚えておいて、あなたが持っている
金曜日に起因するエッセイ。

43
00:01:42,550 --> 00:01:45,780
だから、私は誰も好きではない知っている
中間試験について考え、

44
00:01:45,780 --> 00:01:50,620
しかし、あなたの最初のクイズは、10月15日です
その10月は今週始めている。

45
00:01:50,620 --> 00:01:53,290
だから、それは早くかもしれない
あなたが予想よりも全てです。

46
00:01:53,290 --> 00:01:57,510
あなたは、ときにガードをオフにスローされていないように、
私は、ああ、その次の週のセクションに言及

47
00:01:57,510 --> 00:02:00,560
あなたのクイズ来週、私は思った
私はあなたにもう少し与えるだろう

48
00:02:00,560 --> 00:02:01,500
今までのヘッド。

49
00:02:01,500 --> 00:02:02,970

50
00:02:02,970 --> 00:02:04,660
>> だから、あなたの問題が設定され、3番。

51
00:02:04,660 --> 00:02:07,070
どのように人々が読んでいる
好奇心からスペック？

52
00:02:07,070 --> 00:02:08,560

53
00:02:08,560 --> 00:02:09,199
[OK]をクリックします。

54
00:02:09,199 --> 00:02:10,229
私たちはカップルを得た。

55
00:02:10,229 --> 00:02:12,320
種類のダウン最後から
週ませんが、問題ありません。

56
00:02:12,320 --> 00:02:13,650
私はそれは美しい出ていた知っている。

57
00:02:13,650 --> 00:02:15,120

58
00:02:15,120 --> 00:02:16,660
だから、ブレイクアウト。

59
00:02:16,660 --> 00:02:21,010
間違いなくあなたが成し遂げる後
本日は、少なくともあなたのスペックを読んで

60
00:02:21,010 --> 00:02:25,240
ダウンロードするように試みる
流通コードと実行

61
00:02:25,240 --> 00:02:27,430
最初のイニシャルのような
彼らはにあなたを尋ねるもの。

62
00:02:27,430 --> 00:02:28,681

63
00:02:28,681 --> 00:02:32,590
私たちが使用しているので、
流通コードとライブラリ

64
00:02:32,590 --> 00:02:36,790
我々は唯一の--Itだけだusing--てきたこと
我々はこののPsetをやった二回目、

65
00:02:36,790 --> 00:02:38,650
狂気の事が起こる可能性が
あなたのアプライアンスと、

66
00:02:38,650 --> 00:02:41,370
そしてあなたはそれを見つけたい
今対後で出。

67
00:02:41,370 --> 00:02:45,570
>> それは木曜日の夜だかどうかだから
水曜日の夜といくつかの理由で

68
00:02:45,570 --> 00:02:48,912
アプライアンスはちょうどない
ライブラリと実行したい

69
00:02:48,912 --> 00:02:50,620
または配布した
コー​​ドは、その手段

70
00:02:50,620 --> 00:02:52,309
あなたもコーディングをやって起動することはできません。

71
00:02:52,309 --> 00:02:54,100
あなたがチェックすることはできませんので、
それが動作するかどうかを確認します。

72
00:02:54,100 --> 00:02:55,975
ことができ、あなたのつもりはない
それはコンパイルするかどうかを確認します。

73
00:02:55,975 --> 00:03:00,500
あなたは、早期のものの世話をしたい
あなたはまだ私にメールすることができ、週、

74
00:03:00,500 --> 00:03:03,100
または他のTFの一つ
そして我々は、固定のものを得ることができます。

75
00:03:03,100 --> 00:03:05,410
それらは問題であるため、
それはあなたを停止しようとしている

76
00:03:05,410 --> 00:03:07,120
任意の実際の進捗状況を作るから。

77
00:03:07,120 --> 00:03:10,055
それがあることを、1バグようではありません
あなただけの種類のオーバースキップすることができます。

78
00:03:10,055 --> 00:03:10,712

79
00:03:10,712 --> 00:03:13,420
あなたの問題を抱えている場合
アプライアンスまたは配布コード、

80
00:03:13,420 --> 00:03:16,211
あなたは本当にそれが取ら取得したい
遅かれ早かれよりもむしろ後での世話。

81
00:03:16,211 --> 00:03:20,410
だから、実際につもりしていない場合でも、
コー​​ディングを開始、ディストリビューションをダウンロード

82
00:03:20,410 --> 00:03:24,040
コー​​ド、仕様を読んで、確認してください
すべてがそこに働いている。

83
00:03:24,040 --> 00:03:25,134
OK？

84
00:03:25,134 --> 00:03:27,675
あなたはちょうどそれを行うことができますなら、私
自分の人生が容易になります約束します。

85
00:03:27,675 --> 00:03:28,800

86
00:03:28,800 --> 00:03:31,410
だからあなたはおそらくつもり
今は右のそれを行うには？

87
00:03:31,410 --> 00:03:32,100
[OK]をクリックします。

88
00:03:32,100 --> 00:03:33,950
だから、そこにどんな質問？

89
00:03:33,950 --> 00:03:35,850
任意のロジスティック物事？

90
00:03:35,850 --> 00:03:36,910
誰もが良いことだ？

91
00:03:36,910 --> 00:03:38,270
[OK]をクリックします。

92
00:03:38,270 --> 00:03:41,700
>> のそれらのための免責条項
あなたの部屋で、オンライン。

93
00:03:41,700 --> 00:03:45,437
Iスイッチしようとしているつもりだ
アプライアンス内のPowerPointの間

94
00:03:45,437 --> 00:03:47,270
私たちがしようとしているので、
いくつかのコーディングをやっている

95
00:03:47,270 --> 00:03:53,630
匿名の好評につき本日
提案世論調査では、私が先週送った。

96
00:03:53,630 --> 00:03:55,480
だから、我々はいくつかのコーディングをすることになるだろう。

97
00:03:55,480 --> 00:03:57,800
だから、あなたたちもしたい場合
あなたのアプライアンスを起動するために、

98
00:03:57,800 --> 00:04:02,910
あなたが電子メールを持っている必要があります
サンプルファイルで、私から。

99
00:04:02,910 --> 00:04:04,310
それを行う気軽にご相談ください。

100
00:04:04,310 --> 00:04:07,340
>> だから、私たちはについて話をするつもりだ
デバッガですGDB、。

101
00:04:07,340 --> 00:04:09,970
それはあなたを助けるために起こっている
種類のどこに把握

102
00:04:09,970 --> 00:04:11,860
物事は、あなたのコード内で間違って行っている。

103
00:04:11,860 --> 00:04:15,370
それは本当にあなたがステップにするためだけの方法だ
それが起こっているようにあなたのコードを通して、

104
00:04:15,370 --> 00:04:19,100
と変数をプリントアウトすることができる
または実際に何が起こっているかを参照してください。

105
00:04:19,100 --> 00:04:22,980
あなたのプログラムの詩ボンネットの下に
ただ実行している、それは断層のようなものだ、

106
00:04:22,980 --> 00:04:25,030
あなたが、ないアイデアに似ている
何がちょうどここで起こった。

107
00:04:25,030 --> 00:04:26,730
私はそれが失敗した時に何行か分からない。

108
00:04:26,730 --> 00:04:29,040
それは間違っていたどこに私は知らない。

109
00:04:29,040 --> 00:04:31,280
だから、GDBはそのお手伝いをしようとしている。

110
00:04:31,280 --> 00:04:35,240
また、あなたがすることを決定した場合
はい継続し、61を取る、

111
00:04:35,240 --> 00:04:38,430
それは本当に、本当にあなたになります
親友、私はあなたを伝えることができる原因

112
00:04:38,430 --> 00:04:40,840
私は、そのクラスを通してつもりですので。

113
00:04:40,840 --> 00:04:43,620
>> 我々はバイナリを見てするつもりだ
あなたたちは覚えている場合は、検索、

114
00:04:43,620 --> 00:04:47,540
偉大な電話帳の例
クラスから光景。

115
00:04:47,540 --> 00:04:50,620
我々はそれを実装することでしょうし、
、もう少しその中を歩い

116
00:04:50,620 --> 00:04:54,650
その後、我々は4を通してつもりだ
バブルである異なる種類の、

117
00:04:54,650 --> 00:04:56,285
選択、挿入、およびマージ。

118
00:04:56,285 --> 00:04:57,830

119
00:04:57,830 --> 00:04:58,330
涼しい。

120
00:04:58,330 --> 00:05:00,390
だから、GDBは、私が述べたように、デバッガです。

121
00:05:00,390 --> 00:05:01,400

122
00:05:01,400 --> 00:05:09,370
そして、これらは大きなの一種である
物事、大きな関数やコマンド

123
00:05:09,370 --> 00:05:13,240
あなたは、GDB内で使用し、私は歩いていくこと
あなた秒でそれのデモを通して。

124
00:05:13,240 --> 00:05:15,360
>> だから、これはただではない
抽象滞在する予定。

125
00:05:15,360 --> 00:05:18,000
私が試してみて、コンクリートとしてそれを作ってあげる
君たちのために可能な限り。

126
00:05:18,000 --> 00:05:19,870
だから、破る。

127
00:05:19,870 --> 00:05:22,200
これは、いずれかのブレークになるでしょう
のような、いくつかの数は、どの

128
00:05:22,200 --> 00:05:26,900
プログラム内の行を表し、
または、関数に名前を付けることができます。

129
00:05:26,900 --> 00:05:30,150
それで、あなたはメイン破る言うなら、
それは、メインで停止します

130
00:05:30,150 --> 00:05:32,400
そしてあなたは、その関数の中を歩くましょう。

131
00:05:32,400 --> 00:05:36,350
>> 同様に、いくつかの外部を持っている場合
スワップやキューブのような関数、

132
00:05:36,350 --> 00:05:38,450
我々は先週見た。

133
00:05:38,450 --> 00:05:41,780
あなたがそれらのいずれかを破ると言うなら、
あなたのプログラムがヒットするたびに、その

134
00:05:41,780 --> 00:05:44,290
それはあなたのために待っています
何をするか、それを教えてください。

135
00:05:44,290 --> 00:05:47,860
それはちょうどので、あなたを実行する前
実際には関数の内部で進む可能性が

136
00:05:47,860 --> 00:05:49,020
そして何が起こっているかを参照してください。

137
00:05:49,020 --> 00:05:50,370

138
00:05:50,370 --> 00:05:53,515
だから、次は、ちょうどをスキップ
次の行は、関数より行く。

139
00:05:53,515 --> 00:05:54,730

140
00:05:54,730 --> 00:05:55,560
ステップ。

141
00:05:55,560 --> 00:05:56,810
これらはすべて少し抽象的である。

142
00:05:56,810 --> 00:06:00,530
だから、私はちょうどそれらを介して実行するつもりです、
しかし、あなたは第二での使用にそれらが表示されます。

143
00:06:00,530 --> 00:06:01,810
>> 関数にステップ。

144
00:06:01,810 --> 00:06:04,170
だから私が言っていたように、
スワップと同じように、それはでしょう

145
00:06:04,170 --> 00:06:07,110
あなたが実際にあなたがしているかのようにできるように
物理的に内部のステッピングのように、

146
00:06:07,110 --> 00:06:10,990
これらの変数を持つことができます混乱、印刷
彼らが何であるか、何が起こっているかを参照してください。

147
00:06:10,990 --> 00:06:12,140

148
00:06:12,140 --> 00:06:14,830
リストは、文字通り印刷されます
周辺のコード外。

149
00:06:14,830 --> 00:06:17,570
だから、あなたは親切なの忘れてしまった場合
あなたがあなたのプログラムのどこにいるか、

150
00:06:17,570 --> 00:06:19,880
またはあなたが迷っている
何がその周りで起こっている、

151
00:06:19,880 --> 00:06:23,790
これはただのセグメントをプリントアウトします
のその周りに五、六行が好きです。

152
00:06:23,790 --> 00:06:26,080
だから、あなたは慣れることができます
あなたがどこにいる約。

153
00:06:26,080 --> 00:06:27,230

154
00:06:27,230 --> 00:06:28,650
>> いくつかの変数を印刷します。

155
00:06:28,650 --> 00:06:34,590
だから、あなたのような鍵を持っている場合
シーザーは、我々は見てみましょうという。

156
00:06:34,590 --> 00:06:36,220
あなたは、任意の時点で印刷キーを言うことができる。

157
00:06:36,220 --> 00:06:40,070
値がそうであるもの、それはあなたを教えてあげましょう
その、多分どこかで道に沿って、

158
00:06:40,070 --> 00:06:42,070
あなたの鍵を上書きしました。

159
00:06:42,070 --> 00:06:45,495
あなたが実際にその理由を伝えることができます
あなたが実際にその値を観察することができます。

160
00:06:45,495 --> 00:06:46,500

161
00:06:46,500 --> 00:06:48,780
>> 地元の人々、ちょうど印刷中
あなたのローカル変数外。

162
00:06:48,780 --> 00:06:53,120
だから、いつでもあなたがループ内でなら、
そしてあなただけのああ、のような見てみたい。

163
00:06:53,120 --> 00:06:54,270
私の私とは何ですか？

164
00:06:54,270 --> 00:06:57,020
このキーの値とは何ですか
私はここで初期化することを？

165
00:06:57,020 --> 00:06:58,537
この時点でメッセージは何ですか？

166
00:06:58,537 --> 00:07:00,370
それはちょうど、すべての印刷されます
それらの、あなたはそのよう

167
00:07:00,370 --> 00:07:04,330
個別にする必要はありません
印刷I.印刷メッセージ、と言う。

168
00:07:04,330 --> 00:07:04,970
印刷キー。

169
00:07:04,970 --> 00:07:06,190

170
00:07:06,190 --> 00:07:07,700
その後表示します。

171
00:07:07,700 --> 00:07:10,370
何それが行うのは、あなたのようになる
プログラムをステップ実行、

172
00:07:10,370 --> 00:07:13,980
それはちょうどそれがだことを確認してくださいよ
いくつかの特定の変数を表示する

173
00:07:13,980 --> 00:07:14,780
すべての点で。

174
00:07:14,780 --> 00:07:17,160
あなたが--it年代をalso--ように
どこにショートカットの種類

175
00:07:17,160 --> 00:07:19,530
あなたがああ、のように続ける必要はありません。

176
00:07:19,530 --> 00:07:23,150
PRINTキーまたは印刷I.それだけ
自動的にあなたのためにそれを行います。

177
00:07:23,150 --> 00:07:25,959
>> だから、それを、我々はつもりだ
これはどのようになるかを確認します。

178
00:07:25,959 --> 00:07:28,000
私が試してみて、スイッチするつもりです
私のアプライアンスにオーバー。

179
00:07:28,000 --> 00:07:30,200

180
00:07:30,200 --> 00:07:31,271
私はこれを行うことができます参照してください。

181
00:07:31,271 --> 00:07:31,770
すべてのこと。

182
00:07:31,770 --> 00:07:40,970

183
00:07:40,970 --> 00:07:42,370
私達はちょうどそれをミラーリングするつもりだ。

184
00:07:42,370 --> 00:07:44,530
クレイジーは何もありません
とにかく私のラップトップ上で。

185
00:07:44,530 --> 00:07:49,600

186
00:07:49,600 --> 00:07:50,100
[OK]をクリックします。

187
00:07:50,100 --> 00:07:57,030

188
00:07:57,030 --> 00:08:01,054
これは、これである必要がある。

189
00:08:01,054 --> 00:08:01,795
それはとても小さなです。

190
00:08:01,795 --> 00:08:03,730

191
00:08:03,730 --> 00:08:05,120
我々はこれを行うことができるかどうか見てみましょう。

192
00:08:05,120 --> 00:08:09,970

193
00:08:09,970 --> 00:08:10,940
>> [OK]をクリックします。

194
00:08:10,940 --> 00:08:15,305
アリスは明らかに苦労している
ここで少しだけ、

195
00:08:15,305 --> 00:08:17,995
しかし、我々はモメントでそれを得るでしょう。

196
00:08:17,995 --> 00:08:20,810

197
00:08:20,810 --> 00:08:22,020
[OK]をクリックします。

198
00:08:22,020 --> 00:08:25,900
私達はちょうどこれを増やすつもりです。

199
00:08:25,900 --> 00:08:28,770

200
00:08:28,770 --> 00:08:29,380
[OK]をクリックします。

201
00:08:29,380 --> 00:08:31,679
誰もが親切なのそれを見ることができますか？

202
00:08:31,679 --> 00:08:32,470
たぶん少し？

203
00:08:32,470 --> 00:08:33,594
私はそれが少し小さいことを知っている。

204
00:08:33,594 --> 00:08:34,570

205
00:08:34,570 --> 00:08:37,530
あなたが非常に把握することはできません
これを大きくする方法。

206
00:08:37,530 --> 00:08:38,350
誰もが知っている場合。

207
00:08:38,350 --> 00:08:40,309
誰もがそれを大きくする方法を知っていますか？

208
00:08:40,309 --> 00:08:40,932
[OK]をクリックします。

209
00:08:40,932 --> 00:08:42,140
我々はそれをロールバックするつもりだ。

210
00:08:42,140 --> 00:08:45,801
それだけだからとにかく問題ではありません
それはその君たちがすべきコードです

211
00:08:45,801 --> 00:08:46,300
持っている。

212
00:08:46,300 --> 00:08:48,310
>> もっと重要なのは何
ここでは端末である。

213
00:08:48,310 --> 00:08:52,840

214
00:08:52,840 --> 00:08:58,690
そして、私たちはなぜそれが非常に小さいので、ここで持っている？

215
00:08:58,690 --> 00:09:02,325

216
00:09:02,325 --> 00:09:02,825
セッティング。

217
00:09:02,825 --> 00:09:07,920

218
00:09:07,920 --> 00:09:08,420
ああ。

219
00:09:08,420 --> 00:09:09,500
真のアイク。

220
00:09:09,500 --> 00:09:10,880
これはどうですか？

221
00:09:10,880 --> 00:09:11,770
そこから取り出します。

222
00:09:11,770 --> 00:09:19,370

223
00:09:19,370 --> 00:09:21,810
それは誰にとっても良いですか？

224
00:09:21,810 --> 00:09:22,525
[OK] ,.

225
00:09:22,525 --> 00:09:23,025
涼しい。

226
00:09:23,025 --> 00:09:25,830

227
00:09:25,830 --> 00:09:28,220
>> あなたがCSにいるときあなたが知っている
クラス技術的な問題

228
00:09:28,220 --> 00:09:32,971
the--の種類の一部である
それでは、これをクリアしてみましょう。

229
00:09:32,971 --> 00:09:33,470
[OK]をクリックします。

230
00:09:33,470 --> 00:09:38,060
だから、ちょうどここのセクションで、
その私たちがここに持っていた。

231
00:09:38,060 --> 00:09:40,830
シーザーは実行ファイルです。

232
00:09:40,830 --> 00:09:41,800
だから私はそれを作った。

233
00:09:41,800 --> 00:09:46,370
だから、GDBと実現するための一つのことである
それが唯一の実行可能ファイルに動作する。

234
00:09:46,370 --> 00:09:48,040
だから、あなたはdotsy上でそれを実行することはできません。

235
00:09:48,040 --> 00:09:50,532
あなたが実際に行う必要があります
あなたのコードがコンパイルされていることを確認し、

236
00:09:50,532 --> 00:09:51,865
それは実際に実行することができる。

237
00:09:51,865 --> 00:09:52,970

238
00:09:52,970 --> 00:09:56,186
>> だから、必ず、そうでない場合ことを確認してください
コンパイル、それはコンパイルに取得、

239
00:09:56,186 --> 00:09:57,810
ように、あなたは一種のそれを介して実行することができます。

240
00:09:57,810 --> 00:10:04,590
だから、GDBを起動するために、すべてのあなたが、
グロリアは、GDBを入力し、[ちょうど

241
00:10:04,590 --> 00:10:06,250
あなたが望むファイル。

242
00:10:06,250 --> 00:10:08,240
私はいつもシーザーのスペルを。

243
00:10:08,240 --> 00:10:11,730
しかし、あなたは確認する
それは実行可能なので、

244
00:10:11,730 --> 00:10:14,210
TIのドットフラッシュするように
あなたが行っていることを意味

245
00:10:14,210 --> 00:10:19,240
あなたが実行しようとしているCSI実行する
これは、どちらかのデバッガを使用してファイル。

246
00:10:19,240 --> 00:10:19,910
[OK]をクリックします。

247
00:10:19,910 --> 00:10:22,885
だから、あなたはあなたが得る、それを行う
ちんぷんかんぷんのこの種。

248
00:10:22,885 --> 00:10:24,250

249
00:10:24,250 --> 00:10:25,750
これは、デバッガ約ちょうどすべてのものです。

250
00:10:25,750 --> 00:10:28,200
あなたは本当にする必要はありません
今はそれを心配。

251
00:10:28,200 --> 00:10:31,460
ご覧のように、我々はこれを持っている
オープン括弧、GDP、近い括弧、

252
00:10:31,460 --> 00:10:34,690
とだけの種類のように見える
私たちのコマンドラインは、右？

253
00:10:34,690 --> 00:10:37,010
>> だから、私たちはdo--するかをしたい
 -  SO、まず最初に

254
00:10:37,010 --> 00:10:39,570
私たちが選択したいです
場所は、それを破壊する。

255
00:10:39,570 --> 00:10:42,332
だから、1バグがあります
このシーザープログラムにおける

256
00:10:42,332 --> 00:10:44,290
私は、それを紹介していること
我々は見つけるつもりです。

257
00:10:44,290 --> 00:10:45,330

258
00:10:45,330 --> 00:10:56,350
それは入力を取り込みで、それが何をするか
すべて大文字でBarfoo、およびいくつかの理由で

259
00:10:56,350 --> 00:11:01,950
それはA.それだけ葉を変更しません
それだけで、他のすべて正しいです、

260
00:11:01,950 --> 00:11:03,980
しかし第二の手紙
Aは変わらない。

261
00:11:03,980 --> 00:11:07,120
だから、私たちがしようとするつもりだ
つまり理由を把握。

262
00:11:07,120 --> 00:11:10,440
だから、最初にあなた通常、
あなたは、GDBで起動するたびにやってみたい

263
00:11:10,440 --> 00:11:12,010
それを破るためにどこに把握である。

264
00:11:12,010 --> 00:11:14,956
>> だから、シーザーはかなり短いプログラムです。

265
00:11:14,956 --> 00:11:16,330
私達はちょうど、一つの機能を持っている？

266
00:11:16,330 --> 00:11:18,520
シーザーにおける当社の機能は何でしたか？

267
00:11:18,520 --> 00:11:19,590

268
00:11:19,590 --> 00:11:24,350
一つだけの関数、主な権利はあります？

269
00:11:24,350 --> 00:11:26,490
主な機能である
すべてのプログラムのために。

270
00:11:26,490 --> 00:11:29,230
あなたがメインを持っていなかった場合、私はかもしれない
、今は少し心配である

271
00:11:29,230 --> 00:11:31,000
しかし、私はあなたのすべてがそこにメインを持っていた願っています。

272
00:11:31,000 --> 00:11:34,150
だから、何私たちにできることは、我々はできている
ちょうどそのように、メインを破る。

273
00:11:34,150 --> 00:11:35,190
だから、それは[OK]を、述べています。

274
00:11:35,190 --> 00:11:37,430
私たちは、そこに私たちのブレークポイント1を設定してください。

275
00:11:37,430 --> 00:11:42,870
>> だから、今覚えておくべき事はシーザーである
1コマンドライン引数権を取る

276
00:11:42,870 --> 00:11:45,150
そして我々はどこにもまだあることを行っていない。

277
00:11:45,150 --> 00:11:47,560
だから、あなたは何をすべきかは、時です
あなたが実際に実行するために行く

278
00:11:47,560 --> 00:11:51,540
プログラム、あなたがしている任意のプログラム
GDBで実行されていることは、コマンドラインを必要とします

279
00:11:51,540 --> 00:11:55,010
引数は、あなたが入力するつもりだ
あなたが最初にそれを実行して起動したとき。

280
00:11:55,010 --> 00:11:59,280
そこで、この場合には、何
3のキーで実行します。

281
00:11:59,280 --> 00:12:00,770

282
00:12:00,770 --> 00:12:02,040
そして、それは実際に開始されます。

283
00:12:02,040 --> 00:12:08,480
>> ここで見るのであれば、我々は持っている
RCは2に等しくない場合。

284
00:12:08,480 --> 00:12:12,210
だから、君たちがすべて持っている場合
私が送り出され、そのファイル

285
00:12:12,210 --> 00:12:15,100
あなたはそのようなものだが、ことがわかります
最初の行私たちの主な機能は、右？

286
00:12:15,100 --> 00:12:17,890
それは我々が持っているかどうかをチェックだ
正しい数の引数。

287
00:12:17,890 --> 00:12:20,620
だから、あなたは迷っている場合は、
RCが正しい場合、

288
00:12:20,620 --> 00:12:23,250
あなただけの印刷RCのような何かを行うことができます。

289
00:12:23,250 --> 00:12:24,380

290
00:12:24,380 --> 00:12:28,640
RCはある、2です
私たちが予想、右？

291
00:12:28,640 --> 00:12:32,010
>> そこで、次に行くことができ、
そしてを通して継続。

292
00:12:32,010 --> 00:12:33,200
だから、私たちはそこにいくつかのキーを持っています。

293
00:12:33,200 --> 00:12:34,260

294
00:12:34,260 --> 00:12:37,090
そして、我々は我々のキーをプリントアウトすることができます
それは正しいです確認します。

295
00:12:37,090 --> 00:12:38,380

296
00:12:38,380 --> 00:12:39,500
興味深い。

297
00:12:39,500 --> 00:12:41,210
私たちが期待したものはかなりありません。

298
00:12:41,210 --> 00:12:44,810
だから、一つのことは実現する
GDBでも、です

299
00:12:44,810 --> 00:12:49,000
あなたが実際にヒットするまで、そうではありませんことを
次に、そのあなたがちょうど見たライン

300
00:12:49,000 --> 00:12:50,720
実際に実行される。

301
00:12:50,720 --> 00:12:53,870
だから、この場合のキーで
まだ割り当てられていない。

302
00:12:53,870 --> 00:12:57,050
したがって、キーは、一部のごみ値である
あなたはそこに底に見ている。

303
00:12:57,050 --> 00:13:03,680
負の$ 120-- --Itの10億
何か変なことですよね？

304
00:13:03,680 --> 00:13:05,340
それは我々が期待キーではありません。

305
00:13:05,340 --> 00:13:10,720
しかし、我々は[次へ]をヒットし、あれば、私たち
それは3だ、試してみて、Printキー。

306
00:13:10,720 --> 00:13:11,710
>> 誰もがそれを参照してください？

307
00:13:11,710 --> 00:13:13,780
だから、あなたが何かを得れば
あなたが似ていることを、お待ちしております。

308
00:13:13,780 --> 00:13:15,540
これは完全にある
間違った、と私にはわからない

309
00:13:15,540 --> 00:13:20,150
すべて私がしたいので、これは起こるだろうか
番号を割り当てているためには、変数、

310
00:13:20,150 --> 00:13:22,900
[次へ]を打つ試して、印刷を試してみてください
もう一度、それが動作するか観察してください。

311
00:13:22,900 --> 00:13:27,830
それだけで実行するために起こっているためと
実際にあなたの後に何かを割り当てる

312
00:13:27,830 --> 00:13:29,340
[次へ]を押してください。

313
00:13:29,340 --> 00:13:30,336
みんなに意味をなさない？

314
00:13:30,336 --> 00:13:30,836
uhハァッ？

315
00:13:30,836 --> 00:13:33,220
>> SPEAKER 2：あなたがランダム
数字それが何を意味するのでしょうか？

316
00:13:33,220 --> 00:13:34,790
>> SPEAKER 1：それはちょうどランダムです。

317
00:13:34,790 --> 00:13:35,710
それはちょうどごみだ。

318
00:13:35,710 --> 00:13:38,320
それはちょうど、そのあなたの何か
コンピューターがランダムに割り当てられます。

319
00:13:38,320 --> 00:13:39,721

320
00:13:39,721 --> 00:13:40,220
涼しい。

321
00:13:40,220 --> 00:13:45,760
だから、今私たちはを通して移動し、そうすることができます
今、私たちはこのプレーンテキストのGetStringを持っている。

322
00:13:45,760 --> 00:13:48,600
だから、私はちょうど何を紹介しましょう
私たちがここで[次へ]を打ったときに起こります。

323
00:13:48,600 --> 00:13:51,320
私たちのGDBは一種の右側、消え？

324
00:13:51,320 --> 00:13:55,720
それが原因のGetStringだ
今実行している、右？

325
00:13:55,720 --> 00:14:01,460
我々が見たときに、プレーンテキストに等しい
のGetString、オープン括弧と括弧、

326
00:14:01,460 --> 00:14:04,380
そして我々は持って[次へ]を、ヒット
実際に今、実行。

327
00:14:04,380 --> 00:14:06,580
だから、それは待っている
入力何かに私たち。

328
00:14:06,580 --> 00:14:13,560
>> だから、私たちは私たちの食べ物どの入力するつもりだ
私はあなたに言ったように、それが失敗しているものである

329
00:14:13,560 --> 00:14:18,020
それはちょうどそれがだと言っている
閉じたことを、実行が終了

330
00:14:18,020 --> 00:14:19,980
ブラケットは、それがであることを意味
そのループの外に出た。

331
00:14:19,980 --> 00:14:21,170

332
00:14:21,170 --> 00:14:25,420
そこで、[次へ]を打つことができる、そして今、私はとして
必ず、すべてのシーザーから精通している、

333
00:14:25,420 --> 00:14:27,260
これは、この行が何を何が起こっているのか、である。

334
00:14:27,260 --> 00:14:32,030
それはint型私は0に等しいためだ、Nに等しく
STRLEN、プレーンテキスト、その後

335
00:14:32,030 --> 00:14:33,960
I nは、I、プラス、プラス未満である。

336
00:14:33,960 --> 00:14:35,210
どうするつもりこのループは何ですか？

337
00:14:35,210 --> 00:14:37,900

338
00:14:37,900 --> 00:14:39,160
あなたのメッセージを開きます。

339
00:14:39,160 --> 00:14:39,770
涼しい。

340
00:14:39,770 --> 00:14:41,330
それでは、それをやって始めましょう。

341
00:14:41,330 --> 00:14:47,210
>> したがって、この状態ははず
私たちの最初の1のために、一致する？

342
00:14:47,210 --> 00:14:52,250
それがBの場合は、プレーンテキストⅠ。私たちだ
私たちの地元の人々についての情報を得ることができます。

343
00:14:52,250 --> 00:14:53,610

344
00:14:53,610 --> 00:14:57,970
だから、私は、そのゼロであり、6の場合
私たちは期待し、私たちのキーが3個である。

345
00:14:57,970 --> 00:14:59,227
意味をなすこと、すべて、右？

346
00:14:59,227 --> 00:15:01,310
これらの数字が全てです
正確に彼らがどうあるべきか。

347
00:15:01,310 --> 00:15:02,590

348
00:15:02,590 --> 00:15:03,870
だから、ハム？

349
00:15:03,870 --> 00:15:05,620
スピーカ3：私が持っている
鉱山のための乱数。

350
00:15:05,620 --> 00:15:09,156

351
00:15:09,156 --> 00:15:12,030
SPEAKER 1：まあ、我々は--weをcheck--できる
第二でそれについてチャットすることができます。

352
00:15:12,030 --> 00:15:14,110

353
00:15:14,110 --> 00:15:15,750
しかし、あなたはこれを取得する必要があります。

354
00:15:15,750 --> 00:15:17,700

355
00:15:17,700 --> 00:15:20,130
だから、我々は資本を持っている場合
私たちの最初の1のためのB、

356
00:15:20,130 --> 00:15:22,080
この条件では右、それをキャッチする必要があり？

357
00:15:22,080 --> 00:15:27,120
私たちは次を打つのであれば、我々はを参照してください。
この場合には、実際に実行されるように。

358
00:15:27,120 --> 00:15:29,220
あなたがフォローしている場合には理由
あなたのコード内に沿って、

359
00:15:29,220 --> 00:15:33,460
このここで行、プレーンテキスト私は
この算術に置き換えられ、

360
00:15:33,460 --> 00:15:35,720
場合にのみ実行された場合
条件が正しい権利である？

361
00:15:35,720 --> 00:15:36,905

362
00:15:36,905 --> 00:15:40,240
>> GDBはだけお見せしようとしている
実際に実行しているもの。

363
00:15:40,240 --> 00:15:45,140
このIf条件が満たされていなかったのであれば、それはだ
ちょうど次の行にスキップするつもり。

364
00:15:45,140 --> 00:15:46,540
OK？

365
00:15:46,540 --> 00:15:48,510
だから、私たちはそれを持っている。

366
00:15:48,510 --> 00:15:51,171
このブラケットは、それがであることを意味
今そのループの外に閉鎖した。

367
00:15:51,171 --> 00:15:52,420
だから、それは再び開始する予定だ。

368
00:15:52,420 --> 00:15:54,760

369
00:15:54,760 --> 00:15:56,280
ちょうどそのように。

370
00:15:56,280 --> 00:15:59,120
だから、私たちは情報を得ることができること
ここに私たちの地元の人々約、

371
00:15:59,120 --> 00:16:02,575
そして我々は我々の最初のことがわかります
手紙は、右変わりましたか？

372
00:16:02,575 --> 00:16:05,150
それがあるべきように、それは、今、Eです。

373
00:16:05,150 --> 00:16:07,360
だから、私たちは上継続することができます。

374
00:16:07,360 --> 00:16:08,500
>> そして、我々は、このチェックを持っている。

375
00:16:08,500 --> 00:16:09,916
そして、このチェックは、右動作するはず？

376
00:16:09,916 --> 00:16:12,570
それが変更されるべきだA.
フォワードの三文字。

377
00:16:12,570 --> 00:16:14,320

378
00:16:14,320 --> 00:16:16,530
しかし、あなたは、私たちに気づいた場合
別の何かを得る。

379
00:16:16,530 --> 00:16:17,580

380
00:16:17,580 --> 00:16:22,860
だからここに、この場合、最大では、それがキャッチ
それので、この行が実行され、

381
00:16:22,860 --> 00:16:28,620
私たちのBを変更している
しかし、ここで、この場合、

382
00:16:28,620 --> 00:16:32,860
我々はそれがちょうどそれをスキップすることを持っている、
そして[に行きました？ L個のSIFF。 ？]

383
00:16:32,860 --> 00:16:34,660
だから、何かが起こっている。

384
00:16:34,660 --> 00:16:37,780
それは何それはあなたを語っていますです、
我々は、それがここにキャッチする必要があることを知っている

385
00:16:37,780 --> 00:16:39,200
しかしそうではありません。

386
00:16:39,200 --> 00:16:42,210
誰もが何を参照することができます私たちの
問題は、その行にある？

387
00:16:42,210 --> 00:16:45,380

388
00:16:45,380 --> 00:16:46,969
それは非常に微細なことだ。

389
00:16:46,969 --> 00:16:48,510
そして、あなたはまた、あなたのコードを見て可能性があります。

390
00:16:48,510 --> 00:16:49,980

391
00:16:49,980 --> 00:16:54,940
また、それが何であるかのラインを忘れline--だ
there--にそれは[聞こえない]にあります。

392
00:16:54,940 --> 00:16:55,480
はい？

393
00:16:55,480 --> 00:16:58,639
>> スピーカ4：それはより大きい上にある
あなたは本の中でそれを読めばページ。

394
00:16:58,639 --> 00:16:59,430
SPEAKER 1：その通り。

395
00:16:59,430 --> 00:17:02,620
だから、デバッガは言うことができませんでした
あなたでなく、デバッガ

396
00:17:02,620 --> 00:17:05,880
ラインにあなたを得ることができる
あなたが機能していないことを知っている。

397
00:17:05,880 --> 00:17:09,319
そして、時には、場合に特に
後で学期、中

398
00:17:09,319 --> 00:17:12,910
あなたが百、Aを扱っている
数百行のコード、そしてあなた

399
00:17:12,910 --> 00:17:16,190
それは失敗だか分からない、
これはそれを行うための素晴らしい方法です。

400
00:17:16,190 --> 00:17:17,900

401
00:17:17,900 --> 00:17:18,989
だから、私たちは私たちのバグを発見した。

402
00:17:18,989 --> 00:17:21,530
あなたは、あなたのファイルにそれを修正することができ、
その後、あなたは再びそれを実行することができ、

403
00:17:21,530 --> 00:17:23,029
すべてが完璧に動作します。

404
00:17:23,029 --> 00:17:24,970

405
00:17:24,970 --> 00:17:30,590
そして最大のものです
これはOK、のように見えるかもしれません。

406
00:17:30,590 --> 00:17:31,090
うん。

407
00:17:31,090 --> 00:17:31,370
涼しい。

408
00:17:31,370 --> 00:17:32,744
あなたが探しているものを知っていた。

409
00:17:32,744 --> 00:17:34,910
だから、あなたは何をすべきかを知っていた。

410
00:17:34,910 --> 00:17:39,021
>> GDBはあなたのためのスーパー役に立ちます
あなたこれらすべてのものをプリントアウトすることができます

411
00:17:39,021 --> 00:17:39,520
ないだろう。

412
00:17:39,520 --> 00:17:41,160
それは、はるかに便利なのprintfよりもだ。

413
00:17:41,160 --> 00:17:43,440
どのように多くのあなたの使用
のprintf文のような

414
00:17:43,440 --> 00:17:46,200
バグが、右のあった場所を把握するには？

415
00:17:46,200 --> 00:17:48,450
だから、これで、あなたはしないでください
戻って保持する必要があり、

416
00:17:48,450 --> 00:17:51,139
とにコメントしたい
PRINTF、またはコメントアウト、

417
00:17:51,139 --> 00:17:52,930
何を把握
あなたが印刷されるべきである。

418
00:17:52,930 --> 00:17:55,670
これは実際にあなたがすることができます
ステップスルー、物事をプリントアウト

419
00:17:55,670 --> 00:18:00,000
あなたを介して行っているようなので、次のことができます
彼らはリアルタイムでどのように変化するかを観察し、

420
00:18:00,000 --> 00:18:02,190
あなたのプログラムとして実行されている。

421
00:18:02,190 --> 00:18:04,390
>> そして、それは少し時間がかかりますか
に慣れるのビット。

422
00:18:04,390 --> 00:18:07,850
私は非常に親切なだけで推薦する
それを少し不満であることの

423
00:18:07,850 --> 00:18:08,930
今のため。

424
00:18:08,930 --> 00:18:13,450
あなたは時間以上を費やしている場合
来週GDBを使用する方法を学んで、

425
00:18:13,450 --> 00:18:16,140
あなた自身を救う
後でそんなに時間。

426
00:18:16,140 --> 00:18:18,750
文字通り。我々は言う
この人々に、毎年、

427
00:18:18,750 --> 00:18:23,890
私が取ったとき、私は覚えている
クラス、私は罰金になります、のようだった。

428
00:18:23,890 --> 00:18:24,700
いいえ。

429
00:18:24,700 --> 00:18:27,030
PSET 6は、上来て、私がいた
のような、私は学ぶつもりだ

430
00:18:27,030 --> 00:18:29,500
私はしませんので、GDBを使用する方法
ここで何が起こっているか知っている。

431
00:18:29,500 --> 00:18:32,940
>> ですから、そのように時間がかかる場合は、
小さいプログラムでそれを使用

432
00:18:32,940 --> 00:18:35,697
あなたがするつもりだこと
作業のように、上の作業

433
00:18:35,697 --> 00:18:37,530
のようなものを通して
このようなVisionare、。

434
00:18:37,530 --> 00:18:38,800

435
00:18:38,800 --> 00:18:42,850
あなたが余分な練習をしたい場合、または、私は確信している
私は、バグのあるプログラムを思い付くことができ、

436
00:18:42,850 --> 00:18:45,300
あなたが好きな場合は、デバッグするために。

437
00:18:45,300 --> 00:18:49,300
>> しかし、あなただけの取得に時間がかかる場合は、
それに慣れ、ちょうどそれで遊んで、

438
00:18:49,300 --> 00:18:50,550
それは本当によくあなたを提供します。

439
00:18:50,550 --> 00:18:52,591
そして、それは本当にの一つだ
あなたそれらの事ばかり

440
00:18:52,591 --> 00:18:57,340
試してみて、そしてあなたの手を汚す
あなたが本当にそれを理解する前に、と。

441
00:18:57,340 --> 00:19:02,090
私は本当に一度だけ、それを理解
私はそれで物事をデバッグしなければならなかった、

442
00:19:02,090 --> 00:19:08,170
そしてそれはのアイデアを持っているために非常に良くだ
どのようにすぐにではなく、後にデバッグします。

443
00:19:08,170 --> 00:19:08,850
[OK]をクリックします。

444
00:19:08,850 --> 00:19:09,625
涼しい。

445
00:19:09,625 --> 00:19:12,960
私はそれが一種のようなものだ知っている
GDBのクラッシュコース、

446
00:19:12,960 --> 00:19:16,400
と私は間違いなく得る上で動作します
これらは次回に大きく見えるように。

447
00:19:16,400 --> 00:19:17,590

448
00:19:17,590 --> 00:19:18,280
涼しい。

449
00:19:18,280 --> 00:19:20,390
>> だから、我々は戻って私たちのPowerPointに行けば。

450
00:19:20,390 --> 00:19:27,194

451
00:19:27,194 --> 00:19:28,110
これが仕事に行くされていますか？

452
00:19:28,110 --> 00:19:29,711

453
00:19:29,711 --> 00:19:30,210
AWH。

454
00:19:30,210 --> 00:19:31,101
はい。

455
00:19:31,101 --> 00:19:31,600
[OK]をクリックします。

456
00:19:31,600 --> 00:19:35,480
だから、あなたは今までのいずれかを必要とする場合は、
それらを再度、リストがあります。

457
00:19:35,480 --> 00:19:37,160

458
00:19:37,160 --> 00:19:40,830
だから、バイナリ検索、そのすべての人
ダビデの偉大な光景を記憶しています

459
00:19:40,830 --> 00:19:42,259
半分に電話帳をリッピング。

460
00:19:42,259 --> 00:19:44,050
私は本当に得ることはありません
もはや電話帳、

461
00:19:44,050 --> 00:19:46,530
あなたを行う場所が好きなので
これらの日電話帳を取得？

462
00:19:46,530 --> 00:19:48,220
私は本当にわからない。

463
00:19:48,220 --> 00:19:49,840

464
00:19:49,840 --> 00:19:50,590
バイナリ検索。

465
00:19:50,590 --> 00:19:52,464
誰もが覚えているん
どのようにバイナリサーチの作品？

466
00:19:52,464 --> 00:19:54,380

467
00:19:54,380 --> 00:19:55,220
まったく誰ですか？

468
00:19:55,220 --> 00:19:56,325
うん？

469
00:19:56,325 --> 00:19:58,283
スピーカ5：あなたが知っているとき
あなたが半分を見て

470
00:19:58,283 --> 00:20:01,146
それはこれに基づき、中だろう、
そして残りの半分を取り除く。

471
00:20:01,146 --> 00:20:01,896
>> SPEAKER 1その通り。

472
00:20:01,896 --> 00:20:06,290
だから、バイナリ検索は、それがのA--ようなものだ
分割統治、それを呼びたい--we。

473
00:20:06,290 --> 00:20:09,170
だから、あなたがやるものです
あなたは、途中で見てみましょう

474
00:20:09,170 --> 00:20:11,990
それが一致した場合、あなたが表示されます
あなたが探しているもの。

475
00:20:11,990 --> 00:20:15,420
そうでない場合、あなたはしよう
把握するには、左されようとしている

476
00:20:15,420 --> 00:20:16,450
半分または右半分。

477
00:20:16,450 --> 00:20:19,325
あなたが探しているのであれば、これは可能性があります
アルファベット順だ何かで、

478
00:20:19,325 --> 00:20:20,720
あなたがああ、参照してください。

479
00:20:20,720 --> 00:20:22,750
アリソンは、Mの前に来ていますか？

480
00:20:22,750 --> 00:20:23,250
はい。

481
00:20:23,250 --> 00:20:25,030
そこで、我々はするつもりだ
前半を見てください。

482
00:20:25,030 --> 00:20:26,450
>> それとも、番号を持つようになる可能性があります。

483
00:20:26,450 --> 00:20:28,830
そのあなたが何かできること
比較するには、ソートすることができる。

484
00:20:28,830 --> 00:20:29,920

485
00:20:29,920 --> 00:20:31,260
あなたは上のバイナリ検索を使用することができます。

486
00:20:31,260 --> 00:20:32,340

487
00:20:32,340 --> 00:20:37,455
だから、誰もがこれを覚えている
グラフまたはこれが何であるか？

488
00:20:37,455 --> 00:20:39,520
それは漸近複雑だ。

489
00:20:39,520 --> 00:20:42,830
だから、このグラフだけ
どのくらいの時間を説明

490
00:20:42,830 --> 00:20:46,230
ような問題を解決するために移動します
あなたは物事の数を増やす

491
00:20:46,230 --> 00:20:47,090
あなたが使っているという。

492
00:20:47,090 --> 00:20:51,260
>> そこで、線形時間であるNを持っています。

493
00:20:51,260 --> 00:20:54,560
わずかに2以上のN、もし
より良い、まだ超高速成長する。

494
00:20:54,560 --> 00:20:58,360
そして、我々はある、ログインしている
私たちは、バイナリ検索を検討してください。

495
00:20:58,360 --> 00:21:03,630
我々は気付いた場合、あなたの問題など
、はるかにはるかに大きくなる

496
00:21:03,630 --> 00:21:06,600
それを解決するためにかかる時間
本当にそれほど増加しない。

497
00:21:06,600 --> 00:21:09,010
それは同等のようなものだ
ここで初めに。

498
00:21:09,010 --> 00:21:10,060
[OK]をクリックすると、似ている。

499
00:21:10,060 --> 00:21:13,000
ここで何が本当にしません
我々が使用する1問題、

500
00:21:13,000 --> 00:21:16,220
しかし、あなたは、万人に億を出す。

501
00:21:16,220 --> 00:21:20,010
あなたはsome-- --you'reを見つけようとしている
干し草の山の中から針を見つけようとする。

502
00:21:20,010 --> 00:21:21,550
>> 私はあなたがこの問題をしたいと思います。

503
00:21:21,550 --> 00:21:25,850
あなたは、この複雑さをしないしたい
あなたのためにすべてのために線形

504
00:21:25,850 --> 00:21:30,049
あなたのつもりを検索することがわかっている
各個別の針、干し草のもの、

505
00:21:30,049 --> 00:21:31,340
あなたの針を探すようにしよう。

506
00:21:31,340 --> 00:21:34,730
そして、それは私の意見ではあまりにも楽しいではありません。

507
00:21:34,730 --> 00:21:35,500
私が速いのが好きです。

508
00:21:35,500 --> 00:21:36,620
私は効率的なのが好きです。

509
00:21:36,620 --> 00:21:40,450
そして勤勉な学生として、あなた
みんな、あなたがよりスマートに働く知っている、ある

510
00:21:40,450 --> 00:21:43,010
タイプの事難しくありません、どのように
これらのアルゴリズムを構成することができます。

511
00:21:43,010 --> 00:21:45,110

512
00:21:45,110 --> 00:21:47,910
>> だから、私たちは歩くつもりです
ちょうど簡単な例を通して。

513
00:21:47,910 --> 00:21:51,090
私はあなたたちが持っているべきだと思う
バイナリ検索上の手、

514
00:21:51,090 --> 00:21:54,352
しかし場合に誰もが少しある
ファジー、それを強化したい、

515
00:21:54,352 --> 00:21:56,310
私達はちょうど行くつもりです
ここでの例を通して。

516
00:21:56,310 --> 00:21:59,490
そこで、もし探している
配列には7が含まれています。

517
00:21:59,490 --> 00:22:00,540

518
00:22:00,540 --> 00:22:06,010
>> ですから、私たちが最初にすることはある
右、真ん中に見える？

519
00:22:06,010 --> 00:22:09,340
また、あなたがコーディングことになるだろう
ちょうど第二のバイナリ検索。

520
00:22:09,340 --> 00:22:11,310
だから、それは楽しいことになるだろう。

521
00:22:11,310 --> 00:22:13,710
だから我々はに見える
真ん中の少しの配列3。

522
00:22:13,710 --> 00:22:15,501
図3は、7に等しくしていますか？

523
00:22:15,501 --> 00:22:16,000
しません。

524
00:22:16,000 --> 00:22:18,670

525
00:22:18,670 --> 00:22:19,550
それは6です。

526
00:22:19,550 --> 00:22:21,480
だから、それは以下である
または7より大きい？

527
00:22:21,480 --> 00:22:23,080

528
00:22:23,080 --> 00:22:23,960
未満である。

529
00:22:23,960 --> 00:22:24,570
はい。

530
00:22:24,570 --> 00:22:25,170
ニースの仕事の連中。

531
00:22:25,170 --> 00:22:25,569

532
00:22:25,569 --> 00:22:27,360
私は私が必要がありますように感じる
キャンディーを持っている私がいるので

533
00:22:27,360 --> 00:22:29,460
ヤードにそれを捨てたい。

534
00:22:29,460 --> 00:22:30,270
それは私が来週するつもりですんだ。

535
00:22:30,270 --> 00:22:31,436
それは鋭い君たちを維持します。

536
00:22:31,436 --> 00:22:32,560

537
00:22:32,560 --> 00:22:34,690
>> そこで、我々はそれを捨てる
前半、右？

538
00:22:34,690 --> 00:22:35,670
それは以下であった。

539
00:22:35,670 --> 00:22:39,325
我々はそのすべてを知っている
その左側

540
00:22:39,325 --> 00:22:41,700
未満であると何が起こっているか
私たちは実際に探している。

541
00:22:41,700 --> 00:22:43,491
だから、する必要はありません
それに注意を払う。

542
00:22:43,491 --> 00:22:45,120
ちょうどそれを忘れる。

543
00:22:45,120 --> 00:22:48,720
だから、今私たちは私たちの右側を見て、
そして我々はあそこに真ん中を見て、

544
00:22:48,720 --> 00:22:50,510
今では9です。

545
00:22:50,510 --> 00:22:55,510
だから、9 is-- --Everyone？

546
00:22:55,510 --> 00:22:57,470
私たちは何をしているよりも大きい
右、先をお探しですか？

547
00:22:57,470 --> 00:22:59,860
だから、私たちはスローするつもりだ
右に離れてすべてのもの。

548
00:22:59,860 --> 00:23:00,970

549
00:23:00,970 --> 00:23:01,940
そのような。

550
00:23:01,940 --> 00:23:03,700
今、すべての私たちは一つですが残っている。

551
00:23:03,700 --> 00:23:07,760
だから我々はチェックし、この1であるもの
私たちは探している？それは。

552
00:23:07,760 --> 00:23:08,970
我々は、我々が望んで見つかった。

553
00:23:08,970 --> 00:23:10,440

554
00:23:10,440 --> 00:23:11,690
だから我々は完了です。

555
00:23:11,690 --> 00:23:12,550
バイリニア検索。

556
00:23:12,550 --> 00:23:15,740
>> そして、あなたは、私たちに気づいた場合
そこに7の入力を持っていた。

557
00:23:15,740 --> 00:23:24,320
それは3回だけのように連れて行ってくれました、
しかし、あなたは億のようにやっている場合には、

558
00:23:24,320 --> 00:23:28,190
君たちは、どのように多くのステップそれは知っているだろう
我々は40億物事を持っていた場合取る？

559
00:23:28,190 --> 00:23:29,940

560
00:23:29,940 --> 00:23:30,455
任意の推測？

561
00:23:30,455 --> 00:23:32,286

562
00:23:32,286 --> 00:23:33,960
それは32だ。

563
00:23:33,960 --> 00:23:37,110
何かを見つけるための32ステップ
40億中

564
00:23:37,110 --> 00:23:39,650
なぜなら、2の累乗の要素の配列。

565
00:23:39,650 --> 00:23:43,550
だから二人は、32にある40億にある。

566
00:23:43,550 --> 00:23:50,430
>> だから、かなりクレイジーどのようにあなたはまだ内だ
ステップのかなり少数のような

567
00:23:50,430 --> 00:23:52,650
で何かを見つけるために
40億要素。

568
00:23:52,650 --> 00:23:55,730
だから、そのノートに、私たちはしている
これをコーディングする予定

569
00:23:55,730 --> 00:23:58,950
そうあなたたちは、実際に缶
種類の、これはどのように動作するかを参照してください。

570
00:23:58,950 --> 00:24:01,520
すべての権利、君たちはコーディングすることができますように。

571
00:24:01,520 --> 00:24:04,100
私は君たちようにするつもりです
少しのために話す。

572
00:24:04,100 --> 00:24:07,970
である、あなたの周りの人々を知ってもらう
何誰かが最後のセクションから望んでいた。

573
00:24:07,970 --> 00:24:10,280
>> だから、あなたの周りの人々を知るようになる。

574
00:24:10,280 --> 00:24:11,305
少しのために話す。

575
00:24:11,305 --> 00:24:12,580

576
00:24:12,580 --> 00:24:15,730
そして、すべて私はあなたから欲しい
連中は、今だけである

577
00:24:15,730 --> 00:24:17,575
擬似コードのアウトラインを作成してみてください。

578
00:24:17,575 --> 00:24:18,075
OK？

579
00:24:18,075 --> 00:24:20,825

580
00:24:20,825 --> 00:24:21,325
おっと。

581
00:24:21,325 --> 00:24:23,320

582
00:24:23,320 --> 00:24:29,520
私はあなたたちから欲しいすべては、あなたがしているである
ちょうどこのしばらくケースに埋めるつもり。

583
00:24:29,520 --> 00:24:32,170
だから私は、これらの上限を設定している
と下限いる

584
00:24:32,170 --> 00:24:35,250
始まりを表す
私たちの配列のと終了。

585
00:24:35,250 --> 00:24:40,440
そして、あなたが実際にしようとしている
ループを通ると把握

586
00:24:40,440 --> 00:24:42,470
我々は、このwhileループ内で何をやっている。

587
00:24:42,470 --> 00:24:45,810
>> あなたがゆうパックで把握することができますので、もし私が持っている
ケースが何であるかをthere--ヒント

588
00:24:45,810 --> 00:24:46,640
私たちがここに持っている？

589
00:24:46,640 --> 00:24:48,100

590
00:24:48,100 --> 00:24:51,560
あなたが把握したいのであれば
ケースは、我々はそれらを擬似コードます

591
00:24:51,560 --> 00:24:53,350
その後、我々は実際にそれらをコーディングします。

592
00:24:53,350 --> 00:24:55,330
そしてそれは、私になるだろう
それがうまくいけば、と思う

593
00:24:55,330 --> 00:24:56,788
あなたが予想よりも少し簡単にしてください。

594
00:24:56,788 --> 00:24:57,554

595
00:24:57,554 --> 00:25:00,220
なぜならそれがその多くのコードではありません、
実際に、これは本当にクールです。

596
00:25:00,220 --> 00:25:34,110

597
00:25:34,110 --> 00:25:35,018
>> MM-HM？

598
00:25:35,018 --> 00:25:35,893
>> 学生：[聞こえない]？

599
00:25:35,893 --> 00:25:36,984

600
00:25:36,984 --> 00:25:37,650
講師：はい。

601
00:25:37,650 --> 00:25:38,595
何かがあった
途中で見つけるために。

602
00:25:38,595 --> 00:25:39,552
>> 学生：だから我々はそれを使用することができます。

603
00:25:39,552 --> 00:25:39,770
[OK]をクリックします。

604
00:25:39,770 --> 00:25:40,603
>> 講師：パーフェクト。

605
00:25:40,603 --> 00:25:42,950
だから、それは我々が最初に必要なことだ。

606
00:25:42,950 --> 00:25:44,330
だから、真ん中を見つける。

607
00:25:44,330 --> 00:25:45,415

608
00:25:45,415 --> 00:25:45,915
グレート。

609
00:25:45,915 --> 00:25:47,770

610
00:25:47,770 --> 00:25:55,010
だから、どのように我々はかもしれないという考えを持っていない
実際にコードとの真ん中を見つける？

611
00:25:55,010 --> 00:25:55,980
>> 学生：うん。

612
00:25:55,980 --> 00:25:57,000
2オーバーのn？

613
00:25:57,000 --> 00:25:58,500

614
00:25:58,500 --> 00:25:59,500
講師：だから、nは2オーバー。

615
00:25:59,500 --> 00:26:05,170
だから、覚えておくべき一つのことということです
あなたの上限と下限が変わります。

616
00:26:05,170 --> 00:26:08,110
私たちは、一部を収縮保つ
アレイで我々はに探しています。

617
00:26:08,110 --> 00:26:11,970
だから、nは2の上にのみ機能します
最初にのために私たちはやる。

618
00:26:11,970 --> 00:26:17,810
そこで考慮上下取る
どのように我々はその中間の要素を得るかもしれない？

619
00:26:17,810 --> 00:26:20,640
私たちは中央をしたいので
右、上下の間に？

620
00:26:20,640 --> 00:26:21,730

621
00:26:21,730 --> 00:26:22,494
MM-HM？

622
00:26:22,494 --> 00:26:23,369
>> 学生：[聞こえない]。

623
00:26:23,369 --> 00:26:26,170

624
00:26:26,170 --> 00:26:28,080
>> 講師：だから我々はいくつかの真ん中を持っている。

625
00:26:28,080 --> 00:26:32,730
そして、それは、上側プラス2オーバー低くなるでしょう。

626
00:26:32,730 --> 00:26:34,740

627
00:26:34,740 --> 00:26:35,690
恐ろしい。

628
00:26:35,690 --> 00:26:36,570
私たちはそこに行く。

629
00:26:36,570 --> 00:26:37,280
1行下。

630
00:26:37,280 --> 00:26:38,560
君たちはあなたの方法にある。

631
00:26:38,560 --> 00:26:41,400
だから今我々は持っていること
真ん中には、我々は何をすべきかをしたいですか？

632
00:26:41,400 --> 00:26:45,050

633
00:26:45,050 --> 00:26:45,900
ただ一般的には。

634
00:26:45,900 --> 00:26:47,734
あなたはそれをコーディングする必要はありません。

635
00:26:47,734 --> 00:26:48,335
はい。

636
00:26:48,335 --> 00:26:49,210
学生：[聞こえない]？

637
00:26:49,210 --> 00:27:00,310

638
00:27:00,310 --> 00:27:10,310
講師：あなたがしているので、だから、プラスだ
2間の平均を見つける

639
00:27:10,310 --> 00:27:10,810
それらの。

640
00:27:10,810 --> 00:27:11,890

641
00:27:11,890 --> 00:27:17,370
だから、として親切それらを思えば
側面からの高まりの、

642
00:27:17,370 --> 00:27:21,640
あなたが近づくとそれについて考える
真ん中のは、あなたがそのようにしたい。

643
00:27:21,640 --> 00:27:27,150
だから、のいずれかの側にあった場合は、
ミドル、そして我々は5,7のように持っている。

644
00:27:27,150 --> 00:27:31,440
あなたはあなたにそれらを一緒に追加すると
12を取得し、あなたは2で割る、6です。

645
00:27:31,440 --> 00:27:33,726
>> 時にはそれが難しいです
その作業の理由を説明し、

646
00:27:33,726 --> 00:27:35,600
しかし、あなたはを通して作業している場合
例時には、

647
00:27:35,600 --> 00:27:37,962
それはあなたがどうかを把握お手伝いします
それがプラスまたはマイナスにする必要があります。

648
00:27:37,962 --> 00:27:38,846
はい。

649
00:27:38,846 --> 00:27:40,830
>> 学生：[聞こえない]
丁度真ん中に

650
00:27:40,830 --> 00:27:43,950
彼らはどこにケースを持っていた場合
小さい数字がたくさんあり​​ます

651
00:27:43,950 --> 00:27:45,860
1つの大きな番号のような？

652
00:27:45,860 --> 00:27:49,750
>> 講師：だから、すべてあなたが必要
アレイの中央である。

653
00:27:49,750 --> 00:27:53,010
ですから、少数の束を持っていた場合
その後1本当に多数

654
00:27:53,010 --> 00:27:54,799
最後に、それは問題ではありません。

655
00:27:54,799 --> 00:27:56,840
重要なのは、ということです
彼らは、あなただけでソートしている

656
00:27:56,840 --> 00:27:59,339
の真ん中を見てみたい
アレーあなたはまだだから

657
00:27:59,339 --> 00:28:00,700
半分にあなたの問題をスライスする。

658
00:28:00,700 --> 00:28:03,020

659
00:28:03,020 --> 00:28:03,680
涼しい。

660
00:28:03,680 --> 00:28:06,430
だから今我々が持っていること
真ん中には、私たちは次に何をしますか？

661
00:28:06,430 --> 00:28:07,150
>> 学生：比較してください。

662
00:28:07,150 --> 00:28:08,150
講師：比較。

663
00:28:08,150 --> 00:28:11,670
だからvalue_wantedために中間を比較します。

664
00:28:11,670 --> 00:28:14,300

665
00:28:14,300 --> 00:28:15,160
涼しい。

666
00:28:15,160 --> 00:28:17,950
ですから、私たちが持ってここに参照してください。
この値は、我々はここにアップしたい。

667
00:28:17,950 --> 00:28:22,012

668
00:28:22,012 --> 00:28:23,095
これは配列であることを忘れないでください。

669
00:28:23,095 --> 00:28:24,100

670
00:28:24,100 --> 00:28:26,970
だから、真ん中はインデックスを参照。

671
00:28:26,970 --> 00:28:29,785
だから我々は真ん中の値をやってみたい。

672
00:28:29,785 --> 00:28:32,380

673
00:28:32,380 --> 00:28:35,650
あなたがしたい場合を忘れないでください
、二重の等号を比較することができます。

674
00:28:35,650 --> 00:28:38,250
あなたがしているシングル等しいん
ちょうどそれを再割り当てするつもりは、

675
00:28:38,250 --> 00:28:41,090
その後、もちろん、それがだ
あなたが希望する値になるだろう。

676
00:28:41,090 --> 00:28:42,300
だから、それをしないでください。

677
00:28:42,300 --> 00:28:44,350
>> だから我々はどうするつもりだ
途中での値

678
00:28:44,350 --> 00:28:46,460
私たちが望む値に等しい。

679
00:28:46,460 --> 00:28:47,749

680
00:28:47,749 --> 00:28:48,790
あなたの中括弧を忘れないでください。

681
00:28:48,790 --> 00:28:50,520

682
00:28:50,520 --> 00:28:52,235
Dropboxは離れて行く必要があります。

683
00:28:52,235 --> 00:28:54,140

684
00:28:54,140 --> 00:28:56,200
だから我々は、この場合に何をしますか？

685
00:28:56,200 --> 00:28:59,360
それが仕事だ場合、我々は返すようにしたいですか？

686
00:28:59,360 --> 00:29:01,510

687
00:29:01,510 --> 00:29:02,626
私たちは言おうとしている。

688
00:29:02,626 --> 00:29:03,440
>> 学生：オフ印刷します。

689
00:29:03,440 --> 00:29:05,314
>> 講師：まあ、我々
オフ印刷しない。

690
00:29:05,314 --> 00:29:08,220
だから、これはここにブールですので、我々
trueまたはfalseを返すようにしたい。

691
00:29:08,220 --> 00:29:12,280
我々は、この番号である、と言っている
[？ RRA？ ？]だからである場合

692
00:29:12,280 --> 00:29:13,788
私達はちょうどそれが真を返す。

693
00:29:13,788 --> 00:29:16,780

694
00:29:16,780 --> 00:29:17,760
私は真綴ることができる場合。

695
00:29:17,760 --> 00:29:18,830

696
00:29:18,830 --> 00:29:20,805
>> 学生：なぜあなたは、ゼロを返しませんでしょうか？

697
00:29:20,805 --> 00:29:22,930
講師：あなたができるよう
あなたが望む場合はゼロを返します。

698
00:29:22,930 --> 00:29:26,780
しかし、今回のケースであるため
私たちの関数はブール値を返し、

699
00:29:26,780 --> 00:29:28,962
私たちは、trueまたはfalseを返す必要があります。

700
00:29:28,962 --> 00:29:30,920
学生：あなたがしている
ブール式を言って、

701
00:29:30,920 --> 00:29:33,450
あなたはそれをfalseに等しくなるように設定することができますか？

702
00:29:33,450 --> 00:29:39,860
私が言いたい場合には、もしこのような状態
アッパーはfalseに等しいように、満たされていない。

703
00:29:39,860 --> 00:29:42,332
ちょうどあなた場合、それは理解できるであろう
反対側にfalseを置く？

704
00:29:42,332 --> 00:29:43,040
講師：うん。

705
00:29:43,040 --> 00:29:44,820
だから、実際にあなたがいるなら
今までに何かをして

706
00:29:44,820 --> 00:29:49,600
上限であるか、または低くなるような、
それは、trueまたはfalseを返します

707
00:29:49,600 --> 00:29:53,850
そしてそれは実際に悪いスタイルだ
等号がtrueに等しいかイコール言う

708
00:29:53,850 --> 00:29:54,840
偽等しい。

709
00:29:54,840 --> 00:30:00,210
あなたはその結果を使用したい
あなたのチェックとして、それ自体として。

710
00:30:00,210 --> 00:30:04,720

711
00:30:04,720 --> 00:30:05,860
私が望んでいないもの。

712
00:30:05,860 --> 00:30:08,150

713
00:30:08,150 --> 00:30:09,240
それは私が欲しかったものだ。

714
00:30:09,240 --> 00:30:13,205
だから例に求めている
Cでこれを保存するような何かについて。

715
00:30:13,205 --> 00:30:16,320

716
00:30:16,320 --> 00:30:25,150
>> そこで、int型メイン（ボイド）がある場合
そして、このような何か。

717
00:30:25,150 --> 00:30:31,922
上側のであれば、あなたが持っている
あなたがしているといくつかの入力の

718
00:30:31,922 --> 00:30:33,630
あなたが行うことができますかどうかを尋ねる
このような何か？

719
00:30:33,630 --> 00:30:35,010

720
00:30:35,010 --> 00:30:35,679
右？

721
00:30:35,679 --> 00:30:37,470
学生：私がしようとしていた
それ[聞こえない]することができません。

722
00:30:37,470 --> 00:30:38,450
なぜならば、it's--

723
00:30:38,450 --> 00:30:39,200
講師：右。

724
00:30:39,200 --> 00:30:41,197
だから、あなたは正しい、これが偽になりたい？

725
00:30:41,197 --> 00:30:41,780
学生：うん。

726
00:30:41,780 --> 00:30:45,960
講師：だから、この場合はあなた
それは本当ではない場合は、それが実行したい。

727
00:30:45,960 --> 00:30:50,510
だから、あなたがクールな事はこれがあります。

728
00:30:50,510 --> 00:30:52,900

729
00:30:52,900 --> 00:30:55,650
だから、感嘆を覚えている
ポイントは、物事を否定？

730
00:30:55,650 --> 00:30:58,270
これは、[聞こえない]ではないことを意味言う。

731
00:30:58,270 --> 00:31:03,590
我々だけを見ればそう
ここではこの部分、あなたがしたい

732
00:31:03,590 --> 00:31:05,740
それがあると評価言う
あなたはそれがしたいようにはfalseを返します。

733
00:31:05,740 --> 00:31:06,790

734
00:31:06,790 --> 00:31:09,880
偽ではないが真である
これが実行される可能性がありますことを意味します。

735
00:31:09,880 --> 00:31:11,037
それは理にかなっていますか？

736
00:31:11,037 --> 00:31:11,620
学生：うん。

737
00:31:11,620 --> 00:31:12,453
講師：恐ろしい。

738
00:31:12,453 --> 00:31:13,800

739
00:31:13,800 --> 00:31:14,300
[OK]をクリックします。

740
00:31:14,300 --> 00:31:16,330
だから我々はただ返すことができます
この場合は真。

741
00:31:16,330 --> 00:31:20,357
だから今我々は他の2を持っている
この場合の例。

742
00:31:20,357 --> 00:31:21,565
我々の2つの他のケースは何ですか？

743
00:31:21,565 --> 00:31:31,610

744
00:31:31,610 --> 00:31:32,900
ちょうどこのようにそれをやってみましょう。

745
00:31:32,900 --> 00:31:40,660
それでは、誰から始めましょう
もし途中での値

746
00:31:40,660 --> 00:31:43,230
私たちが望む値未満である。

747
00:31:43,230 --> 00:31:47,200

748
00:31:47,200 --> 00:31:52,020
だから、途中で私たちの値が小さい
私たちが探している値よりも。

749
00:31:52,020 --> 00:31:53,765

750
00:31:53,765 --> 00:31:56,720
>> だからを行う​​バインドいる
我々は更新したいと思いますか？

751
00:31:56,720 --> 00:31:57,870

752
00:31:57,870 --> 00:31:58,780
上部または下部？

753
00:31:58,780 --> 00:32:01,440

754
00:32:01,440 --> 00:32:01,940
アッパー？

755
00:32:01,940 --> 00:32:03,230

756
00:32:03,230 --> 00:32:06,470
配列のだから、どちら側
我々はを見ているつもりですか？

757
00:32:06,470 --> 00:32:07,500
>> 学生：低い。

758
00:32:07,500 --> 00:32:09,750
>> 講師：私たちは、私たちがしようとしている
左を見られる。

759
00:32:09,750 --> 00:32:11,120
少し値が小さければ、そのように他の。

760
00:32:11,120 --> 00:32:14,730
ここにだからあなたの中間値
私たちが望むものよりも小さい。

761
00:32:14,730 --> 00:32:17,202
だから我々は利用したい
我々のアレイの右側。

762
00:32:17,202 --> 00:32:18,910
だから我々はするつもりだ
私たちの下界更新します。

763
00:32:18,910 --> 00:32:20,210

764
00:32:20,210 --> 00:32:23,020
だから我々は我々の下を再割り当てします。

765
00:32:23,020 --> 00:32:25,221
そして、あなたは下がどうあるべきかだと思いますか？

766
00:32:25,221 --> 00:32:26,304
学生：中間値？

767
00:32:26,304 --> 00:32:27,446

768
00:32:27,446 --> 00:32:28,820
講師：だから、真ん中value--

769
00:32:28,820 --> 00:32:30,136
学生：プラス1。

770
00:32:30,136 --> 00:32:31,010
講師：--plus 1。

771
00:32:31,010 --> 00:32:32,300

772
00:32:32,300 --> 00:32:34,380
誰もが、なぜ私を伝えることができます
我々はそのプラス1を持っている？

773
00:32:34,380 --> 00:32:35,730
>> 学生：[？値なし？]
それにより平等である。

774
00:32:35,730 --> 00:32:36,120
>> 講師：右。

775
00:32:36,120 --> 00:32:38,661
我々はすでに知っているので
我々の中央値は、に等しくない

776
00:32:38,661 --> 00:32:42,750
それ、我々はそれを除外したい
後続のすべての検索の。

777
00:32:42,750 --> 00:32:46,360
あなたはそのプラス1、これを忘れた場合
無限にループを好きになるでしょう。

778
00:32:46,360 --> 00:32:49,620
そして、あなたはただでキャッチされます
無限ループして、あなたがセグメンテーション違反だろう

779
00:32:49,620 --> 00:32:50,370
そして物事は悪くなる。

780
00:32:50,370 --> 00:32:54,780
だから、いつもあなたがわからないことを確認してください
ちょうどあなた値を含む

781
00:32:54,780 --> 00:32:55,380
を見た。

782
00:32:55,380 --> 00:32:58,530
だから我々は、プラス1でそれの世話をする。

783
00:32:58,530 --> 00:33:04,840
>> だから今、私たちは私たちの最後の条件を持っている
安全のためのためにどのいつも私

784
00:33:04,840 --> 00:33:12,664
あなたはでの値であれば、他の、ここで確認することができます
中間の値よりも大きい

785
00:33:12,664 --> 00:33:13,163
私たちは欲しい。

786
00:33:13,163 --> 00:33:16,260

787
00:33:16,260 --> 00:33:20,230
つまり、私たちが望むことを意味します
左側半分。

788
00:33:20,230 --> 00:33:21,350

789
00:33:21,350 --> 00:33:23,260
だから、その一つ、我々は更新するつもりですか？

790
00:33:23,260 --> 00:33:23,760
アッパー。

791
00:33:23,760 --> 00:33:25,470

792
00:33:25,470 --> 00:33:26,970
と等しくなるようにしよう、この1は何ですか？

793
00:33:26,970 --> 00:33:31,630

794
00:33:31,630 --> 00:33:33,690
真ん中のマイナス1なぜなら、
もちろん、我々は欲しい

795
00:33:33,690 --> 00:33:38,370
私たちがわからないことを確認します
再びその中間の値を見て。

796
00:33:38,370 --> 00:33:41,830

797
00:33:41,830 --> 00:33:45,110
そして、我々はそれを持っている。

798
00:33:45,110 --> 00:33:45,610
それはそれだ。

799
00:33:45,610 --> 00:33:46,820
つまり、バイナリ検索がすべてです。

800
00:33:46,820 --> 00:33:48,190
それは右、その悪くはない？

801
00:33:48,190 --> 00:33:51,590
これは、10行のようなものだ
ホワイトスペースを使用してコード。

802
00:33:51,590 --> 00:33:57,510
あなたは意志、非常に便利なので、非常に強力な
あなた以降のPsetのいずれかでそれを使用する。

803
00:33:57,510 --> 00:33:59,360
そうでないかもしれない、この1が、後。

804
00:33:59,360 --> 00:34:00,670
だから、それを学ぶ。

805
00:34:00,670 --> 00:34:01,510
それを愛する。

806
00:34:01,510 --> 00:34:02,980
それはあなたによく扱います。

807
00:34:02,980 --> 00:34:05,370
だから、誰もがいずれかを持っているん
バイナリサーチに関する質問？

808
00:34:05,370 --> 00:34:06,196
はい。

809
00:34:06,196 --> 00:34:09,840
>> 学生：それは問題ではない
あなたのnが偶数か奇数か？

810
00:34:09,840 --> 00:34:10,750
>> 講師：いいえ。

811
00:34:10,750 --> 00:34:18,150
我々のように真ん中にキャストしているので
int型は、それはちょうどそれが切り捨てられます。

812
00:34:18,150 --> 00:34:21,600
だから、整数に滞在し、それは意志
最終的にはすべてのものをソート。

813
00:34:21,600 --> 00:34:23,909
だから、そのことについて心配する必要はありません。

814
00:34:23,909 --> 00:34:24,580
みんな良い？

815
00:34:24,580 --> 00:34:25,659

816
00:34:25,659 --> 00:34:26,850
恐ろしい。

817
00:34:26,850 --> 00:34:27,919
涼しい。

818
00:34:27,919 --> 00:34:30,836
だから、君たちはこれを得た。

819
00:34:30,836 --> 00:34:33,380

820
00:34:33,380 --> 00:34:33,880
スライドショー。

821
00:34:33,880 --> 00:34:35,719

822
00:34:35,719 --> 00:34:43,270
私たちが話していたように、私は知っている
Davidは複雑ランタイムを言及。

823
00:34:43,270 --> 00:34:44,420

824
00:34:44,420 --> 00:34:50,340
>> そこで最良のケースでは、それだけだ
我々は一定の時間を呼び出す1、。

825
00:34:50,340 --> 00:34:51,909
それはかもしれない、なぜ誰も教えてもらえますか？

826
00:34:51,909 --> 00:34:52,969

827
00:34:52,969 --> 00:34:55,800
それは、シナリオはどのようなタイプを伴うだろうか？

828
00:34:55,800 --> 00:34:58,260

829
00:34:58,260 --> 00:34:58,760
MM-HM。

830
00:34:58,760 --> 00:34:59,926
>> 学生：[聞こえない] first--

831
00:34:59,926 --> 00:35:00,789

832
00:35:00,789 --> 00:35:03,830
講師：だから、真ん中がいる
我々はに来て最初の要素は、右？

833
00:35:03,830 --> 00:35:08,167
だから、1の配列のいずれか、または
私達はちょうど探しているものは何でも

834
00:35:08,167 --> 00:35:09,750
真ん中にピシャリDABであることを起こる。

835
00:35:09,750 --> 00:35:11,190

836
00:35:11,190 --> 00:35:13,380
だから、私たちの最高のケースです。

837
00:35:13,380 --> 00:35:17,540
おそらく、本当の問題にしない取得
その多くの場合、[聞こえない]に到達しようとして。

838
00:35:17,540 --> 00:35:18,667

839
00:35:18,667 --> 00:35:19,750
何私たちの最悪のケースはどうですか？

840
00:35:19,750 --> 00:35:21,270
私たちの最悪の場合には、ログnである。

841
00:35:21,270 --> 00:35:25,360
そして、それは全体に関係しています
私が話を2のべき乗の事。

842
00:35:25,360 --> 00:35:30,930
>> そこで最悪の場合、それが意味する
私たちはダウン配列をチョップしなければならなかったこと

843
00:35:30,930 --> 00:35:33,270
、一つの要素になるまで。

844
00:35:33,270 --> 00:35:34,810

845
00:35:34,810 --> 00:35:38,930
だから我々はそれを半分に切り倒す必要がありました
何度でも我々はおそらくできる限り。

846
00:35:38,930 --> 00:35:41,430
それはログnの理由だ理由です
あなただけの2で割る保つ。

847
00:35:41,430 --> 00:35:42,890

848
00:35:42,890 --> 00:35:45,830
仮定、物事あなたはとても
あなたが今までしているかどうかを知る必要があり

849
00:35:45,830 --> 00:35:48,050
バイナリ検索を使用するつもり。

850
00:35:48,050 --> 00:35:50,680
あなたの要素はソートする必要があります。

851
00:35:50,680 --> 00:35:53,890
彼らは理由にソートされなければならない
それはあなたの唯一の方法だ

852
00:35:53,890 --> 00:35:57,060
あなたができるかどうかを知ることができます
それの半分を捨てる。

853
00:35:57,060 --> 00:36:00,260
>> あなたはこのごちゃ混ぜ袋を持っていた場合
数字のあなたが言っている、

854
00:36:00,260 --> 00:36:05,380
[OK]を、私は真ん中をチェックするつもりだ
数と私が探している数

855
00:36:05,380 --> 00:36:08,510
それよりも少ないですが、私はちょうどつもりです
任意の半分を捨てるため。

856
00:36:08,510 --> 00:36:11,130
あなたの場合は知っているだろう
その残りの半分の数字。

857
00:36:11,130 --> 00:36:12,655
あなたのリストをソートする必要があります。

858
00:36:12,655 --> 00:36:14,030

859
00:36:14,030 --> 00:36:16,560
同様に、これであってもよい
先に少し行く、

860
00:36:16,560 --> 00:36:18,360
しかし、あなたは、ランダムアクセスを持っている必要があります。

861
00:36:18,360 --> 00:36:21,940
あなただけのことができるようにする必要があります
その中央の要素に移動します。

862
00:36:21,940 --> 00:36:25,110
あなたが横断しなければならない場合
何かを通じて

863
00:36:25,110 --> 00:36:28,630
またはそれはあなたの余分なステップを取る
その中間の要素を取得するには、

864
00:36:28,630 --> 00:36:31,750
それはログに記録nはもはやなぜならないです
あなたはそれに多くの作業を追加している。

865
00:36:31,750 --> 00:36:34,800
そして、これは少しを行います
2週間でより多くの意味、

866
00:36:34,800 --> 00:36:37,950
しかし、私はちょうど種類の序文たかった、
君たちに何のアイデアを与える

867
00:36:37,950 --> 00:36:38,999
来て。

868
00:36:38,999 --> 00:36:40,790
しかし、これらの2つである
重要な仮定

869
00:36:40,790 --> 00:36:44,804
あなたがバイナリリストについて必要があると。

870
00:36:44,804 --> 00:36:45,720
それはソートだことを確認してください。

871
00:36:45,720 --> 00:36:47,920
つまりにとって大きな一つだ
あなた今、みんな。

872
00:36:47,920 --> 00:36:52,170
その上、我々は入ることができます
私たちの種類の残りの部分。

873
00:36:52,170 --> 00:36:56,444
だから、4 sorts--バブル、
挿入、選択、およびマージ。

874
00:36:56,444 --> 00:36:57,485
彼らはクールのすべての種類だ。

875
00:36:57,485 --> 00:37:02,860
君たちは、CS 124取ることを決定した場合、
あなたは種類のすべての種類について学びます。

876
00:37:02,860 --> 00:37:07,575
そして、あなたはそこに、XKCDファンなら
本当にクールな漫画うとしている

877
00:37:07,575 --> 00:37:11,530
本当に効果のない種類のように、どのI
非常にあなたが見に行くことをお勧めします。

878
00:37:11,530 --> 00:37:16,170
その一つは、パニックソート似ているある
ああ、いや、ランダムな配列を返す、などである。

879
00:37:16,170 --> 00:37:16,991
停止システム。

880
00:37:16,991 --> 00:37:17,490
ままにしておきます。

881
00:37:17,490 --> 00:37:19,070

882
00:37:19,070 --> 00:37:21,500
だから、マニアックなユーモアは常に良いです。

883
00:37:21,500 --> 00:37:22,620

884
00:37:22,620 --> 00:37:25,750
>> だから、誰もが親切覚えてません
ちょうど一般的な考えのように

885
00:37:25,750 --> 00:37:27,810
バブルソートがどのように動作するかの。

886
00:37:27,810 --> 00:37:31,130

887
00:37:31,130 --> 00:37:32,155
あなたは覚えていますか？

888
00:37:32,155 --> 00:37:32,755
>> 学生：うん。

889
00:37:32,755 --> 00:37:33,970
>> 講師：それのために行く。

890
00:37:33,970 --> 00:37:38,980
>> 学生：だからあなたを介して行っていると
それは大きいです場合は、2を交換。

891
00:37:38,980 --> 00:37:39,820
>> 講師：MM-HM。

892
00:37:39,820 --> 00:37:40,564
正確に。

893
00:37:40,564 --> 00:37:41,730
だから、あなただけの反復処理。

894
00:37:41,730 --> 00:37:43,050
次の2つの番号をチェック。

895
00:37:43,050 --> 00:37:46,510
1は前に大きい場合
その後1より、

896
00:37:46,510 --> 00:37:50,230
あなただけでそのようにそれらを交換
このように高い数値のすべて

897
00:37:50,230 --> 00:37:54,990
リストの終わりに向かってバブルアップ
とそれ以下のすべての数字バブルダウン。

898
00:37:54,990 --> 00:37:59,355
>> 彼はクールな君たちを示しましたか
ビデオをソートする効果音？

899
00:37:59,355 --> 00:38:00,480
それは、クールのようなものだ。

900
00:38:00,480 --> 00:38:01,510

901
00:38:01,510 --> 00:38:05,200
だから、ロバートは今言ったように、アルゴリズム
あなただけのリストをステップ実行することを、

902
00:38:05,200 --> 00:38:07,930
隣接する値をスワップ
彼らは順番にいないのであれば。

903
00:38:07,930 --> 00:38:10,975
そして、ちょうど繰り返し続ける
あなたまで、あらゆるスワップすることはありません。

904
00:38:10,975 --> 00:38:11,990

905
00:38:11,990 --> 00:38:12,740
そんなに悪くないよね？

906
00:38:12,740 --> 00:38:14,080

907
00:38:14,080 --> 00:38:16,319
だから我々はちょうどここに簡単な例を持っている。

908
00:38:16,319 --> 00:38:18,360
だから、これは並べ替えしようとしている
昇順でそれら。

909
00:38:18,360 --> 00:38:19,470

910
00:38:19,470 --> 00:38:23,470
だから我々は最初に通過するとき
時間は、私たちは8に目を通す

911
00:38:23,470 --> 00:38:26,880
そして6は明らかではありません
ために、我々はそれらを交換。

912
00:38:26,880 --> 00:38:27,985
>> だから、次の1を見てください。

913
00:38:27,985 --> 00:38:29,430
エイトと順番に4ません。

914
00:38:29,430 --> 00:38:30,450
それらを交換。

915
00:38:30,450 --> 00:38:32,530
その後8および2は、それらを交換。

916
00:38:32,530 --> 00:38:33,470
私たちはそこに行く。

917
00:38:33,470 --> 00:38:39,519
だからあなたの最初のパスの後、あなた
あなたの最も多くのことを知っている

918
00:38:39,519 --> 00:38:41,810
すべての道になるだろう
それだけだから一番上にある

919
00:38:41,810 --> 00:38:44,210
絶えずになるだろう
他のすべてよりも大きい

920
00:38:44,210 --> 00:38:46,810
そしてそれはちょうどバブルに起こっている
そこに最後まですべての方法まで。

921
00:38:46,810 --> 00:38:48,226
それは皆に理にかなっていますか？

922
00:38:48,226 --> 00:38:48,560

923
00:38:48,560 --> 00:38:49,060
涼しい。

924
00:38:49,060 --> 00:38:51,310

925
00:38:51,310 --> 00:38:53,920
>> それでは、私たちは私たちの第二のパスを見てください。

926
00:38:53,920 --> 00:38:54,980
六四、スイッチ。

927
00:38:54,980 --> 00:38:55,920
六二、スイッチ。

928
00:38:55,920 --> 00:38:58,700
そして今、我々は順番にいくつかのことを持っている。

929
00:38:58,700 --> 00:39:02,240
すべてのパスのように、私たち
私達の全体のリストを作る

930
00:39:02,240 --> 00:39:06,320
我々は、多くの数字のようにそれを知っている
終了時にソートされているであろう。

931
00:39:06,320 --> 00:39:07,690

932
00:39:07,690 --> 00:39:09,610
だから我々は3回目のパスを行う、
その1スワップです。

933
00:39:09,610 --> 00:39:10,860

934
00:39:10,860 --> 00:39:15,910
その後私たちの第四の上
我々はゼロスロットがあり、合格する。

935
00:39:15,910 --> 00:39:18,570
そして私たちは知っている私たちの
配列はソートされている。

936
00:39:18,570 --> 00:39:20,900
>> そしてそれは大きいです
バブルソートとの事。

937
00:39:20,900 --> 00:39:23,720
私たちは、そのときに我々を知って
、そのゼロスワップを持っている

938
00:39:23,720 --> 00:39:26,497
そのすべてを意味します
完全なオーダーである。

939
00:39:26,497 --> 00:39:27,580
それは我々がチェックする方法のようなものだ。

940
00:39:27,580 --> 00:39:28,740

941
00:39:28,740 --> 00:39:36,480
だから我々はまた、バブルをコーディングしようとしている
また、悪いことではありませんソート。

942
00:39:36,480 --> 00:39:38,120
これらはどれもそれほど悪くはありません。

943
00:39:38,120 --> 00:39:40,210
私は、彼らが少し怖いように見えることができます知っている。

944
00:39:40,210 --> 00:39:42,124
私が取ったとき、私は知っている
クラス場合であっても、私

945
00:39:42,124 --> 00:39:44,290
のためのクラスを教えていた
初めて昨年、

946
00:39:44,290 --> 00:39:46,165
私は、私はこれをどのように行うのですか、のようだった？

947
00:39:46,165 --> 00:39:48,540
それは、理論的には理にかなっているが、
私たちは実際にこれをどのように行うのですか？

948
00:39:48,540 --> 00:39:51,420
私も歩きたい理由である
ここに君たちとのコードを通して。

949
00:39:51,420 --> 00:39:54,915
だから私は擬似コードを持っている
今回は皆さんのために。

950
00:39:54,915 --> 00:39:55,950

951
00:39:55,950 --> 00:39:58,970
だから、同じようにこれを覚えておく
我々はオーバーに移行しようとしています。

952
00:39:58,970 --> 00:40:04,210
だから我々はいくつかのカウンターを持っている
私たちのスワップを追跡し、

953
00:40:04,210 --> 00:40:08,370
我々は確認する必要がありますので、
我々はそれをチェックしていること。

954
00:40:08,370 --> 00:40:11,830
そして、我々は、配列全体を反復
私達はちょうどこの例で行ったように。

955
00:40:11,830 --> 00:40:12,900

956
00:40:12,900 --> 00:40:17,325
要素は、以前よりも大きい場合
私たちがどこの後の要素、

957
00:40:17,325 --> 00:40:20,760
私たちはそれらを交換し、我々は我々のをインクリメント
カウンター、我々はスワップや否や理由

958
00:40:20,760 --> 00:40:23,850
私たちはカウンターがそれを知らせたい。

959
00:40:23,850 --> 00:40:26,247
そこにどの質問？

960
00:40:26,247 --> 00:40:27,580
何かがこっちに面白いと思われる。

961
00:40:27,580 --> 00:40:29,225

962
00:40:29,225 --> 00:40:32,350
学生：あなたがゼロにカウンターを設定してください
あなたは、ループを通過するたびに？

963
00:40:32,350 --> 00:40:34,339
あなたは続けるしないでください
ゼロに戻るたびに？

964
00:40:34,339 --> 00:40:35,505
講師：必ずしもそうではありません。

965
00:40:35,505 --> 00:40:39,710
だから何が起こるかは私たちがここを通過している。

966
00:40:39,710 --> 00:40:43,830
だから、これをしばらく覚えていますか
必ず一度実行されます。

967
00:40:43,830 --> 00:40:46,480
だから、設定するために起こっている
ゼロに等しいカウンタ

968
00:40:46,480 --> 00:40:48,070
それはを反復処理するために起こっている。

969
00:40:48,070 --> 00:40:50,590
それが反復処理として、
それはカウンターを更新します。

970
00:40:50,590 --> 00:40:51,870

971
00:40:51,870 --> 00:40:56,900
それはカウンター更新など、それが終了したときに、
それは、配列の最後に到達だとき、

972
00:40:56,900 --> 00:41:00,830
私たちのリストがソートされていない場合、
カウンタが更新されています。

973
00:41:00,830 --> 00:41:01,840

974
00:41:01,840 --> 00:41:07,150
>> だから、それは条件をチェックし、それ
[OK]を、ゼロよりカウンターも大きい、と言います。

975
00:41:07,150 --> 00:41:09,290
もしそうであれば、再びそれを行う。

976
00:41:09,290 --> 00:41:14,340
あなたはそうしたときにことをリセットしたい
通過すると、カウンタはゼロに等しい。

977
00:41:14,340 --> 00:41:18,240
あなたは、ソートを通過した場合
アレー、何も変化し、

978
00:41:18,240 --> 00:41:21,355
これが失敗し、
ソートされたリストを返す。

979
00:41:21,355 --> 00:41:23,104

980
00:41:23,104 --> 00:41:24,020
それは理にかなっていますか？

981
00:41:24,020 --> 00:41:24,940

982
00:41:24,940 --> 00:41:26,356
学生：それは少し中かもしれません。

983
00:41:26,356 --> 00:41:27,147
講師：OK。

984
00:41:27,147 --> 00:41:28,980
他のは、あるとすれば
立ち上がる質問。

985
00:41:28,980 --> 00:41:30,180

986
00:41:30,180 --> 00:41:30,680
はい。

987
00:41:30,680 --> 00:41:33,760
>> 学生：何だろう機能
要素をスワップするためのもの？

988
00:41:33,760 --> 00:41:36,900
>> 講師：だから我々は実際に書くことができます
私たちが今するつもりならそれ。

989
00:41:36,900 --> 00:41:37,801

990
00:41:37,801 --> 00:41:38,300
涼しい。

991
00:41:38,300 --> 00:41:42,155
そのノート上のように、アリソンに起こっている
アプライアンスに戻って切り替えます。

992
00:41:42,155 --> 00:41:43,080
それは楽しみになるだろう。

993
00:41:43,080 --> 00:41:45,170

994
00:41:45,170 --> 00:41:47,390
そして、私たちは私たちの素敵なを持っている
ここにバブルソートの事。

995
00:41:47,390 --> 00:41:50,800
だから私はすでにサイクリングをしました
配列を通して。

996
00:41:50,800 --> 00:41:53,030
私たちは、スワップを持っている
ゼロに等しい。

997
00:41:53,030 --> 00:41:54,480

998
00:41:54,480 --> 00:41:58,440
だから我々は、隣接入れ替えたい
要素は、彼らは順不同でなら。

999
00:41:58,440 --> 00:42:03,020
だから我々がする必要がある最初の事は
私たちの配列を反復処理されません。

1000
00:42:03,020 --> 00:42:04,500

1001
00:42:04,500 --> 00:42:08,260
>> それでは、どのように我々はかもしれないと思うん
私たちの配列を反復処理？

1002
00:42:08,260 --> 00:42:09,720

1003
00:42:09,720 --> 00:42:13,990
私達はのために持っていると私は0に等しい。

1004
00:42:13,990 --> 00:42:16,950

1005
00:42:16,950 --> 00:42:22,454
私たちは、私はあまりなりたい
nはマイナス1マイナスkより。

1006
00:42:22,454 --> 00:42:23,870
そして、私は、第二にそれを説明します。

1007
00:42:23,870 --> 00:42:26,280

1008
00:42:26,280 --> 00:42:32,830
だから、これはここで、最適化され、
私はすべてのパスの後に言った方法を覚えて

1009
00:42:32,830 --> 00:42:36,655
アレイ·私たちを通して
何がon--だということを知っている

1010
00:42:36,655 --> 00:42:43,590

1011
00:42:43,590 --> 00:42:46,295
>> だから、1パスの後、私たち
これがソートされていることを知っています。

1012
00:42:46,295 --> 00:42:47,370

1013
00:42:47,370 --> 00:42:50,060
二つのパスの後、我々は知っている
このすべてがソートされていること。

1014
00:42:50,060 --> 00:42:52,750
3つのパスの後、私たち
それはソートだね。

1015
00:42:52,750 --> 00:42:55,620
私は繰り返し処理していそうな方法
ここでは、アレイを通して、

1016
00:42:55,620 --> 00:43:01,090
それだけで行くことを確認していますされている
私たちが知っていることを通してソートされていないです。

1017
00:43:01,090 --> 00:43:01,644
OK？

1018
00:43:01,644 --> 00:43:02,810
それはちょうど、最適化だ。

1019
00:43:02,810 --> 00:43:04,430

1020
00:43:04,430 --> 00:43:08,210
あなたはただ単純にそれを書くことができます
すべてのものを反復、

1021
00:43:08,210 --> 00:43:09,970
それだけで長い時間がかかるだろう。

1022
00:43:09,970 --> 00:43:12,470
これ4ループで、それはだ
ちょうどいい最適化

1023
00:43:12,470 --> 00:43:18,460
我々はその後、すべての完全な知っているので、
ここで、アレイを通して反復、

1024
00:43:18,460 --> 00:43:24,050
ここにすべての完全なループのように、私たちは知っている
これらの要素のもう一つのその

1025
00:43:24,050 --> 00:43:25,760
最後にソートされます。

1026
00:43:25,760 --> 00:43:28,294
>> だから我々はそれらを心配する必要はありません。

1027
00:43:28,294 --> 00:43:29,710
それは皆に理にかなっていますか？

1028
00:43:29,710 --> 00:43:30,950
そのクールな小さなトリック？

1029
00:43:30,950 --> 00:43:32,060

1030
00:43:32,060 --> 00:43:37,270
その場合、もしそうであれば
我々は、を反復している

1031
00:43:37,270 --> 00:43:50,590
我々はかどうかを確認したいことを知っている
配列nとnプラス1が順序である。

1032
00:43:50,590 --> 00:43:52,640

1033
00:43:52,640 --> 00:43:53,559
[OK]をクリックします。

1034
00:43:53,559 --> 00:43:54,600
だからここ擬似コードです。

1035
00:43:54,600 --> 00:43:57,540
私たちは、アレイのnかどうかを確認したい
そしてnプラス1が順序である。

1036
00:43:57,540 --> 00:43:59,520
だから我々はそこに何を持っているのでしょうか？

1037
00:43:59,520 --> 00:44:01,090

1038
00:44:01,090 --> 00:44:03,120
それはいくつかの条件になるだろう。

1039
00:44:03,120 --> 00:44:04,220
それは場合になります。

1040
00:44:04,220 --> 00:44:07,066
>> 学生：配列​​nがされた場合
配列nはプラス1未満である。

1041
00:44:07,066 --> 00:44:07,816
講師：MM-HM。

1042
00:44:07,816 --> 00:44:09,000

1043
00:44:09,000 --> 00:44:10,699
さて、以下より大きい。

1044
00:44:10,699 --> 00:44:11,615
学生：より大きい。

1045
00:44:11,615 --> 00:44:15,850

1046
00:44:15,850 --> 00:44:17,620
その後、我々はそれらを交換したいと思います。

1047
00:44:17,620 --> 00:44:18,570
正確に。

1048
00:44:18,570 --> 00:44:23,570
だから今我々は何に入る
それらをスワップするためのメカニズム？

1049
00:44:23,570 --> 00:44:24,840

1050
00:44:24,840 --> 00:44:28,137
だから我々は、この簡単に通り抜けた、
スワップ関数の型は先週。

1051
00:44:28,137 --> 00:44:29,595
誰もがそれが働いた方法を覚えていますか？

1052
00:44:29,595 --> 00:44:32,300

1053
00:44:32,300 --> 00:44:34,950
だから我々はちょうど、それらを再割り当てすることはできません？

1054
00:44:34,950 --> 00:44:36,640
そのうちの一つが失われてしまいますので。

1055
00:44:36,640 --> 00:44:41,696
我々は、AがB、次いでBに等しいことを特徴とする場合
Aに等しく、両者の突然

1056
00:44:41,696 --> 00:44:43,150
Bにちょうど等しい

1057
00:44:43,150 --> 00:44:45,720
>> だから我々がしなければならない私たちです
の一時変数を持っている

1058
00:44:45,720 --> 00:44:49,055
我々しばらくのいずれかを保持するために行く
我々はスワッピングの過程にいる。

1059
00:44:49,055 --> 00:44:50,200

1060
00:44:50,200 --> 00:44:56,464
それでは私たちが持っていることは我々はいくつかのint型があるでしょうです
あなたがそれを割り当てることができto-- tempが等しい

1061
00:44:56,464 --> 00:44:59,130
あなただけの、欲しい方1へ
あなたがit--を追跡することを確認してください

1062
00:44:59,130 --> 00:45:01,840
ので、この場合には、私はするつもりだ
配列nはプラス1に割り当てます。

1063
00:45:01,840 --> 00:45:03,360

1064
00:45:03,360 --> 00:45:07,674
だから、何でも保持するために起こっている
値は、その第二のブロックである

1065
00:45:07,674 --> 00:45:08,590
私たちが見ていること。

1066
00:45:08,590 --> 00:45:09,700

1067
00:45:09,700 --> 00:45:13,240
>> そして、我々は行くことができますし、我々が行うことができますです
先に、配列nのプラス1を再割り当て、

1068
00:45:13,240 --> 00:45:14,990
私たちを知っているので
その値が格納されている。

1069
00:45:14,990 --> 00:45:16,645

1070
00:45:16,645 --> 00:45:19,270
また、これは大きなの一つです
あなたのいずれかの場合にthings--私は知らない

1071
00:45:19,270 --> 00:45:23,780
あなたは2を切り替えた場合の問題を持っていた
コー​​ドの行が突然物事が働いた。

1072
00:45:23,780 --> 00:45:25,880
順番は、CSで非常に重要である。

1073
00:45:25,880 --> 00:45:29,450
だから、必ず図作る
物事出可能な場合

1074
00:45:29,450 --> 00:45:31,230
実際に何が起こっているかに関して。

1075
00:45:31,230 --> 00:45:34,256
だから今、我々はするつもりだ
配列nのプラス1を再割り当て、

1076
00:45:34,256 --> 00:45:36,005
私たちを知っているので
その値が格納されている。

1077
00:45:36,005 --> 00:45:37,090

1078
00:45:37,090 --> 00:45:41,560
>> そして、我々は、配列にそれを割り当てることができます
nまたはこの場合、アレイ内のi。

1079
00:45:41,560 --> 00:45:50,540

1080
00:45:50,540 --> 00:45:51,465
あまりにも多くの変数。

1081
00:45:51,465 --> 00:45:54,230

1082
00:45:54,230 --> 00:45:55,470
[OK]をクリックします。

1083
00:45:55,470 --> 00:46:01,500
だから今我々が再割り当てした配列にi
プラス1は、配列のiに何があるかに等しい。

1084
00:46:01,500 --> 00:46:08,240
そして今、我々は戻って行くことができます
何に配列iのを割り当てる？

1085
00:46:08,240 --> 00:46:10,680

1086
00:46:10,680 --> 00:46:11,180
誰ですか？

1087
00:46:11,180 --> 00:46:13,490

1088
00:46:13,490 --> 00:46:14,010
>> 学生：10。

1089
00:46:14,010 --> 00:46:14,680
>> 講師：10。

1090
00:46:14,680 --> 00:46:15,180
正確に。

1091
00:46:15,180 --> 00:46:16,930

1092
00:46:16,930 --> 00:46:18,640
そして最後にひとつ。

1093
00:46:18,640 --> 00:46:21,840
我々は今それをスワップしている場合は、
私たちは何をすべきかが必要ですか？

1094
00:46:21,840 --> 00:46:23,740
一つのことは何ですか
それは私たちに伝えるために起こっている

1095
00:46:23,740 --> 00:46:27,542
我々はこれまでに、このプログラムを終了させる場合はどうなりますか？

1096
00:46:27,542 --> 00:46:29,250
私たちを教えてくれる
ソートされたリストを持っている？

1097
00:46:29,250 --> 00:46:31,560

1098
00:46:31,560 --> 00:46:33,750
私たちはどんなスワップを実行しない場合、右？

1099
00:46:33,750 --> 00:46:36,900
スワップに等しい場合
これの終わりにゼロ。

1100
00:46:36,900 --> 00:46:42,975
だから、あなたは私たちのように、スワップを実行するたびに、
ちょうどここでしたが、我々はスワップを更新したい。

1101
00:46:42,975 --> 00:46:45,002

1102
00:46:45,002 --> 00:46:47,210
そして、私はそこにいた知っている
質問以前の約あなたができる

1103
00:46:47,210 --> 00:46:49,689
代わりに、ゼロまたは1を使用
trueまたはfalseの。

1104
00:46:49,689 --> 00:46:50,980
そして、それは、これは、ここで何をするかだ。

1105
00:46:50,980 --> 00:46:52,750
だから、これはそうでない場合スワップを言います。

1106
00:46:52,750 --> 00:47:01,310
だから、スワップは常に私をis--ゼロである場合、
私の真理と取り違え私falsesを得る。

1107
00:47:01,310 --> 00:47:03,960
私たちは、私たちは評価したい
trueにし、そうではありません。

1108
00:47:03,960 --> 00:47:07,680

1109
00:47:07,680 --> 00:47:09,630
それがゼロだのであれば、それは偽だ。

1110
00:47:09,630 --> 00:47:12,560
あなたはそれを否定した場合
[？強打？]それは真になる。

1111
00:47:12,560 --> 00:47:13,975
それでは、この行が実行されます。

1112
00:47:13,975 --> 00:47:15,060

1113
00:47:15,060 --> 00:47:17,370
>> 真理と虚偽と
ゼロと1の狂気を取得。

1114
00:47:17,370 --> 00:47:20,690
ちょうどあなたがゆっくり歩けば
それを介してそれが意味をなすでしょう。

1115
00:47:20,690 --> 00:47:23,320
しかし、それはどのようなこの小さなだ
コー​​ドのビットはここにいます。

1116
00:47:23,320 --> 00:47:26,490
だから、これはどうかを確認し
我々はすべてスワップを行っている。

1117
00:47:26,490 --> 00:47:30,054
だから、何かほかにあればだ
ゼロ、それが偽になるだろう

1118
00:47:30,054 --> 00:47:31,970
全体の事はある
再び実行しよう。

1119
00:47:31,970 --> 00:47:33,150

1120
00:47:33,150 --> 00:47:33,650
クール？

1121
00:47:33,650 --> 00:47:34,660

1122
00:47:34,660 --> 00:47:36,000
>> 学生：ブレークは何をしますか？

1123
00:47:36,000 --> 00:47:38,990
>> 講師：ちょうどブレイク
ループの外にあなたを壊します。

1124
00:47:38,990 --> 00:47:41,570
この場合、それはそうだろう
ちょうどのようなプログラムを終了

1125
00:47:41,570 --> 00:47:43,828
そしてあなただけでしょう
あなたのソートされたリストを持っている。

1126
00:47:43,828 --> 00:47:44,536
学生：アメージング。

1127
00:47:44,536 --> 00:47:48,094

1128
00:47:48,094 --> 00:47:49,010
講師：ごめんなさい？

1129
00:47:49,010 --> 00:47:52,110
学生：以前に私たちのため
書かれたゼロの上に書かれた1を使用

1130
00:47:52,110 --> 00:47:54,170
場合にそれを提示する
それは仕事をしたりしません。

1131
00:47:54,170 --> 00:47:54,878
>> 講師：うん。

1132
00:47:54,878 --> 00:47:56,410
だから、ゼロまたは1を返すことができます。

1133
00:47:56,410 --> 00:47:58,950
この場合、我々は実際にわからないので、
関数で何をやって、

1134
00:47:58,950 --> 00:48:00,150
私達はちょうどそれが壊したく。

1135
00:48:00,150 --> 00:48:02,680
私たちは本当にそれを気にしないでください。

1136
00:48:02,680 --> 00:48:06,960
ブレーキもあれば良いです
それが勃発するために使われている

1137
00:48:06,960 --> 00:48:10,710
その4つのループまたは状態の
あなたが実行を保持しない。

1138
00:48:10,710 --> 00:48:12,110
それはちょうどそれらのあなたを取る。

1139
00:48:12,110 --> 00:48:13,587

1140
00:48:13,587 --> 00:48:14,795
それは、ニュアンスの事少しだ。

1141
00:48:14,795 --> 00:48:16,737

1142
00:48:16,737 --> 00:48:18,445
ありますような気がします
の手振りの多くは、

1143
00:48:18,445 --> 00:48:19,740
のようなあなたはすぐにこのことについて学びます。

1144
00:48:19,740 --> 00:48:20,955
>> しかし、あなたはすぐにこのことについて学びます。

1145
00:48:20,955 --> 00:48:21,500
私は約束します。

1146
00:48:21,500 --> 00:48:22,670

1147
00:48:22,670 --> 00:48:23,170
[OK]をクリックします。

1148
00:48:23,170 --> 00:48:24,840
だから、誰もがバブルソートを取得していますか？

1149
00:48:24,840 --> 00:48:25,550
あまりにも悪くはない。

1150
00:48:25,550 --> 00:48:31,910
使用して、スワップ物事を反復処理
temp変数は、我々はすべてそこに設定されている？

1151
00:48:31,910 --> 00:48:32,960
涼しい。

1152
00:48:32,960 --> 00:48:34,080
恐ろしい。

1153
00:48:34,080 --> 00:48:34,807
[OK]をクリックします。

1154
00:48:34,807 --> 00:48:35,765
戻るPowerPointに。

1155
00:48:35,765 --> 00:48:38,140

1156
00:48:38,140 --> 00:48:40,130
一般的にどの質問
これまでのところ、これらはどうですか？

1157
00:48:40,130 --> 00:48:41,200

1158
00:48:41,200 --> 00:48:41,700
涼しい。

1159
00:48:41,700 --> 00:48:43,110

1160
00:48:43,110 --> 00:48:43,695
MM-HM。

1161
00:48:43,695 --> 00:48:45,279
>> 学生：[聞こえない]通常はメインint型。

1162
00:48:45,279 --> 00:48:46,695
あなたは、このためにそれを持っている必要がありますか？

1163
00:48:46,695 --> 00:48:48,400

1164
00:48:48,400 --> 00:48:53,550
>> 講師：だから我々はちょうど探していた
ただ、実際のソートアルゴリズムで。

1165
00:48:53,550 --> 00:48:54,559

1166
00:48:54,559 --> 00:48:56,350
あなたが以内にそれを持っていた場合
より大きなプログラムのように、

1167
00:48:56,350 --> 00:48:57,891
あなたはint型のメインのどこかを持っているでしょう。

1168
00:48:57,891 --> 00:49:00,070

1169
00:49:00,070 --> 00:49:02,880
どこに依存
このアルゴリズムを使用して、

1170
00:49:02,880 --> 00:49:05,860
それは何決定するであろう
それによって返される。

1171
00:49:05,860 --> 00:49:09,960
しかし、私たちのケースでは、我々は厳密にしている
実際にこれを行う方法を見て

1172
00:49:09,960 --> 00:49:11,300
配列を反復処理。

1173
00:49:11,300 --> 00:49:12,570
だから我々はそれについて心配しないでください。

1174
00:49:12,570 --> 00:49:14,150

1175
00:49:14,150 --> 00:49:19,830
>> だから我々は最良のケースについて話していたと
バイナリサーチのための最悪の場合のシナリオ。

1176
00:49:19,830 --> 00:49:22,470
だから、やることも重要です
私たちの種類のそれぞれについて、その。

1177
00:49:22,470 --> 00:49:24,200

1178
00:49:24,200 --> 00:49:27,560
それで、あなたは最悪ですどう思いますか
バブルソートの場合ランタイム？

1179
00:49:27,560 --> 00:49:29,560

1180
00:49:29,560 --> 00:49:30,700
君たちは覚えていますか？

1181
00:49:30,700 --> 00:49:31,784
>> 学生：Nマイナス1。

1182
00:49:31,784 --> 00:49:32,700
講師：Nマイナス1。

1183
00:49:32,700 --> 00:49:35,070
だから、ある意味
nはマイナス1の比較。

1184
00:49:35,070 --> 00:49:40,060
だから、実現するための一つのことである
最初の反復でその、

1185
00:49:40,060 --> 00:49:43,360
我々は、比較、通過
これらはtwo--ので、それが1だ。

1186
00:49:43,360 --> 00:49:46,685
これらの二つ、三つ、四つ。

1187
00:49:46,685 --> 00:49:48,070

1188
00:49:48,070 --> 00:49:55,050
だから、1反復後、私たち
すでに4比較を持っている。

1189
00:49:55,050 --> 00:49:58,230
私は、ランタイムとnについて話しているとき。

1190
00:49:58,230 --> 00:50:04,680
Nは、比較の回数を表す
どのように多くの要素の関数として

1191
00:50:04,680 --> 00:50:05,570
私たちは持っている。

1192
00:50:05,570 --> 00:50:06,430
OK？

1193
00:50:06,430 --> 00:50:08,860
>> だから我々は、我々は4を持って、通過。

1194
00:50:08,860 --> 00:50:11,780
あなたが知っている次の時間、私たちにはありません
このの世話をしなければならない。

1195
00:50:11,780 --> 00:50:15,140
我々は、これら2つを比較し、
これら二つは、これらの2つ、

1196
00:50:15,140 --> 00:50:20,050
そして我々はその最適化を持っていなかった場合は、
私が書いた4ループと、

1197
00:50:20,050 --> 00:50:22,750
あなたはとにかく、ここで比較されることになる。

1198
00:50:22,750 --> 00:50:26,170
だから、しなければならない
アレイを介して実行

1199
00:50:26,170 --> 00:50:34,380
n個の比較のnを作る
回、毎回私たちのため

1200
00:50:34,380 --> 00:50:36,670
それを介して実行するソート一つのことを私たち。

1201
00:50:36,670 --> 00:50:38,300

1202
00:50:38,300 --> 00:50:41,475
>> そして、我々はを介して実行するたびに
アレイは、我々は、n個の比較を行う。

1203
00:50:41,475 --> 00:50:42,920

1204
00:50:42,920 --> 00:50:46,330
したがって、このための私たちのランタイムがある
実際にnの二乗いる

1205
00:50:46,330 --> 00:50:48,400
私たちの中でずっと悪いです
そのため、最後のログ

1206
00:50:48,400 --> 00:50:51,965
我々は4を持っていた場合には意味
億の要素、それはだ

1207
00:50:51,965 --> 00:50:55,260
私たちに40億を取るつもり
代わりに32の二乗。

1208
00:50:55,260 --> 00:51:01,240
そうではない最高のランタイム、
しかし、いくつかのもののために、

1209
00:51:01,240 --> 00:51:04,610
あなたが以内なら、あなたが知っている、
要素の特定の範囲

1210
00:51:04,610 --> 00:51:06,540
バブルソートを使用するの罰金かもしれません。

1211
00:51:06,540 --> 00:51:07,530
>> [OK]をクリックします。

1212
00:51:07,530 --> 00:51:12,290
だから今最良の場合ランタイムは何ですか？

1213
00:51:12,290 --> 00:51:14,357

1214
00:51:14,357 --> 00:51:14,940
学生：ゼロ？

1215
00:51:14,940 --> 00:51:16,420
または1？

1216
00:51:16,420 --> 00:51:18,140
>> 講師：だから1になる
つの比較も。

1217
00:51:18,140 --> 00:51:19,114
右。

1218
00:51:19,114 --> 00:51:20,002
>> 学生：Nマイナス1？

1219
00:51:20,002 --> 00:51:21,380

1220
00:51:21,380 --> 00:51:22,320
>> 講師：だから、ええ。

1221
00:51:22,320 --> 00:51:22,990
だから、nはマイナス1。

1222
00:51:22,990 --> 00:51:26,510
あなたは、nのようなコンセプトを持っているときはいつでも
マイナス1、我々はそれをオフにドロップする傾向がある

1223
00:51:26,510 --> 00:51:31,680
そして我々はちょうどあなたが持っているので、nの言う
these--各対のそれぞれを比較する。

1224
00:51:31,680 --> 00:51:36,470
だから、1 nとマイナスであろう、私たち
私達はちょうど約nであると思います。

1225
00:51:36,470 --> 00:51:39,280
あなたは、ランタイムを扱っている場合には、
すべてがに近似している。

1226
00:51:39,280 --> 00:51:43,860
限り指数であるので
正しい、あなたはかなり良いよ。

1227
00:51:43,860 --> 00:51:45,700
>> それは我々がそれに対処方法を説明します。

1228
00:51:45,700 --> 00:51:47,410

1229
00:51:47,410 --> 00:51:51,780
最良のケースでは、nはあるように
リストが既にソートされていることを意味し、

1230
00:51:51,780 --> 00:51:54,320
そして我々が行うすべてを介して実行されている
それはソートだことを確認してください。

1231
00:51:54,320 --> 00:51:56,110

1232
00:51:56,110 --> 00:51:56,855
涼しい。

1233
00:51:56,855 --> 00:51:57,355
わかりました。

1234
00:51:57,355 --> 00:51:58,980

1235
00:51:58,980 --> 00:52:01,920
私たちは、ここで見るように
ただ、いくつかの複数のグラフを持っている。

1236
00:52:01,920 --> 00:52:02,660
だから、nの二乗。

1237
00:52:02,660 --> 00:52:03,780

1238
00:52:03,780 --> 00:52:05,120
楽しい。

1239
00:52:05,120 --> 00:52:09,730
我々が見るように、nよりもはるかに悪化し、そして
ログ2n個よりもはるかに、はるかに悪い。

1240
00:52:09,730 --> 00:52:12,060
そして、あなたはまた、ログのログに入る。

1241
00:52:12,060 --> 00:52:18,020
そして、あなたは124を取る、あなたが入る
狂ったようになっているログの星、などである。

1242
00:52:18,020 --> 00:52:20,172
だから、もし興味があるなら、
ルックアップログスター。

1243
00:52:20,172 --> 00:52:20,880
それは楽しみのようなものだ。

1244
00:52:20,880 --> 00:52:22,800

1245
00:52:22,800 --> 00:52:24,220
だから我々はこの偉大なチャートを持っている。

1246
00:52:24,220 --> 00:52:25,360

1247
00:52:25,360 --> 00:52:28,720
ちょうどヘッドアップ、このA
持っている素晴らしいチャート

1248
00:52:28,720 --> 00:52:31,350
あなたの中期のための私たちのため
あなたにこれらの薄くなりを聞いて長い。

1249
00:52:31,350 --> 00:52:36,090
だから頭までは、上でこれを持っているあなたの
あなたの素敵なチートシート上中期

1250
00:52:36,090 --> 00:52:36,616
そこに。

1251
00:52:36,616 --> 00:52:37,990
だから我々はちょうどバブルソートを見ました。

1252
00:52:37,990 --> 00:52:39,510

1253
00:52:39,510 --> 00:52:42,370
最悪の場合、N N、最良の場合の二乗。

1254
00:52:42,370 --> 00:52:43,367

1255
00:52:43,367 --> 00:52:44,950
そして、我々は他の人を見てするつもりだ。

1256
00:52:44,950 --> 00:52:47,940
>> そして、あなたが見ることができるように、唯一の
本当によくないもの

1257
00:52:47,940 --> 00:52:50,910
私たちは、なぜに買ってあげるマージソートです。

1258
00:52:50,910 --> 00:52:52,690

1259
00:52:52,690 --> 00:52:55,215
だから我々はに行くつもりだ
次の1 here--選択ソート。

1260
00:52:55,215 --> 00:52:56,360

1261
00:52:56,360 --> 00:52:58,420
誰もがどのように覚えていますか
選択はソート働いた？

1262
00:52:58,420 --> 00:53:05,200

1263
00:53:05,200 --> 00:53:05,700
それのために行く。

1264
00:53:05,700 --> 00:53:08,210
>> 学生：基本的に通過する
秩序と新しいリストを作成。

1265
00:53:08,210 --> 00:53:11,001
そして、あなたは要素を入れているのと同様に
で、適切な場所にそれらを置く

1266
00:53:11,001 --> 00:53:11,750
新しいリストで。

1267
00:53:11,750 --> 00:53:14,040
>> 講師：音になるよう
挿入ソートのようなより。

1268
00:53:14,040 --> 00:53:15,040
しかし、あなたは本当に近くだ。

1269
00:53:15,040 --> 00:53:15,915
彼らは非常によく似ている。

1270
00:53:15,915 --> 00:53:17,440
でも、私は彼らが時々混同取得。

1271
00:53:17,440 --> 00:53:18,981
このセクションの前に私は待つ、のようだった。

1272
00:53:18,981 --> 00:53:20,130

1273
00:53:20,130 --> 00:53:20,630
[OK]をクリックします。

1274
00:53:20,630 --> 00:53:24,141
だから、あなたがしたいもの
やる選択ソートされ、

1275
00:53:24,141 --> 00:53:25,890
あなたが考えることができる方法
それと方法に関する

1276
00:53:25,890 --> 00:53:30,140
私は私が取得しないようにしようことを確認してください
彼らはそれが通過され、混同

1277
00:53:30,140 --> 00:53:33,280
それは選択
最小数とそれ

1278
00:53:33,280 --> 00:53:36,070
あなたのリストの先頭にそれを置きます。

1279
00:53:36,070 --> 00:53:37,730
それは、その最初のスポットでそれを交換します。

1280
00:53:37,730 --> 00:53:42,600

1281
00:53:42,600 --> 00:53:45,370
彼らは実際に私のための例があります。

1282
00:53:45,370 --> 00:53:46,540
恐ろしい。

1283
00:53:46,540 --> 00:53:50,130
it--選択について考えるのでちょうど方法
ソート、最小の値を選択します。

1284
00:53:50,130 --> 00:53:51,940
そして、我々はするつもりだ
例を介して実行

1285
00:53:51,940 --> 00:53:55,320
私がいるために役立つと思うこと
私はビジュアルは常に助けと思います。

1286
00:53:55,320 --> 00:53:58,510
だから我々は何かから始める
それは完全にソートされていないです。

1287
00:53:58,510 --> 00:54:00,730
赤は、ソートされていないとなります
緑がソートされます。

1288
00:54:00,730 --> 00:54:02,190
それはすべて秒で意味をなすでしょう。

1289
00:54:02,190 --> 00:54:08,950
>> だから我々は通過し、我々は反復処理
最初から最後まで。

1290
00:54:08,950 --> 00:54:12,320
そして、我々はOK、2は、言う
私たちの最小数。

1291
00:54:12,320 --> 00:54:15,680
だから我々は2を取るつもりだと我々はつもりだ
私たちのアレイの前面に移動します

1292
00:54:15,680 --> 00:54:17,734
それはだから
私たちが持っている最小数。

1293
00:54:17,734 --> 00:54:19,150
だから、これはここでやっているものだ。

1294
00:54:19,150 --> 00:54:20,820
それはちょうど二人を入れ替えるために起こっている。

1295
00:54:20,820 --> 00:54:21,850

1296
00:54:21,850 --> 00:54:25,450
だから今我々は、ソートしている
パートとソートされていない部分。

1297
00:54:25,450 --> 00:54:27,810
と覚えているのは良いものだ
選択ソート約

1298
00:54:27,810 --> 00:54:30,690
我々は唯一の選択しているある
ソートされていない部分から。

1299
00:54:30,690 --> 00:54:32,220

1300
00:54:32,220 --> 00:54:34,527
>> ソートされた部分は、あなただけの一人で去る。

1301
00:54:34,527 --> 00:54:35,660
MM-HM？

1302
00:54:35,660 --> 00:54:38,452
>> 学生：どのようにそれが何であるか知っている
それを比較することなく、最小の

1303
00:54:38,452 --> 00:54:39,868
アレイ内のすべての他の値に設定します。

1304
00:54:39,868 --> 00:54:41,250
講師：それは、それを比較しない。

1305
00:54:41,250 --> 00:54:42,041
我々はそれをスキップしたい。

1306
00:54:42,041 --> 00:54:43,850
これにより、全体単に一般的である。

1307
00:54:43,850 --> 00:54:44,831
うん。

1308
00:54:44,831 --> 00:54:47,205
我々は、私はコードを記述する場合
あなたがより満足だろうと確信して。

1309
00:54:47,205 --> 00:54:48,696

1310
00:54:48,696 --> 00:54:53,030
しかし、あなたが最初にこれを保存する
最小の要素として。

1311
00:54:53,030 --> 00:54:56,110
あなたが比較します
[OK]を、それは小さい、と言う？

1312
00:54:56,110 --> 00:54:56,660
はい。

1313
00:54:56,660 --> 00:54:57,460
それを維持する。

1314
00:54:57,460 --> 00:54:58,640
ここでは、小さくなっている？

1315
00:54:58,640 --> 00:54:59,660
いいえ？

1316
00:54:59,660 --> 00:55:02,510
>> これは、あなたの最も小さい
あなたの値に再割り当てします。

1317
00:55:02,510 --> 00:55:06,340
そして、あなたは非常に幸せになるでしょう
私たちはコードを行くとき。

1318
00:55:06,340 --> 00:55:07,510

1319
00:55:07,510 --> 00:55:13,970
だから我々はそのように、その後、我々はそれを交換し、通過する
我々は、このソートされていない部分を見てください。

1320
00:55:13,970 --> 00:55:15,810
だから我々は3アウトを選択するつもりだ。

1321
00:55:15,810 --> 00:55:18,890
私たちは、でそれを上に置くつもりだ
私たちのソートされた部分の端。

1322
00:55:18,890 --> 00:55:20,267

1323
00:55:20,267 --> 00:55:23,100
そして、私たちはただやり続けるつもりだ
それは、それをやって、それをやって。

1324
00:55:23,100 --> 00:55:24,130

1325
00:55:24,130 --> 00:55:27,420
だから、これはここでの擬似コードの私たちのようなものです。

1326
00:55:27,420 --> 00:55:29,470

1327
00:55:29,470 --> 00:55:31,380
私たちは、第二に、ここでそれをコーディングします。

1328
00:55:31,380 --> 00:55:34,140

1329
00:55:34,140 --> 00:55:37,270
しかし、単に何かが歩く
高レベルの貫通。

1330
00:55:37,270 --> 00:55:40,275
あなたがから行くつもりです
iが0に等しいnはマイナス2。

1331
00:55:40,275 --> 00:55:41,570

1332
00:55:41,570 --> 00:55:43,530
それはまた別の最適化だ。

1333
00:55:43,530 --> 00:55:45,020
それについてはあまり心配しないでください。

1334
00:55:45,020 --> 00:55:46,620
ようにあなたが言っていた。

1335
00:55:46,620 --> 00:55:49,660

1336
00:55:49,660 --> 00:55:54,406
ヤコブは言っていたように、どのように我々を行う
我々の最小値が何であるかを追跡する？

1337
00:55:54,406 --> 00:55:55,030
どのように我々は知っているのですか？

1338
00:55:55,030 --> 00:55:57,060
私たちは、比較する必要が
私たちのリストのすべて。

1339
00:55:57,060 --> 00:55:59,600
>> だから最小のiに等しい。

1340
00:55:59,600 --> 00:56:03,870
それはちょうど、この場合に言っている
私たちの最小値のインデックス。

1341
00:56:03,870 --> 00:56:07,660
だから、それはを反復処理するだろう
jはiのプラス1に等しいから、それは行く。

1342
00:56:07,660 --> 00:56:11,420
だから我々はすでに知っている
それが私たちの最初の要素です。

1343
00:56:11,420 --> 00:56:13,240
私たちは自分自身にそれを比較する必要はありません。

1344
00:56:13,240 --> 00:56:16,970
だから私たちは次のと比較することを開始
それはnまでのiプラス1である理由である1

1345
00:56:16,970 --> 00:56:20,110
マイナス1、
そこ配列の末尾。

1346
00:56:20,110 --> 00:56:25,090
そして、我々は、アレイであれば言った
jは、配列minより小さい

1347
00:56:25,090 --> 00:56:29,200
その後、我々はどこに再割り当て
我々の最小のインデックスである。

1348
00:56:29,200 --> 00:56:37,470
>> そして分として、私に等しくない場合
ここで、我々はここに戻って終わった。

1349
00:56:37,470 --> 00:56:38,950

1350
00:56:38,950 --> 00:56:41,790
私たちは最初にこの1をやったときに好き。

1351
00:56:41,790 --> 00:56:49,310
この場合には、で開始する
ゼロ、それが2になってしまうだろう。

1352
00:56:49,310 --> 00:56:53,010
だから、minは最後に、私と等しくないであろう。

1353
00:56:53,010 --> 00:56:55,720
つまり、私たちがそれを知ることができます
私たちはそれらを交換する必要があります。

1354
00:56:55,720 --> 00:56:57,420

1355
00:56:57,420 --> 00:57:00,470
私は具体的な例のように感じる
これよりはるかに役立ちます。

1356
00:57:00,470 --> 00:57:04,970
だから私はあなたたちにこれをコーディングします
今、私はそれが良くなると思う。

1357
00:57:04,970 --> 00:57:07,380

1358
00:57:07,380 --> 00:57:11,350
>> ソートは、その中でそのように動作する傾向があり
それはちょうどそれらを見るために、多くの場合、良いでしょう。

1359
00:57:11,350 --> 00:57:12,780

1360
00:57:12,780 --> 00:57:17,280
だから我々が何をしたいです
我々は最初の最小たい

1361
00:57:17,280 --> 00:57:19,890
配列内のその位置にある要素。

1362
00:57:19,890 --> 00:57:21,280
まさにヤコブは言っていた。

1363
00:57:21,280 --> 00:57:23,090
あなたは何とかそれを格納する必要があります。

1364
00:57:23,090 --> 00:57:25,900
だから我々はここに開始するつもりだ
配列を反復。

1365
00:57:25,900 --> 00:57:28,970
私たちは、それが私たちだと言うつもりだ
ちょうどで始まる最初の1。

1366
00:57:28,970 --> 00:57:38,308
だから我々はint型を持っているつもりされている
最小のiにおける配列に等しい。

1367
00:57:38,308 --> 00:57:40,500

1368
00:57:40,500 --> 00:57:45,050
>> だから、一つのことは、すべてのに気づくこと
このループの実行時間、

1369
00:57:45,050 --> 00:57:48,550
私たちは一緒にさらに一歩始めている。

1370
00:57:48,550 --> 00:57:54,780

1371
00:57:54,780 --> 00:57:57,440
我々は起動すると、私たちはこの1つを見てください。

1372
00:57:57,440 --> 00:58:00,840
私たちは反復処理次回、
私たちはこの1つで開始している

1373
00:58:00,840 --> 00:58:02,680
それに私たちの最も小さい値を割り当てる。

1374
00:58:02,680 --> 00:58:10,450
だから、バブルソートと非常に似ています
我々はその1パスの後知っている場合には、

1375
00:58:10,450 --> 00:58:11,700
この最後の要素はソートされます。

1376
00:58:11,700 --> 00:58:12,810

1377
00:58:12,810 --> 00:58:15,120
選択ソートと、
それはちょうど反対だ。

1378
00:58:15,120 --> 00:58:18,950
>> すべてのパスでは、我々は知っている
一つ目はソートされます。

1379
00:58:18,950 --> 00:58:21,360
第二のパスの後、
もう一つはソートされます。

1380
00:58:21,360 --> 00:58:26,470
そして、あなたはスライドの例で見たように、
私たちのソート部分はちょうど成長続けている。

1381
00:58:26,470 --> 00:58:34,020
だから私たちの最も小さい1を設定することにより、
アレイに私は、すべてがそれがやっている

1382
00:58:34,020 --> 00:58:37,340
何を収縮さ
我々としてそう見ている

1383
00:58:37,340 --> 00:58:40,164
数を最小限にする
比較の我々は作る。

1384
00:58:40,164 --> 00:58:41,770
それは皆に意味があるか？

1385
00:58:41,770 --> 00:58:42,920

1386
00:58:42,920 --> 00:58:46,380
あなたは私がそれを介して実行する必要がありますか
再び遅い、または別の言葉で？

1387
00:58:46,380 --> 00:58:47,180
私はうれしいです。

1388
00:58:47,180 --> 00:58:48,095

1389
00:58:48,095 --> 00:58:48,595
[OK]をクリックします。

1390
00:58:48,595 --> 00:58:50,060

1391
00:58:50,060 --> 00:58:55,540
>> だから私たちは保存している
この時点での値、

1392
00:58:55,540 --> 00:58:57,840
我々はまた、インデックスを格納したいと思います。

1393
00:58:57,840 --> 00:59:01,010
だから私たちは保存するつもりだ
最小の位置

1394
00:59:01,010 --> 00:59:02,770
ちょうど私であることを行っている1。

1395
00:59:02,770 --> 00:59:04,357

1396
00:59:04,357 --> 00:59:05,440
だから今ヤコブは満足している。

1397
00:59:05,440 --> 00:59:06,870
私たちは、格納されているものを持っている。

1398
00:59:06,870 --> 00:59:08,240

1399
00:59:08,240 --> 00:59:11,870
そして今、我々は目を通す必要がある
配列のソートされていない部分。

1400
00:59:11,870 --> 00:59:18,170
この場合には、このそう
私たちのソートされていないだろう。

1401
00:59:18,170 --> 00:59:20,980

1402
00:59:20,980 --> 00:59:22,462
これが私です。

1403
00:59:22,462 --> 00:59:25,430

1404
00:59:25,430 --> 00:59:26,210
[OK]をクリックします。

1405
00:59:26,210 --> 00:59:30,040
>> だから、私たちがやろうとしている
forループになるだろう。

1406
00:59:30,040 --> 00:59:32,066
あなたがする必要がある場合は、必ず
配列を反復処理、

1407
00:59:32,066 --> 00:59:33,440
あなたの心には、forループに行くことができます。

1408
00:59:33,440 --> 00:59:34,760

1409
00:59:34,760 --> 00:59:38,090
いくつかのint kについてそう
私たちは何を思いますかequals--

1410
00:59:38,090 --> 00:59:39,700
kは、で開始することに等しくなるように起こっている？

1411
00:59:39,700 --> 00:59:41,580

1412
00:59:41,580 --> 00:59:44,766
これは私達が私達の最も小さいとして設定したものである
値、我々はそれを比較したい。

1413
00:59:44,766 --> 00:59:47,090
私たちは、それを比較するために何をしたいですか？

1414
00:59:47,090 --> 00:59:48,730
それは右、この次の1になるだろう？

1415
00:59:48,730 --> 00:59:53,200
だから我々は、kが初期化されたい
私はプラス1開始するまで。

1416
00:59:53,200 --> 00:59:55,350

1417
00:59:55,350 --> 01:00:02,800
>> そして、我々は、この場合におけるKたい私たち
すでにサイズがここに保存されている、

1418
01:00:02,800 --> 01:00:03,930
私たちは単にサイズを使用することができます。

1419
01:00:03,930 --> 01:00:06,240
サイズは、アレイのサイズである。

1420
01:00:06,240 --> 01:00:09,620
そして、私たちはちょうどしたい
1ずつのkを更新します。

1421
01:00:09,620 --> 01:00:17,410

1422
01:00:17,410 --> 01:00:17,910
涼しい。

1423
01:00:17,910 --> 01:00:19,650

1424
01:00:19,650 --> 01:00:23,430
だから今我々は見つける必要がある
ここで最小の要素。

1425
01:00:23,430 --> 01:00:24,470

1426
01:00:24,470 --> 01:00:31,380
だから我々は繰り返し処理をした場合、私たちは
kで配列した場合、言いたい

1427
01:00:31,380 --> 01:00:37,080
私たちの最も小さいvalue--より小さい
私たちが実際にいる場所です

1428
01:00:37,080 --> 01:00:42,950
何を追跡する
最小here--

1429
01:00:42,950 --> 01:00:47,740
その後、我々は再割り当てしたい
私たちの最小値は何ですか。

1430
01:00:47,740 --> 01:00:50,645
>> これはああ、私たちはしている、ことを意味します
ここを反復処理する。

1431
01:00:50,645 --> 01:00:51,699

1432
01:00:51,699 --> 01:00:53,740
どのような値がここにある
ではない私たちの最も小さいもの。

1433
01:00:53,740 --> 01:00:54,448
我々はそれをしたくない。

1434
01:00:54,448 --> 01:00:56,100
我々はそれを再割り当てしたいと思います。

1435
01:00:56,100 --> 01:01:02,050
だから、我々はそれを再割り当てしている場合、何をすべきか
あなたはここで、このコードにあるかもしれないと思いますか？

1436
01:01:02,050 --> 01:01:04,160
私たちは再割り当てしたい
最小の位置。

1437
01:01:04,160 --> 01:01:05,740

1438
01:01:05,740 --> 01:01:07,010
だから今最も小さい何ですか？

1439
01:01:07,010 --> 01:01:08,422

1440
01:01:08,422 --> 01:01:09,130
学生：配列​​のk。

1441
01:01:09,130 --> 01:01:09,963
講師：配列のk。

1442
01:01:09,963 --> 01:01:13,480

1443
01:01:13,480 --> 01:01:15,956
そして位置は今何ですか？

1444
01:01:15,956 --> 01:01:20,940

1445
01:01:20,940 --> 01:01:23,000
のインデックス何ですか
私たちの最小値はありますか？

1446
01:01:23,000 --> 01:01:24,030

1447
01:01:24,030 --> 01:01:24,530
それはちょうどKです。

1448
01:01:24,530 --> 01:01:25,690

1449
01:01:25,690 --> 01:01:27,790
そのように配列kは、kは、それらが一致。

1450
01:01:27,790 --> 01:01:31,670

1451
01:01:31,670 --> 01:01:33,120
だから我々はそれを再割り当てしたかった。

1452
01:01:33,120 --> 01:01:34,390

1453
01:01:34,390 --> 01:01:39,950
その後の後に私たちは最小のを見つけ、
forループこれの終わりにそう

1454
01:01:39,950 --> 01:01:45,100
ここでは、発見した何を私たちの最も小さい
値があるので、我々はそれを交換します。

1455
01:01:45,100 --> 01:01:47,100

1456
01:01:47,100 --> 01:01:50,816
この場合、私たちのようなと言う
最小値はここにある。

1457
01:01:50,816 --> 01:01:51,940
これが私たちの最も小さい値です。

1458
01:01:51,940 --> 01:01:57,690
>> 私達はちょうどである、ここでそれを入れ替えたい
一番下にどのようなことをスワップ機能

1459
01:01:57,690 --> 01:02:01,270
私たちはちょうど書いた、やった
一緒にカップル分前。

1460
01:02:01,270 --> 01:02:02,775
だから、おなじみのはずです。

1461
01:02:02,775 --> 01:02:04,320

1462
01:02:04,320 --> 01:02:08,030
そしてそれは単に反復処理します
それはすべての方法に至るまでを通して

1463
01:02:08,030 --> 01:02:13,100
あなたことを意味して終わり、に
ソートされていないゼロ要素を持っている

1464
01:02:13,100 --> 01:02:14,800
そして他のすべてがソートされている。

1465
01:02:14,800 --> 01:02:16,216

1466
01:02:16,216 --> 01:02:16,715
理にかなって？

1467
01:02:16,715 --> 01:02:18,010

1468
01:02:18,010 --> 01:02:19,280
もう少し具体的に？

1469
01:02:19,280 --> 01:02:19,990
コー​​ドのヘルプ？

1470
01:02:19,990 --> 01:02:21,720

1471
01:02:21,720 --> 01:02:26,410
>> 学生：サイズの場合、あなたは決して
実際にそれを定義したり、それを変更し、

1472
01:02:26,410 --> 01:02:27,340
それはどのように知っているのですか？

1473
01:02:27,340 --> 01:02:32,380
>> 講師：だから、一つのことに
int型のサイズは、ここまでに気づく。

1474
01:02:32,380 --> 01:02:35,680
だから我々はこのsort--ソートで言っている
この関数は、それがだcase--さ

1475
01:02:35,680 --> 01:02:40,770
選択ソート、それが渡された
機能付きで。

1476
01:02:40,770 --> 01:02:43,460
だからそれが渡されなかった場合
で、あなたが何かをするだろう

1477
01:02:43,460 --> 01:02:47,840
配列の長さを持つように
またはあなたが反復処理だろう

1478
01:02:47,840 --> 01:02:49,390
長さを見つけるために。

1479
01:02:49,390 --> 01:02:52,680
しかし、それは渡されたので、
で、私たちはそれを使用することができます。

1480
01:02:52,680 --> 01:02:55,720
あなただけのユーザーことを前提としてい
あなたに有効なサイズを与えたこと

1481
01:02:55,720 --> 01:02:57,698
実際に表している
あなたの配列のサイズ。

1482
01:02:57,698 --> 01:02:59,461

1483
01:02:59,461 --> 01:02:59,960
クール？

1484
01:02:59,960 --> 01:03:01,610

1485
01:03:01,610 --> 01:03:05,870
>> 君たちは、これらを持つ任意の問題が発生した場合
以上の練習コーディングのソートをしたい

1486
01:03:05,870 --> 01:03:08,050
自分で、あなたがすべき
study.cs50に行く。

1487
01:03:08,050 --> 01:03:11,560

1488
01:03:11,560 --> 01:03:12,670
それはツールだ。

1489
01:03:12,670 --> 01:03:15,040
彼らはチェッカーを持っている
あなたが実際に書くことができます。

1490
01:03:15,040 --> 01:03:16,180
彼らは、擬似コードを実行します。

1491
01:03:16,180 --> 01:03:19,310
彼らはより多くのビデオやスライドを持っている
私がここで使うものも含めて。

1492
01:03:19,310 --> 01:03:23,150
あなたはまだ感じているのであれば
少しファジー、それを試してみてください。

1493
01:03:23,150 --> 01:03:25,670
いつものように、あまりにも、私に話してくる。

1494
01:03:25,670 --> 01:03:26,320
質問？

1495
01:03:26,320 --> 01:03:28,611
>> 学生：あなたが言っている
サイズは、以前に定義されている？

1496
01:03:28,611 --> 01:03:29,234

1497
01:03:29,234 --> 01:03:29,900
講師：はい。

1498
01:03:29,900 --> 01:03:35,570
サイズは以前に定義されている
ここでは関数宣言で。

1499
01:03:35,570 --> 01:03:39,060
だから、それが渡されていますことを前提としてい
ユーザーによる、および簡略化のため、

1500
01:03:39,060 --> 01:03:41,896
私たちはと仮定するつもりだ
ユーザーは、私たちに正しいサイズを与えた。

1501
01:03:41,896 --> 01:03:43,240
涼しい。

1502
01:03:43,240 --> 01:03:44,390
だから選択ソートです。

1503
01:03:44,390 --> 01:03:45,590

1504
01:03:45,590 --> 01:03:47,640
Guysは、私たちは、今日多くのことを学習している知っている。

1505
01:03:47,640 --> 01:03:49,710
これは、セクションの密集したデータです。

1506
01:03:49,710 --> 01:03:51,880

1507
01:03:51,880 --> 01:03:57,340
それとだから、私たちは行く
挿入ソートに移動します。

1508
01:03:57,340 --> 01:04:01,550

1509
01:04:01,550 --> 01:04:02,510
>> [OK]をクリックします。

1510
01:04:02,510 --> 01:04:06,100
だから、その前に私たちはしなければならない
ここに私たちのランタイム分析。

1511
01:04:06,100 --> 01:04:10,190
だから、最良のケースでは、
私がお見せした以降に付与された

1512
01:04:10,190 --> 01:04:11,960
テーブルすでに私
種類のそれを譲った。

1513
01:04:11,960 --> 01:04:15,430
しかし、最良の場合ランタイムは、私たちは何を思いますか？

1514
01:04:15,430 --> 01:04:17,310

1515
01:04:17,310 --> 01:04:18,130
すべてがソート。

1516
01:04:18,130 --> 01:04:21,040

1517
01:04:21,040 --> 01:04:22,070
Nは二乗。

1518
01:04:22,070 --> 01:04:24,780
誰でも説明してい
あなたが考える理由のために？

1519
01:04:24,780 --> 01:04:29,060

1520
01:04:29,060 --> 01:04:30,519
>> 学生：あなたはthrough--比較している

1521
01:04:30,519 --> 01:04:31,268
講師：右。

1522
01:04:31,268 --> 01:04:32,540
あなたはを通して比較している。

1523
01:04:32,540 --> 01:04:35,630
にもかかわらず、すべての反復で
私たちは、1によって、これをデクリメントしている

1524
01:04:35,630 --> 01:04:38,950
あなたはまだを通して検索している
最も小さいものを見つけるためにすべて。

1525
01:04:38,950 --> 01:04:42,390
だから、たとえあなたの最小値
初めにここにある、

1526
01:04:42,390 --> 01:04:44,710
あなたはまだそれを比較している
他のすべてに対して

1527
01:04:44,710 --> 01:04:46,550
それは最も小さいことだことを確認します。

1528
01:04:46,550 --> 01:04:49,820
だから、通る終わるだろう
約n倍の二乗。

1529
01:04:49,820 --> 01:04:51,090

1530
01:04:51,090 --> 01:04:51,590
わかりました。

1531
01:04:51,590 --> 01:04:52,785
最悪の場合は何ですか？

1532
01:04:52,785 --> 01:04:54,350

1533
01:04:54,350 --> 01:04:57,980
あなたが行っているので、また、n個の二乗
その同じ手順をやっている。

1534
01:04:57,980 --> 01:05:01,670
したがって、この場合には、選択
ソート何かを持っている

1535
01:05:01,670 --> 01:05:04,010
我々はまた、予想されるランタイム呼び出すことを。

1536
01:05:04,010 --> 01:05:07,400
だから、他の人に、私たちは知っている
上限と下限。

1537
01:05:07,400 --> 01:05:11,180
どのように狂気に応じて、私たちの
リストであるか、それがどのようにソートされていない、

1538
01:05:11,180 --> 01:05:15,350
彼らは、nまたはn乗の間で変化する。

1539
01:05:15,350 --> 01:05:16,550
私たちは知りません。

1540
01:05:16,550 --> 01:05:22,820
>> しかし、選択ソートは、同じを持っているので
ことを教えてくれる最悪と最良の場合、

1541
01:05:22,820 --> 01:05:25,880
入力に関係なくどのようなタイプの、我々
それが完全だかどうか、持っている

1542
01:05:25,880 --> 01:05:29,130
ソートまたは完全に
それはだ、ソートされたリバース

1543
01:05:29,130 --> 01:05:30,740
同じ時間がかかるだろう。

1544
01:05:30,740 --> 01:05:33,760
その場合だから、あなたの場合
私たちのテーブルから覚えている、

1545
01:05:33,760 --> 01:05:38,610
実際には、その値を持っていた
これら二つのソートは、持っていない

1546
01:05:38,610 --> 01:05:40,390
そのランタイムが期待されている。

1547
01:05:40,390 --> 01:05:43,350
だから我々はいつでもことを知っている
我々は選択ソートを実行し、

1548
01:05:43,350 --> 01:05:45,380
それがに保証さだ
nの二乗の時間を実行します。

1549
01:05:45,380 --> 01:05:46,630
そこにはばらつきがありません。

1550
01:05:46,630 --> 01:05:47,630
それは、単に期待だ。

1551
01:05:47,630 --> 01:05:48,820

1552
01:05:48,820 --> 01:05:52,140
そして、再び、あなたが知りたい場合は
より、春のCS 124を取る。

1553
01:05:52,140 --> 01:05:55,370

1554
01:05:55,370 --> 01:05:56,712
わかりました。

1555
01:05:56,712 --> 01:05:57,545
私たちはこの1つを見てきました。

1556
01:05:57,545 --> 01:05:58,530

1557
01:05:58,530 --> 01:05:59,030
涼しい。

1558
01:05:59,030 --> 01:06:00,930
だから、挿入ソート。

1559
01:06:00,930 --> 01:06:03,330
そして私はおそらくつもりです
このを通じて燃え盛る。

1560
01:06:03,330 --> 01:06:05,440
私はあなたたちはそれをコーディングしていません。

1561
01:06:05,440 --> 01:06:06,580
私達はちょうどそれを歩くだろう。

1562
01:06:06,580 --> 01:06:10,500
だから、挿入ソートは、一種である
選択ソートと同様の

1563
01:06:10,500 --> 01:06:14,460
その中で、我々は両方のソートされていないを持っている
とアレイの一部を選別した。

1564
01:06:14,460 --> 01:06:20,260
>> しかし、何が異なるのは、ということです
私たちは一つ一つを通過として、

1565
01:06:20,260 --> 01:06:24,210
私達はちょうど何でも数を取る
私たちのソートされていない中で隣にあり、

1566
01:06:24,210 --> 01:06:28,507
そしてそれを正しく並べ替える
私たちのソートされた配列に変換する。

1567
01:06:28,507 --> 01:06:30,090
これは、例を挙げてより多くの意味をなすでしょう。

1568
01:06:30,090 --> 01:06:31,140

1569
01:06:31,140 --> 01:06:35,430
だから、すべてがソートされていないとして開始、
ただ選択ソートで好きです。

1570
01:06:35,430 --> 01:06:38,740
そして、我々はこれをソートするつもりだ
我々がされているように昇順。

1571
01:06:38,740 --> 01:06:40,360

1572
01:06:40,360 --> 01:06:43,340
だから私たちの最初のパス上の
我々は最初の値をとる

1573
01:06:43,340 --> 01:06:46,700
私たちは、OK、あなたは、言う
今自分でリストにある。

1574
01:06:46,700 --> 01:06:49,150
>> あなたは、リストにあるため、
自分で、あなたが並べ替えられています。

1575
01:06:49,150 --> 01:06:52,460
であることのためにおめでとう
この配列の最初の要素。

1576
01:06:52,460 --> 01:06:54,800
あなたはすでに自分ですべてをソートしています。

1577
01:06:54,800 --> 01:06:58,900
だから今我々は、ソートしている
そしてソートされていない配列。

1578
01:06:58,900 --> 01:07:01,760
だから今我々は最初を取る。

1579
01:07:01,760 --> 01:07:05,600
ここで何が起こるの間
そして、ここで、私たちが言うことです

1580
01:07:05,600 --> 01:07:08,890
[OK]を、我々は見てするつもりだ
私たちのソートされていない配列の最初の値

1581
01:07:08,890 --> 01:07:13,270
私たちは、その入力にそれを行っている
ソートされた配列内の正しい場所。

1582
01:07:13,270 --> 01:07:21,460
>> だから我々は5を取るされている私たちは何をすべきかと
我々は、[OK]を、5は3よりも大きい、と言う

1583
01:07:21,460 --> 01:07:24,630
私たちはちょうどそれを挿入
その右に。

1584
01:07:24,630 --> 01:07:25,130
我々は良いよ。

1585
01:07:25,130 --> 01:07:26,200

1586
01:07:26,200 --> 01:07:28,420
それでは私たちは次のものに行く。

1587
01:07:28,420 --> 01:07:29,720
そして、我々は2を取る。

1588
01:07:29,720 --> 01:07:34,330
私たちは、[OK]を、2未満である、と言う
3よりも、私たちはそのことを知って

1589
01:07:34,330 --> 01:07:36,220
であることが必要
今私たちのリストの正面。

1590
01:07:36,220 --> 01:07:41,800
それでは私たちは、私たちがダウンして3と5をプッシュです
そして我々はその最初のスロットに2を移動します。

1591
01:07:41,800 --> 01:07:42,990

1592
01:07:42,990 --> 01:07:45,870
だから我々はちょうどに挿入している
それがあるべき正しい場所。

1593
01:07:45,870 --> 01:07:46,960

1594
01:07:46,960 --> 01:07:49,470
>> その後、我々は我々の見
次は、私たちは6と言う。

1595
01:07:49,470 --> 01:07:53,620
[OK]を、図6は、より大きい
私たちのソートされた配列のすべて、

1596
01:07:53,620 --> 01:07:56,000
私たちは終了間際にそれを上のタグ。

1597
01:07:56,000 --> 01:07:56,960
そして、我々は4を見てください。

1598
01:07:56,960 --> 01:07:58,130

1599
01:07:58,130 --> 01:08:03,020
図4は、6未満であり、それは以下の
5よりもそれが3より大きいです。

1600
01:08:03,020 --> 01:08:06,270
だから我々はちょうどに挿入
3と5の間の中間。

1601
01:08:06,270 --> 01:08:07,380

1602
01:08:07,380 --> 01:08:10,530
これほど少ないことを確認する
もう少し具体的な、

1603
01:08:10,530 --> 01:08:12,280
こちらの一種である
何が起こったのかのアイデア。

1604
01:08:12,280 --> 01:08:16,430
各ソートされていない要素についてだから、私たち
どこでソートされた部分で決定

1605
01:08:16,430 --> 01:08:17,090
それは。

1606
01:08:17,090 --> 01:08:20,680
>> だから、念頭に置いて
ソートされ、ソートされていない、

1607
01:08:20,680 --> 01:08:26,080
我々はを通して横断する必要があり、図
それはソートされた配列に収まり場所を。

1608
01:08:26,080 --> 01:08:31,460
そして、我々はシフトすることによって、それを挿入
その右側にダウン要素。

1609
01:08:31,460 --> 01:08:34,910
そして、我々はちょうど続ける
私たちまでを反復

1610
01:08:34,910 --> 01:08:39,270
完全にソートされたリストを持っている
今やゼロソートされていないです

1611
01:08:39,270 --> 01:08:41,720
ソートが占め
私たちのリストの全体。

1612
01:08:41,720 --> 01:08:43,146

1613
01:08:43,146 --> 01:08:45,854
だから、再び、さえ物事を作る
より具体的な、我々は擬似コードを持っている。

1614
01:08:45,854 --> 01:08:47,979

1615
01:08:47,979 --> 01:08:52,410
>> そこで、基本的に、私はあるために
nはマイナス1と0に等しい、

1616
01:08:52,410 --> 01:08:54,790
それが私たちの配列の長さだけです。

1617
01:08:54,790 --> 01:09:00,979
私たちは、に等しいいくつかの要素を持っている
最初のアレイまたは最初のインデックス。

1618
01:09:00,979 --> 01:09:03,200
私たちはそれと同等のJを設定します。

1619
01:09:03,200 --> 01:09:04,649

1620
01:09:04,649 --> 01:09:09,210
jはより大きいながらそう
ゼロと配列、Jマイナス1

1621
01:09:09,210 --> 01:09:11,660
より大きい
要素、すべてのようにやっている

1622
01:09:11,660 --> 01:09:17,479
ことを確認している
あなたのjは本当に表し

1623
01:09:17,479 --> 01:09:20,010
配列のソートされていない部分。

1624
01:09:20,010 --> 01:09:30,745
>> だから、物事がまだある一方、
マイナス1を並べ替えるとjすることが何をis--

1625
01:09:30,745 --> 01:09:31,840
要素、彼女は何ですか？

1626
01:09:31,840 --> 01:09:34,760
Jはここで定義されていませんでした。

1627
01:09:34,760 --> 01:09:35,677
それは迷惑なのようなものだ。

1628
01:09:35,677 --> 01:09:36,176
[OK]をクリックします。

1629
01:09:36,176 --> 01:09:36,689
とにかく。

1630
01:09:36,689 --> 01:09:39,899
だからJマイナス1、あなたがチェックしている
その前の要素。

1631
01:09:39,899 --> 01:09:46,460
[OK]をクリックすると、要素であり、言っている
私がみましょうam--どこの前に

1632
01:09:46,460 --> 01:09:47,540
実際にこれを引き出す。

1633
01:09:47,540 --> 01:09:52,580

1634
01:09:52,580 --> 01:09:56,830
それでは、これは言わせて
私たちの第二のパス上のような。

1635
01:09:56,830 --> 01:09:59,525
だから私は同じになるだろう
1に、これはここにある。

1636
01:09:59,525 --> 01:10:03,310

1637
01:10:03,310 --> 01:10:06,025
>> だから私は1に等しいことになるだろう。

1638
01:10:06,025 --> 01:10:09,510

1639
01:10:09,510 --> 01:10:13,702
これは、図2、図4、図5、図6、図7であろう。

1640
01:10:13,702 --> 01:10:16,060

1641
01:10:16,060 --> 01:10:16,750
わかりました。

1642
01:10:16,750 --> 01:10:20,945
この場合はそのように私たちの要素
4に等しくなるだろう。

1643
01:10:20,945 --> 01:10:22,110

1644
01:10:22,110 --> 01:10:24,946
そして、我々はいくつかのJを持っている
1に等しいことになるだろう。

1645
01:10:24,946 --> 01:10:29,770

1646
01:10:29,770 --> 01:10:30,971
ああ、jはデクリメントされる。

1647
01:10:30,971 --> 01:10:31,720
つまり、それが何であるかです。

1648
01:10:31,720 --> 01:10:35,680
だから、jはiのに等しいので、これは何ですか
ことわざは、我々が前進するようにということで、

1649
01:10:35,680 --> 01:10:37,530
我々は念の作っている
我々は終わっていないだということ

1650
01:10:37,530 --> 01:10:43,520
私たちがしようとしている。このようにインデックスを付ける
私たちのソートされたリストに何かを挿入します。

1651
01:10:43,520 --> 01:10:49,850
>> そこでjが、この場合、1に等しいとき
そう配列jのマイナスひとつ選ぶ配列jはマイナス1

1652
01:10:49,850 --> 01:10:54,610
それはだ場合は、このcase--で2です
要素よりも大きく、

1653
01:10:54,610 --> 01:10:57,700
その後、このすべてをやっている
物事をシフトダウンされている。

1654
01:10:57,700 --> 01:11:04,790
この場合、アレイのjから1を引いたので
2である配列ゼロ、であろう。

1655
01:11:04,790 --> 01:11:08,430
図2は、4以下である
これは実行されません。

1656
01:11:08,430 --> 01:11:11,460
だから、シフトは下に移動しません。

1657
01:11:11,460 --> 01:11:18,790
これは、ここで行うことはただです
あなたのソートされた配列を下に移動する。

1658
01:11:18,790 --> 01:11:22,340

1659
01:11:22,340 --> 01:11:26,400
この場合、実際には、我々
do--できたのは、この3を作成してみましょう。

1660
01:11:26,400 --> 01:11:28,080

1661
01:11:28,080 --> 01:11:31,970
だから、私たちが通って歩いているなら
この例では、我々はここで、今だ。

1662
01:11:31,970 --> 01:11:32,740
これがソートされます。

1663
01:11:32,740 --> 01:11:34,492

1664
01:11:34,492 --> 01:11:35,200
これがソートされていないです。

1665
01:11:35,200 --> 01:11:39,090

1666
01:11:39,090 --> 01:11:39,860
クール？

1667
01:11:39,860 --> 01:11:46,620
だから私はそのように、2に等しく、
我々の要素は3に等しい。

1668
01:11:46,620 --> 01:11:47,920

1669
01:11:47,920 --> 01:11:52,270
そして、私たちのjは2に等しい。

1670
01:11:52,270 --> 01:12:00,620
だから我々は我々と目を通す
[OK]を、配列jはマイナス1である、と言う

1671
01:12:00,620 --> 01:12:03,470
要素よりも大きい
我々は見ていることを？

1672
01:12:03,470 --> 01:12:05,540
そして答えは右、yesです？

1673
01:12:05,540 --> 01:12:11,275
図4は、図3およびjよりも大きい
2であるので、このコードが実行されます。

1674
01:12:11,275 --> 01:12:12,510

1675
01:12:12,510 --> 01:12:18,550
>> だから今我々が配列を何
図2は、右ここので、私たちはそれらを交換。

1676
01:12:18,550 --> 01:12:25,620
だから我々はちょうど、[OK]を、配列を言う
2時現在、3になるだろう。

1677
01:12:25,620 --> 01:12:28,130

1678
01:12:28,130 --> 01:12:32,340
jは等しくなるように起こっている
1であるJマイナス1、。

1679
01:12:32,340 --> 01:12:34,590

1680
01:12:34,590 --> 01:12:37,200
それは恐ろしいですが、
あなたたちは、アイデアを得る。

1681
01:12:37,200 --> 01:12:38,360
Jは今1に等しい。

1682
01:12:38,360 --> 01:12:44,360
そして配列jはちょうどになるだろう
4であった私たちの要素に等しい。

1683
01:12:44,360 --> 01:12:45,950

1684
01:12:45,950 --> 01:12:48,570
私はいけない何かを消去
何かを持っているか、miswrote、

1685
01:12:48,570 --> 01:12:49,910
しかし、あなたたちは、アイデアを得る。

1686
01:12:49,910 --> 01:12:50,640
>> それは、nで移動。

1687
01:12:50,640 --> 01:12:51,920

1688
01:12:51,920 --> 01:12:57,960
これがあった場合には、その後、ループだろ
再び、それはOK、jは、今1である、と言うでしょう。

1689
01:12:57,960 --> 01:13:00,665
およびアレイjはマイナス1は今2である。

1690
01:13:00,665 --> 01:13:01,750

1691
01:13:01,750 --> 01:13:03,760
図2は、私たちの要素より小さい？

1692
01:13:03,760 --> 01:13:04,540
いいえ？

1693
01:13:04,540 --> 01:13:07,970
それは我々がしたことを意味します
この要素を挿入する

1694
01:13:07,970 --> 01:13:10,110
私たちのソートされた配列内の正しいスポットで。

1695
01:13:10,110 --> 01:13:14,400
その後、我々はこれを取ることができ、我々は言う、
[OK]を、私たちのソートされた配列はこちらです。

1696
01:13:14,400 --> 01:13:19,940
そして、それはこの数6を取るとなります
のように、[OK]を、この数値より6少ない？

1697
01:13:19,940 --> 01:13:20,480
いいえ？

1698
01:13:20,480 --> 01:13:21,080
涼しい。

1699
01:13:21,080 --> 01:13:22,680
私たちはいいですよ。

1700
01:13:22,680 --> 01:13:23,530
>> 再びそれを行う。

1701
01:13:23,530 --> 01:13:24,740
我々は7を言う。

1702
01:13:24,740 --> 01:13:29,010
端より7少ない
私たちのソートされた配列の？

1703
01:13:29,010 --> 01:13:29,520
いいえ。

1704
01:13:29,520 --> 01:13:30,430
だから我々はいいですよ。

1705
01:13:30,430 --> 01:13:32,760
だから、これはソートされるだろう。

1706
01:13:32,760 --> 01:13:38,610
基本的にすべてこのことを行い
それはテイクを言っているされている

1707
01:13:38,610 --> 01:13:42,060
の最初の要素
あなたのソートされていない配列、

1708
01:13:42,060 --> 01:13:46,010
それがどこに行くかを把握
あなたのソートされた配列中。

1709
01:13:46,010 --> 01:13:48,780
そして、これは単に面倒を見る
そうするスワップの。

1710
01:13:48,780 --> 01:13:51,300
あなたは基本的にスワッピングしている
それは右だったと評価されるまで。

1711
01:13:51,300 --> 01:13:53,600

1712
01:13:53,600 --> 01:13:56,990
視覚的なイメージは、あなたがしているということです
そうすることによって、すべてのものを下に移動する。

1713
01:13:56,990 --> 01:13:59,420
>> だから、ソート風の半分バブルのようなものだ。

1714
01:13:59,420 --> 01:14:02,280

1715
01:14:02,280 --> 01:14:03,420
研究50をチェックしてください。

1716
01:14:03,420 --> 01:14:06,000
私は非常にしようとお勧めします
自分でこれをコードに。

1717
01:14:06,000 --> 01:14:07,220

1718
01:14:07,220 --> 01:14:12,450
あなたはすべての問題を持っているか、あなたがしたい場合は
挿入ソートのためのサンプルコードを参照してください。

1719
01:14:12,450 --> 01:14:13,750
私に知らせてください。

1720
01:14:13,750 --> 01:14:14,500
私の周りは常によ。

1721
01:14:14,500 --> 01:14:16,600

1722
01:14:16,600 --> 01:14:20,200
そこで最悪の場合の実行時
そして最良の場合のランタイム。

1723
01:14:20,200 --> 01:14:30,700
あなたは男私はすでに表から見たように
あなたにあった、それは両方のN乗とn。

1724
01:14:30,700 --> 01:14:35,590
>> とても親切の私たちが話したもののオフに行く
我々の以前の種類と程度、最悪

1725
01:14:35,590 --> 01:14:38,760
ケースランタイムがあればということです
それは完全にソートされていないですが、

1726
01:14:38,760 --> 01:14:42,530
我々は、これらのn回のすべてを比較しなければならない。

1727
01:14:42,530 --> 01:14:47,020
我々は比較の全体の多くを行う
それは逆の順序でのifなぜなら、

1728
01:14:47,020 --> 01:14:50,360
我々は、[OK]を、これを言うつもりだ
これは良いですが、同じであり、

1729
01:14:50,360 --> 01:14:54,650
この1つを比較する必要があります
最初の1に対して後方に移動する。

1730
01:14:54,650 --> 01:14:56,710
そして、私たちは向かって取るにつれて
テールエンドは、我々は持っている

1731
01:14:56,710 --> 01:14:59,440
、コンペアすると、
すべてに対して比較。

1732
01:14:59,440 --> 01:15:03,030
>> だから、なってしまう
約n乗。

1733
01:15:03,030 --> 01:15:09,510
それは、あなたが正しいだ場合
あなたは良いしている、2、[OK]を、言う。

1734
01:15:09,510 --> 01:15:11,330
図3に示すように、あなたは2と比較している。

1735
01:15:11,330 --> 01:15:12,310
あなたは良いね。

1736
01:15:12,310 --> 01:15:14,150
4、あなただけのテールと比較。

1737
01:15:14,150 --> 01:15:14,990
あなたは良いね。

1738
01:15:14,990 --> 01:15:17,140
図6は、あなたがいいですよ、テールと比較。

1739
01:15:17,140 --> 01:15:20,870
だから、すべてのスポットのためにそれは既にだ場合は、
ソートは、1つの比較を作っている。

1740
01:15:20,870 --> 01:15:22,320
だから、ちょうどn個だ。

1741
01:15:22,320 --> 01:15:26,840
そして、我々は最良のケースのランタイムを持っているので、
nとnの最悪の場合の実行時の

1742
01:15:26,840 --> 01:15:28,680
乗、我々は、予想されるランタイムを持っていません。

1743
01:15:28,680 --> 01:15:31,290

1744
01:15:31,290 --> 01:15:34,020
>> それはちょうどに依存
そこに私たちのリストの混乱。

1745
01:15:34,020 --> 01:15:35,860

1746
01:15:35,860 --> 01:15:39,530
そして再び、別の
グラフと別のテーブル。

1747
01:15:39,530 --> 01:15:41,170
種類の違いそう。

1748
01:15:41,170 --> 01:15:44,180
私はちょうどを通してそよ風するつもりです、私
私たちは広範囲に話したように感じる

1749
01:15:44,180 --> 01:15:46,570
どのようにすべての種類の約
の変わりと一緒にリンクします。

1750
01:15:46,570 --> 01:15:50,564
だから、マージソートすることは最後のものである
私はあなたたちを産んだものとします。

1751
01:15:50,564 --> 01:15:52,105
我々はかなりカラフルな絵を持っている。

1752
01:15:52,105 --> 01:15:53,860

1753
01:15:53,860 --> 01:15:56,040
だから、ソート再帰アルゴリズムであるマージ。

1754
01:15:56,040 --> 01:15:59,910
だから、あなたたちは何を知っていますか
再帰関数はありますか？

1755
01:15:59,910 --> 01:16:01,550

1756
01:16:01,550 --> 01:16:03,320
>> 誰もが言いたい？

1757
01:16:03,320 --> 01:16:04,739
あなたは試してみたい？

1758
01:16:04,739 --> 01:16:07,280
だから、再帰関数はただである
自分自身を呼び出す関数。

1759
01:16:07,280 --> 01:16:08,570

1760
01:16:08,570 --> 01:16:11,590
だから、あなたたちは精通している場合
フィボナッチ数列と、

1761
01:16:11,590 --> 01:16:15,670
そのためには、再帰的なものとみなさだ
あなたは前の2つを取る

1762
01:16:15,670 --> 01:16:17,530
と一緒にそれらを追加
あなたの次のいずれかを取得します。

1763
01:16:17,530 --> 01:16:21,440
私はいつも思うので、再帰
スパイラルなどの再帰の

1764
01:16:21,440 --> 01:16:24,430
ので、あなたはそれにダウンスパイラルのようにしている。

1765
01:16:24,430 --> 01:16:27,150
しかし、それは単なる関数です
それは自分自身を呼び出します。

1766
01:16:27,150 --> 01:16:32,660
>> そして、実際に、本当にすぐに私
それがどのように見えるかをお見せすることができます。

1767
01:16:32,660 --> 01:16:34,260

1768
01:16:34,260 --> 01:16:41,840
私たちが見れば、ここでそのように再帰的な、これは
配列をオーバー合計する再帰的な方法です。

1769
01:16:41,840 --> 01:16:45,900

1770
01:16:45,900 --> 01:16:47,880
だから、すべて私たちがやることです
我々は、合計機能を有する

1771
01:16:47,880 --> 01:16:52,210
大きさや配列を受け取り合計。

1772
01:16:52,210 --> 01:16:55,210
そして、あなたが気づけば、サイズ
1ずつ減少します。

1773
01:16:55,210 --> 01:17:00,365
xが等しい場合およびそれがないすべてである
zero--もしそうであれば、配列のサイズ

1774
01:17:00,365 --> 01:17:02,710
それがゼロを返しzero--に等しい。

1775
01:17:02,710 --> 01:17:10,440
>> それ以外の場合は、これを合計し
配列の最後の要素、

1776
01:17:10,440 --> 01:17:14,790
その後の和をとる
配列の残り。

1777
01:17:14,790 --> 01:17:17,555
だから、ちょうどそれを破壊している
より小さな問題に変換する。

1778
01:17:17,555 --> 01:17:18,990

1779
01:17:18,990 --> 01:17:21,890
長い話を短く、再帰、
自分自身を呼び出す関数。

1780
01:17:21,890 --> 01:17:25,740
それはあなたがこのの外に出たすべてだ場合は、
それは再帰関数が何であるかです。

1781
01:17:25,740 --> 01:17:29,870
あなたは51を取る場合は、あなたは非常に取得します、
再帰と非常に快適。

1782
01:17:29,870 --> 01:17:31,110

1783
01:17:31,110 --> 01:17:32,370
それは本当にクールだ。

1784
01:17:32,370 --> 01:17:34,660
それは次のように意味を成していた
午前3時から1つの夜。

1785
01:17:34,660 --> 01:17:37,900
そして、私は、なぜ、のようだった
私はこれを使用することはありませんか？

1786
01:17:37,900 --> 01:17:39,170

1787
01:17:39,170 --> 01:17:42,430
>> マージソートのためにそのように、基本的に
何それを行うために起こっていることは、それがだです

1788
01:17:42,430 --> 01:17:45,620
それを打破し、それを破るつもり
それだけで一つの要素になるまでダウン。

1789
01:17:45,620 --> 01:17:47,570
シングルの要素は並べ替えが容易です。

1790
01:17:47,570 --> 01:17:48,070
我々はそれを参照してください。

1791
01:17:48,070 --> 01:17:50,760
あなたは一つの要素を持っている場合、それはだ
すでにソートされたと考えた。

1792
01:17:50,760 --> 01:17:53,800
だから、n個の要素の入力で、
nが2未満である場合、

1793
01:17:53,800 --> 01:17:58,120
ちょうどことを意味するから戻す
それは我々が見てきたように、0または1のどちらかです。

1794
01:17:58,120 --> 01:18:00,050
それらは、ソートされた要素が考慮されます。

1795
01:18:00,050 --> 01:18:02,170
>> そうでない場合は半分にそれを破る。

1796
01:18:02,170 --> 01:18:06,336
第二のソート、前半を並べ替える
半分、次にそれらを一緒にマージする。

1797
01:18:06,336 --> 01:18:07,460
なぜそれがマージソートと呼ばれています。

1798
01:18:07,460 --> 01:18:08,700

1799
01:18:08,700 --> 01:18:12,155
我々はこれらを並べ替えるよだから我々はここにある。

1800
01:18:12,155 --> 01:18:13,410

1801
01:18:13,410 --> 01:18:17,210
だから我々はそれらを持つ保つ
配列サイズが1になるまで。

1802
01:18:17,210 --> 01:18:20,790
それは1だときに、私達はちょうど返す
これは、ソートされた配列であるため、

1803
01:18:20,790 --> 01:18:23,940
これは、ソートされた配列であり、それはです
ソートされた配列は、我々はすべてのソートしている。

1804
01:18:23,940 --> 01:18:25,390

1805
01:18:25,390 --> 01:18:29,420
それでは、私たちは何をすべきか、我々はある
それらを一緒にマージし始める。

1806
01:18:29,420 --> 01:18:31,820
>> あなたができるような方法
マージがある考える

1807
01:18:31,820 --> 01:18:36,240
あなただけ小さくを削除
サブアレイのそれぞれの数

1808
01:18:36,240 --> 01:18:38,330
ちょうど浮上し、配列に追加します。

1809
01:18:38,330 --> 01:18:44,290
だから我々が持っているときに、ここに見れば
これらのセットは、我々は、4,6、及び1を有している。

1810
01:18:44,290 --> 01:18:47,280
我々はこれらをマージしたい場合は、
我々はこれらの最初の二つを見て

1811
01:18:47,280 --> 01:18:50,730
そして我々は、OK、1の方が小さい、と言う、
それはフロントに行く。

1812
01:18:50,730 --> 01:18:54,330
4と6、比較するものはありません
それは、終了間際にそれを上のタグである。

1813
01:18:54,330 --> 01:18:58,020
>> 我々はこれら二つを組み合わせるとき、私たちだけで
これらの2つの小さい方を取る

1814
01:18:58,020 --> 01:18:59,310
そう、それは1だ。

1815
01:18:59,310 --> 01:19:01,690
そして今、我々は取る
これら2、SO 2の小さい方。

1816
01:19:01,690 --> 01:19:03,330
これら2、3の小さい方。

1817
01:19:03,330 --> 01:19:06,260
これら二つの、4、5、6より小さい。

1818
01:19:06,260 --> 01:19:08,630
だから、あなただけのこれらをオフに引っ張っている。

1819
01:19:08,630 --> 01:19:11,210
そして、彼らがしたので、
以前にソートされて、

1820
01:19:11,210 --> 01:19:14,300
あなただけのものを持っている
比較そこに毎回。

1821
01:19:14,300 --> 01:19:19,610
ここので、より多くのコードだけ表現。

1822
01:19:19,610 --> 01:19:24,410
だから、途中で開始し、
あなたの並べ替え、左右

1823
01:19:24,410 --> 01:19:26,180
そして、あなたはちょうどそれらをマージ。

1824
01:19:26,180 --> 01:19:30,080
>> そして、我々はコードを持っていない
マージのために右ここに。

1825
01:19:30,080 --> 01:19:34,110
しかし、再び、あなたは上に行く場合は、
50を勉強、それはそこでしょう。

1826
01:19:34,110 --> 01:19:36,860
そうしないと私に話を来て
あなたはまだ混乱している場合には。

1827
01:19:36,860 --> 01:19:42,340
だからここにクールなことは、最良の場合で、
最悪の場合、および予想されるランタイム

1828
01:19:42,340 --> 01:19:46,250
、nはすべてログに記録されている
私たちがしたよりもはるかに優れている

1829
01:19:46,250 --> 01:19:48,000
私たちの種類の残りのために見られる。

1830
01:19:48,000 --> 01:19:51,840
我々は、n乗を見てきました
実際に、どのような私たち

1831
01:19:51,840 --> 01:19:54,380
偉大である、nはn個のログですここに来る。

1832
01:19:54,380 --> 01:19:55,830
>> つまり、どの程度改善を見てください。

1833
01:19:55,830 --> 01:19:56,780
このような素敵な曲線。

1834
01:19:56,780 --> 01:19:58,130

1835
01:19:58,130 --> 01:20:00,120
だから、はるかに効率的。

1836
01:20:00,120 --> 01:20:03,510
あなたは今まで、ソートマージ使用することができます。

1837
01:20:03,510 --> 01:20:04,810
それはあなたの時間を節約できます。

1838
01:20:04,810 --> 01:20:07,670
その後、再び、私たちが言ったように、もし
あなたは、この下部領域にダウンしている

1839
01:20:07,670 --> 01:20:09,480
それはそれを行いません
大きな違い。

1840
01:20:09,480 --> 01:20:11,360
あなたは、何千も起きる
と入力の何千人も、

1841
01:20:11,360 --> 01:20:13,318
あなたは間違いなくしたい
より効率的なアルゴリズム。

1842
01:20:13,318 --> 01:20:14,730

1843
01:20:14,730 --> 01:20:19,400
すべてのと、再び、私たちの素敵なテーブル
あなたたちは、今日学んだ種類。

1844
01:20:19,400 --> 01:20:21,157
>> だから私はそれが密な日だった知っている。

1845
01:20:21,157 --> 01:20:23,490
これは、必ずしも予定されていません
あなたのpsetのお手伝いをします。

1846
01:20:23,490 --> 01:20:28,250
しかし、私はちょうど免責事項を作りたい
そのセクションはただのpsetに関するものではありません。

1847
01:20:28,250 --> 01:20:31,240
すべてこの材料は、公正である
あなたの中間試験のためのゲーム。

1848
01:20:31,240 --> 01:20:35,430
そしてまた、あなたがしなければ、CSを続行、
これらは、本当に重要な基礎である

1849
01:20:35,430 --> 01:20:37,870
ことをあなたが知っている必要があります。

1850
01:20:37,870 --> 01:20:41,700
だから、何日かは次のようになります
もう少しPSETヘルプ、

1851
01:20:41,700 --> 01:20:44,600
しかし、いくつかの数週間は次のようになります
ずっと実際のコンテンツ

1852
01:20:44,600 --> 01:20:46,600
それはスーパー思えないかもしれません
今のあなたに役立つ、

1853
01:20:46,600 --> 01:20:51,215
あなたが続けば、私は約束します
上は非常に、非常に有用であろう。

1854
01:20:51,215 --> 01:20:52,560

1855
01:20:52,560 --> 01:20:54,250
>> だから、セクションのためにそれだ。

1856
01:20:54,250 --> 01:20:55,250
ワイヤーにダウン。

1857
01:20:55,250 --> 01:20:56,570
私は1分以内にそれをやった。

1858
01:20:56,570 --> 01:20:58,262

1859
01:20:58,262 --> 01:20:58,970
しかし、そこに行く。

1860
01:20:58,970 --> 01:21:01,240
そして、私はドーナツやキャンディーを持つことになります。

1861
01:21:01,240 --> 01:21:03,464
アレルギー誰もがする​​ことです
ところで何でも、？

1862
01:21:03,464 --> 01:21:05,307

1863
01:21:05,307 --> 01:21:05,890
卵と牛乳。

1864
01:21:05,890 --> 01:21:08,120
だから、ドーナツはありませんがありますか？

1865
01:21:08,120 --> 01:21:09,400

1866
01:21:09,400 --> 01:21:10,160
[OK]をクリックします。

1867
01:21:10,160 --> 01:21:10,770
わかりました。

1868
01:21:10,770 --> 01:21:12,120
チョコレートなし？

1869
01:21:12,120 --> 01:21:12,620
スターバースト。

1870
01:21:12,620 --> 01:21:13,837

1871
01:21:13,837 --> 01:21:14,670
スターバーストは良いです。

1872
01:21:14,670 --> 01:21:15,170
[OK]をクリックします。

1873
01:21:15,170 --> 01:21:17,045
私たちは持っているつもり
その後来週スターバースト。

1874
01:21:17,045 --> 01:21:18,240
それは私が買ってあげるものです。

1875
01:21:18,240 --> 01:21:19,690
君たちは素晴らしい週に持っている。

1876
01:21:19,690 --> 01:21:20,460
あなたのスペックをお読みください。

1877
01:21:20,460 --> 01:21:22,130
>> ご質問があるなら、私に教えてください。

1878
01:21:22,130 --> 01:21:25,300
PSET 2グレードがあるべき
木曜日によってあなたに出。

1879
01:21:25,300 --> 01:21:28,320
あなたが質問があれば
私は何かを段階的方法については、

1880
01:21:28,320 --> 01:21:32,250
またはなぜ私は道私が何かを等級分け
、私に話を来て、私にメールしてくださいました。

1881
01:21:32,250 --> 01:21:34,210
私はこの小さなクレイジーだ
週、私は約束します

1882
01:21:34,210 --> 01:21:36,340
私はまだ24時間以内に返信されます。

1883
01:21:36,340 --> 01:21:38,240
だから、偉大な週皆を持っている。

1884
01:21:38,240 --> 01:21:40,090
あなたのpset上の幸運。

1885
01:21:40,090 --> 01:21:41,248