1
00:00:00,000 --> 00:00:03,332
>> [音楽再生]

2
00:00:03,332 --> 00:00:06,490
>> ANDI PENG：セクションの週3へようこそ。

3
00:00:06,490 --> 00:00:09,550
すべての来てくれてありがとう、あなたたち、
今日この早い開始時間に。

4
00:00:09,550 --> 00:00:11,466
私たちは少し、素敵なを持っています
親密なグループ今日。

5
00:00:11,466 --> 00:00:14,570
だから、うまくいけば、我々はに取得します
仕上げ、おそらく、初期の、

6
00:00:14,570 --> 00:00:15,780
少し早い今日。

7
00:00:15,780 --> 00:00:22,057
だからすぐに、単にいくつかの
議題今日発表。

8
00:00:22,057 --> 00:00:23,890
私たちは始める前に、私たちはしています
わずかに行くつもり

9
00:00:23,890 --> 00:00:28,910
いくつかの簡単な物流の問題、PSET
質問、デブリーフィング、そのようなこと。

10
00:00:28,910 --> 00:00:30,250
そして、我々は右ダイビングます。

11
00:00:30,250 --> 00:00:34,710
我々は、GDBへと呼ばれるデバッガを使用します
我々のコード、ダビデを暴く開始

12
00:00:34,710 --> 00:00:36,550
先日講義で説明しました。

13
00:00:36,550 --> 00:00:39,420
私たちは、ある種の4種類の上に行きますよ。

14
00:00:39,420 --> 00:00:42,310
我々は非常にすぐにそれらの上に行きますよ
彼らはかなりの集中しているからです。

15
00:00:42,310 --> 00:00:45,710
しかし、知っているすべてのスライドと
ソースコードは常にオンラインです。

16
00:00:45,710 --> 00:00:50,810
そうするためには、あなたの閲覧で、お気軽に
戻って、その見てみましょう。

17
00:00:50,810 --> 00:00:53,930
>> 我々は通過します
漸近記法、これ

18
00:00:53,930 --> 00:00:55,944
ただ派手な方法であります
のが「ランタイム」を

19
00:00:55,944 --> 00:00:58,360
私たちは大きなOを持っている場合は、これ
ダビデは講義で説明しました。

20
00:00:58,360 --> 00:01:01,550
そして、我々はまた、オメガを持っています
下界ランタイムがあります。

21
00:01:01,550 --> 00:01:06,450
そして、私たちは少し詳しく説明します
綿密な方法これらの作業について。

22
00:01:06,450 --> 00:01:10,160
そして最後に、我々は、二分探索の上に行きますよ
なぜなら、すでに持っているあなた方の多く

23
00:01:10,160 --> 00:01:15,190
おそらくことを知っているあなたのpsetをちらっと見ました
それはあなたのpsetでの質問です。

24
00:01:15,190 --> 00:01:17,470
だから、すべてにご満足いただけることでしょう
私たちは今日、これをカバーします。

25
00:01:17,470 --> 00:01:20,610
>> そして最後に、あなたのあたり
セクションのフィードバック、実際に私

26
00:01:20,610 --> 00:01:23,000
で約15分間放置
わずか行くに終了

27
00:01:23,000 --> 00:01:27,730
pset3の物流、ご質問、
多分指導のビット、あなたがする場合は、

28
00:01:27,730 --> 00:01:28,990
我々はプログラミングを開始する前に。

29
00:01:28,990 --> 00:01:30,890
それでは、を介して取得してみましょう
かなり迅速に材料。

30
00:01:30,890 --> 00:01:33,880
そして、我々はいくつかの時間を過ごすことができます
PSETのためのより多くの質問を取ります。

31
00:01:33,880 --> 00:01:35,230
OK。

32
00:01:35,230 --> 00:01:39,570
>> すぐに、これだけの数
発表我々が今日開始する前に。

33
00:01:39,570 --> 00:01:45,410
まず、作ることに歓迎
それあなたのpsetの2つの貫通。

34
00:01:45,410 --> 00:01:49,432
私はええ、レッツyour--で見ていました
そのいずれかの拍手のラ​​ウンドを取得します。

35
00:01:49,432 --> 00:01:51,140
実際に、私は、本当にでした
本当に感動。

36
00:01:51,140 --> 00:01:55,800
私はあなたたちのために、最初のpsetを段階的
先週とあなたたちは信じられないほどでした。

37
00:01:55,800 --> 00:01:58,290
>> スタイルのポイントにありました
いくつかのコメントのほかに。

38
00:01:58,290 --> 00:02:00,660
あなたはいつもしていることを確認してください
あなたのコードをコメント。

39
00:02:00,660 --> 00:02:03,040
しかし、あなたのpsetは点にありました。

40
00:02:03,040 --> 00:02:05,549
そして、それを維持します。

41
00:02:05,549 --> 00:02:08,090
そして、それはへ年生のために良いことです
あなたたちは入れていることを確認

42
00:02:08,090 --> 00:02:10,704
あなたのスタイルのように多くの努力で
あなたのコード内で、デザイン

43
00:02:10,704 --> 00:02:12,120
あなたが見ることのために私たちは希望のこと。

44
00:02:12,120 --> 00:02:16,450
だから、私は感謝の気持ちに沿って渡しています
TAの残りのため。

45
00:02:16,450 --> 00:02:19,210
>> しかし、そこにあります
いくつかの結果を聞く質問

46
00:02:19,210 --> 00:02:22,010
私はちょうどそれの上に行きたいです
両方の私の人生になるだろう

47
00:02:22,010 --> 00:02:24,900
および他の多くの
TAが「少し簡単に住んでいます。

48
00:02:24,900 --> 00:02:28,220
まず、私はこれを気づきました
過去はあなたの何をweek--

49
00:02:28,220 --> 00:02:32,301
上check50を実行されています
あなたの前にあなたのコードを提出しますか？

50
00:02:32,301 --> 00:02:32,800
OK。

51
00:02:32,800 --> 00:02:36,690
だから、誰もがcheck50にやるべきこと、
secret--実際に我々because--

52
00:02:36,690 --> 00:02:41,540
私たちの正しさの一部としてcheck50を実行
あなたのコードをテストするためのスクリプト。

53
00:02:41,540 --> 00:02:45,480
だからあなたのコードが失敗した場合
check50、すべての可能性で、

54
00:02:45,480 --> 00:02:47,570
それはおそらくに起こっています
同様に私たちのチェックに失敗。

55
00:02:47,570 --> 00:02:49,320
時々、あなたたち
正しい答えを持っています。

56
00:02:49,320 --> 00:02:52,200
のように、貪欲で、いくつかの
あなたは正しい番号を持って、

57
00:02:52,200 --> 00:02:53,960
あなただけのいくつかの余分なものをプリントアウト。

58
00:02:53,960 --> 00:02:55,940
そして、その余分なもの
実際にチェックに失敗しました、

59
00:02:55,940 --> 00:02:58,440
コンピュータはしていませんので、
実際にそれが探しているものを知っています。

60
00:02:58,440 --> 00:03:00,981
そしてそれはちょうど、通じ実行されます
あなたの出力がないことを確認

61
00:03:00,981 --> 00:03:03,810
私たちは答えを期待するものと一致
よく、それは間違ってマークします。

62
00:03:03,810 --> 00:03:06,560
>> そして、私はで起こったことを知っています
あなたの例いくつかの今週。

63
00:03:06,560 --> 00:03:09,870
だから私は戻って、手動で行ってきました
みんなのコードをregraded。

64
00:03:09,870 --> 00:03:12,780
しかし将来的には、
、確認してくださいしてください。

65
00:03:12,780 --> 00:03:14,570
あなたが実行していること
あなたのコードに50を​​ご確認ください。

66
00:03:14,570 --> 00:03:17,970
そのためには、TAのための痛みのようなものです
戻って手動で勾配をつけ直すために持っています

67
00:03:17,970 --> 00:03:21,197
すべてのためのすべての単一のpset
シングル、少しインスタンスを逃しました。

68
00:03:21,197 --> 00:03:22,530
だから私は、任意のポイントを離陸しませんでした。

69
00:03:22,530 --> 00:03:25,210
私は多分、離陸したと思います
1または設計のための2つ。

70
00:03:25,210 --> 00:03:27,710
しかし将来的には、もし
あなたはcheck50に失敗しています、

71
00:03:27,710 --> 00:03:31,330
ポイントが取得されます
正しさのためにオフにします。

72
00:03:31,330 --> 00:03:35,020
>> さらに、のpsetがあります
正午金曜日による。

73
00:03:35,020 --> 00:03:38,990
私は7分があると思います
私たちはあなたを与える後半猶予期間。

74
00:03:38,990 --> 00:03:42,434
ハーバード時間当たり、それらが許可されているに
後半すべてに7分です。

75
00:03:42,434 --> 00:03:44,350
だからここにエールで、我々はよ
同様にそのに準拠しています。

76
00:03:44,350 --> 00:03:47,910
しかし、かなり多く、12：07で、
あなたのpsetがでない場合は、

77
00:03:47,910 --> 00:03:49,720
それは、後半にマークされるだろう。

78
00:03:49,720 --> 00:03:53,160
そしてそれがマークされている間
私はのように遅く、TA--

79
00:03:53,160 --> 00:03:54,870
まだあなたのpsetをグレーディングすることになるだろう。

80
00:03:54,870 --> 00:03:56,760
だから、あなたはまだグレードが表示されます表示されます。

81
00:03:56,760 --> 00:03:58,820
しかし、であることを知っています
学期の終わり、

82
00:03:58,820 --> 00:04:02,270
すべての後半のpsetだけになります
コンピュータによって自動的にゼロに。

83
00:04:02,270 --> 00:04:04,490
>> 我々は2つ​​の理由でこれを行います。

84
00:04:04,490 --> 00:04:09,220
一つは、時には我々が得ます
学部長の言い訳のように、免除、

85
00:04:09,220 --> 00:04:10,762
後でその上で、私はまだ知りません。

86
00:04:10,762 --> 00:04:13,761
だから我々は我々がグレーディングしていることを確認したいです
念のため、私は、同じようにすべて

87
00:04:13,761 --> 00:04:15,080
学部長の言い訳が欠落。

88
00:04:15,080 --> 00:04:17,000
そして第二に、中に保ちます
心、あなたはまだすることができます

89
00:04:17,000 --> 00:04:19,370
その1 PSETをドロップ
全範囲のポイントを持っています。

90
00:04:19,370 --> 00:04:21,430
そして、私たちはグレードしたいです
あなたのpsetのすべてだけ

91
00:04:21,430 --> 00:04:24,730
必ずあなたの範囲のことを確認します
そこに、あなたはそれをしようとしています。

92
00:04:24,730 --> 00:04:29,150
だから、それは遅場合でも、あなたはまだよ
スコープポイントのクレジットを取得し、私は​​思います。

93
00:04:29,150 --> 00:04:33,730
>> 物語の道徳的だから、作るさ
必ずあなたのpsetはオンタイムです。

94
00:04:33,730 --> 00:04:38,350
そして、彼らはオン時間内にない場合、
それは素晴らしいではないことを知っています。

95
00:04:38,350 --> 00:04:41,678
ええ、私は上に移動する前に、誰もが持っているん
PSETフィードバックに関する質問？

96
00:04:41,678 --> 00:04:42,178
うん。

97
00:04:42,178 --> 00:04:43,630
>> 聴衆：あなたは私たちが言いました
psetのいずれかをドロップすることができますか？

98
00:04:43,630 --> 00:04:44,296
>> ANDI PENG：うん。

99
00:04:44,296 --> 00:04:47,050
だから、全体の9のpsetがあります
学期の経過。

100
00:04:47,050 --> 00:04:50,610
そして、あなたはスコープを持っている場合
points--のでスコープは、単にあります

101
00:04:50,610 --> 00:04:53,567
かなり、あなたがしようとしています
問題は、あなたが時間内に入れています、

102
00:04:53,567 --> 00:04:56,150
あなたがしたことを示しています
あなたが仕様を読んだ実証しました。

103
00:04:56,150 --> 00:04:57,191
それはかなりの範囲です。

104
00:04:57,191 --> 00:04:59,370
そして、あなたが果たしている場合
スコープポイント、我々

105
00:04:59,370 --> 00:05:03,360
最低をドロップすることができます
完全な範囲のうち1。

106
00:05:03,360 --> 00:05:06,790
だから、にあなたの利点にです
完了し、すべてのPSETを試してみてください。

107
00:05:06,790 --> 00:05:10,320
>> いずれの場合であってもupload--
彼らは動作し、それらをすべてアップロードします。

108
00:05:10,320 --> 00:05:13,711
そして、我々は、うまくいけばのことができるようになります
あなたはこれらの点のいくつかを返します。

109
00:05:13,711 --> 00:05:14,210
クール。

110
00:05:14,210 --> 00:05:16,780
その他の質問は？

111
00:05:16,780 --> 00:05:17,840
グレート。

112
00:05:17,840 --> 00:05:21,960
>> 第二に、オフィスはいくつかのhours--
営業時間についての簡単なメモ。

113
00:05:21,960 --> 00:05:24,300
そこでまず、初期の週に来ます。

114
00:05:24,300 --> 00:05:26,909
誰もが今までではありません
月曜日の営業時間。

115
00:05:26,909 --> 00:05:28,700
クリスタベルはに来ました
営業時間昨夜。

116
00:05:28,700 --> 00:05:29,691
クリスタベル、うん。

117
00:05:29,691 --> 00:05:32,190
そして、我々はオフィスで何を持っていました
時間昨夜、クリスタベル？

118
00:05:32,190 --> 00:05:33,020
>> 観客：我々は、アイスクリームを持っていました。

119
00:05:33,020 --> 00:05:36,160
>> ANDI PENG：だからそうです、私たちは持っていました
営業時間の最後の夜にアイスクリーム。

120
00:05:36,160 --> 00:05:39,390
私はあなたを約束することはできませんが
私たちは、営業時間にアイスクリームを持っています

121
00:05:39,390 --> 00:05:43,230
毎週、私はあなたを約束することができるもの
かなりあるだろうということです

122
00:05:43,230 --> 00:05:45,380
TA比に優れた学生。

123
00:05:45,380 --> 00:05:47,650
合法的なように、それは一から三のようなものです。

124
00:05:47,650 --> 00:05:50,350
、とそのコントラストのに対し
木曜日には、約150を持っています

125
00:05:50,350 --> 00:05:52,830
本当に子供なしアイスクリームを強調しました。

126
00:05:52,830 --> 00:05:55,360
そして、それは誰ものための生産的ではありません。

127
00:05:55,360 --> 00:05:58,730
物語の道徳的なだから、早期に来ています
営業時間と良いものへ

128
00:05:58,730 --> 00:06:00,310
起こります。

129
00:06:00,310 --> 00:06:02,110
>> また、質問をする準備してきます。

130
00:06:02,110 --> 00:06:03,200
ええと？

131
00:06:03,200 --> 00:06:05,420
関係なく、どのようなTAの、私
、言っていると思いますが、

132
00:06:05,420 --> 00:06:10,710
我々は、カップルの学生を取得してきました
10：50、のような、で木曜日に来る人

133
00:06:10,710 --> 00:06:15,100
仕様を読んではありません
私を助けるようなもの、私を助けて。

134
00:06:15,100 --> 00:06:18,200
残念ながら、その時点で、あります
多くの私たちはあなたを助けるために行うことができません。

135
00:06:18,200 --> 00:06:19,590
だから、初期の週に来てください。

136
00:06:19,590 --> 00:06:22,040
営業時間に早期に来ます。

137
00:06:22,040 --> 00:06:23,350
質問をする準備してきます。

138
00:06:23,350 --> 00:06:25,310
必ずことを確認してください
学生、どこにあります

139
00:06:25,310 --> 00:06:27,620
あなたはそのようにする必要があります
TAが、に沿ってあなたを導くことができます

140
00:06:27,620 --> 00:06:32,850
どのような営業時間であります
割り当てられなければなりません。

141
00:06:32,850 --> 00:06:37,380
>> 第二に、私は教授を知っています
テストで私たちを驚かせたいです。

142
00:06:37,380 --> 00:06:39,439
私は教授のものを持っていました
ところで、ヨーヨーのような、

143
00:06:39,439 --> 00:06:41,230
その中間を覚えています
あなたは来週の月曜日です。

144
00:06:41,230 --> 00:06:42,855
ええ、私はその中間については知りませんでした。

145
00:06:42,855 --> 00:06:45,630
だから私はそのTAになるだろうよ
それはあなたにすべてのことを連想させるクイズ

146
00:06:45,630 --> 00:06:47,270
0--あなたが知っている、ので、我々は、CSです。

147
00:06:47,270 --> 00:06:50,730
今、私たちは、配列をやったことを、あなたが取得します
それはクイズ0だからこそ、えっ、1をクイズではありませんか？

148
00:06:50,730 --> 00:06:51,320
OK。

149
00:06:51,320 --> 00:06:52,490
ああ、私はその1にいくつかの笑うを得ました。

150
00:06:52,490 --> 00:06:53,120
OK。

151
00:06:53,120 --> 00:06:59,710
>> だから、クイズ0があれば10月14日になります
あなたは月曜日〜水曜日のセクションにいます

152
00:06:59,710 --> 00:07:02,920
そして10月15日あなたがしている場合
火曜日・木曜日のセクション。

153
00:07:02,920 --> 00:07:05,630
これは適用されません
ハーバード大学のあなたのそれら

154
00:07:05,630 --> 00:07:10,350
私はあなたがすべてのだろうと思いwho--
14日にあなたのクイズを取ります。

155
00:07:10,350 --> 00:07:13,560
>> そうそう、来週、場合
ダビデは、講義で、行きます、

156
00:07:13,560 --> 00:07:15,747
ええ、そんなに
クイズ来週、あなたのすべて

157
00:07:15,747 --> 00:07:17,580
ので、ショックを受けることはありません
あなたはセクションに来ました

158
00:07:17,580 --> 00:07:19,664
あなたはあなたのことを知っています
クイズ0は2週間です。

159
00:07:19,664 --> 00:07:21,580
そして、我々は審査があるでしょう
セッションおよびすべて。

160
00:07:21,580 --> 00:07:26,360
そんなに心配しません
そのために怖がっています。

161
00:07:26,360 --> 00:07:29,890
ご質問before--ご質問
全てにおいて物流の問題で、

162
00:07:29,890 --> 00:07:32,591
グレーディング、営業時間、セクション？

163
00:07:32,591 --> 00:07:33,090
うん。

164
00:07:33,090 --> 00:07:35,100
>> 観客：クイズがありそう
講義中になるだろうか？

165
00:07:35,100 --> 00:07:35,766
>> ANDI PENG：うん。

166
00:07:35,766 --> 00:07:39,460
クイズだから、私が思うに、60です
そのタイムスロットに割り当てられた分

167
00:07:39,460 --> 00:07:42,240
あなただけ取るだろうと
講堂インチ

168
00:07:42,240 --> 00:07:44,810
だから、来る必要はありません
ランダム午後7時、のような、上。

169
00:07:44,810 --> 00:07:46,140
大丈夫だよー。

170
00:07:46,140 --> 00:07:47,100
うん。

171
00:07:47,100 --> 00:07:50,060
クール。

172
00:07:50,060 --> 00:07:50,840
>> 大丈夫。

173
00:07:50,840 --> 00:07:54,330
だから我々はするつもりです
あなたに概念を導入します

174
00:07:54,330 --> 00:08:00,760
ダビデは一種すでに持っているこの週
この一週間の講義で触れました。

175
00:08:00,760 --> 00:08:02,010
これは、GDBと呼ばれています。

176
00:08:02,010 --> 00:08:05,570
そして、どのように多くの、にある間
あなたのpsetを書くもちろん、

177
00:08:05,570 --> 00:08:09,981
言う大きなボタンに気づきました
あなたのIDEの上部に「デバッグ」？

178
00:08:09,981 --> 00:08:10,480
OK。

179
00:08:10,480 --> 00:08:13,770
だから今、私たちは実際に発掘するために取得します
実際にどのようなそのボタンの謎

180
00:08:13,770 --> 00:08:14,270
い。

181
00:08:14,270 --> 00:08:16,790
そして、私はそれは、あなたを保証します
美しい、美しいもの。

182
00:08:16,790 --> 00:08:20,740
>> だから今まで、私は思います
二つのことがあったです

183
00:08:20,740 --> 00:08:23,320
学生は一般的になっています
psetをデバッグするときにやって。

184
00:08:23,320 --> 00:08:27,635
一方、彼らはいずれかで追加します
printf（） - ので、すべての数行、

185
00:08:27,635 --> 00:08:29,760
彼らはprintfの（）に追加します - 
ああ、この変数は何ですか？

186
00:08:29,760 --> 00:08:32,551
ああ、この変数は何ですかnow--
あなたは親切なの進行状況を確認

187
00:08:32,551 --> 00:08:33,940
それは実行時にコードの。

188
00:08:33,940 --> 00:08:37,030
や子供たちが行う第二の方法は、
彼らは全体のことを書くこと

189
00:08:37,030 --> 00:08:38,610
して、最後に次のように行きます。

190
00:08:38,610 --> 00:08:39,970
うまくいけば、それは動作します。

191
00:08:39,970 --> 00:08:44,851
私はあなたを保証する、GDBは良いです
これらのメソッドの両方より。

192
00:08:44,851 --> 00:08:45,350
うん。

193
00:08:45,350 --> 00:08:46,980
だから、これはあなたの新しい親友になります。

194
00:08:46,980 --> 00:08:51,780
それは美しいものだからです
その視覚的に表示され、両方の

195
00:08:51,780 --> 00:08:54,850
あなたのコードが何をしていますか
特定の時点で

196
00:08:54,850 --> 00:08:57,486
だけでなく、どのようなあなたのすべて
変数は運んでいます、

197
00:08:57,486 --> 00:08:59,610
それらの値が何であるかのように、
その特定の時点で。

198
00:08:59,610 --> 00:09:02,670
このようにし、あなたが本当にすることができます
あなたのコードにブレークポイントを設定します。

199
00:09:02,670 --> 00:09:04,350
あなたは、行ごとを介して実行することができます。

200
00:09:04,350 --> 00:09:07,324
そして、GDBだけのために持っています
あなたは、あなたのために表示され、

201
00:09:07,324 --> 00:09:09,490
何すべての変数の
、彼らは何をしているしています、

202
00:09:09,490 --> 00:09:10,656
何がコード内で起こっています。

203
00:09:10,656 --> 00:09:13,240
そして、このように、それはです
そんなに簡単に参照するために

204
00:09:13,240 --> 00:09:17,120
何がprintfの-INGの代わりに起こっています
または、あなたの文を書き留めます。

205
00:09:17,120 --> 00:09:19,160
>> だから我々は、この後の例をやります。

206
00:09:19,160 --> 00:09:20,660
だから、これはビット抽象的です。

207
00:09:20,660 --> 00:09:23,490
心配しないで、我々は例もしないでしょう。

208
00:09:23,490 --> 00:09:29,170
だから、本質的に、三大、
あなたはGDBに必要があります最も使う機能

209
00:09:29,170 --> 00:09:32,500
次は、ステップオーバー、
およびボタンへのステップ。

210
00:09:32,500 --> 00:09:34,860
私は頭の上に行きますよ
そこに、実際に、今。

211
00:09:34,860 --> 00:09:40,930
>> だから人はすべてのことを見ることができます
または私は少しズームインする必要がありますか？

212
00:09:40,930 --> 00:09:43,220

213
00:09:43,220 --> 00:09:44,470
バックでは、あなたはそれを見ることができますか？

214
00:09:44,470 --> 00:09:45,730
私は、ズームインする必要がありますか？

215
00:09:45,730 --> 00:09:46,480
少しだけ？

216
00:09:46,480 --> 00:09:49,390
うんいいね。

217
00:09:49,390 --> 00:09:50,280
そうしよう。

218
00:09:50,280 --> 00:09:50,960
OK。

219
00:09:50,960 --> 00:09:57,000
>> だから、私は、ここでは、持っています
貪欲のための実装です。

220
00:09:57,000 --> 00:10:01,430
そして、あなたたちの多くが書いている間
そのform-- whileループで貪欲

221
00:10:01,430 --> 00:10:04,890
行うには完全に受け入れられる方法です
それを行うにはit--別の方法は、単純であること

222
00:10:04,890 --> 00:10:06,280
モジュロに分けます。

223
00:10:06,280 --> 00:10:09,290
あなたが持つことができるので、あなたの
値と、あなたの残りを持っています。

224
00:10:09,290 --> 00:10:11,150
そして、あなただけのことができます
一緒にそれをすべて追加します。

225
00:10:11,150 --> 00:10:13,390
私がやっている何のロジックを行い
誰もがここに意味をなさない、

226
00:10:13,390 --> 00:10:14,117
私たちは始める前に？

227
00:10:14,117 --> 00:10:16,760

228
00:10:16,760 --> 00:10:17,980
やや？

229
00:10:17,980 --> 00:10:18,710
クール。

230
00:10:18,710 --> 00:10:19,210
グレート。

231
00:10:19,210 --> 00:10:21,290
それはかなりセクシーな作品です
コー​​ドの、私は言うでしょう。

232
00:10:21,290 --> 00:10:23,502
私はに、ダビデを言ったように
しばらくして、講義、

233
00:10:23,502 --> 00:10:25,960
あなたはすべてのコードを見てから始めましょう
美しいものとして。

234
00:10:25,960 --> 00:10:29,950
そして、時にはあなたは美しい見たとき
コー​​ドは、このような素晴らしい感覚です。

235
00:10:29,950 --> 00:10:35,410
>> だからしかし、このコードは非常にある間
美しい、それが正しく動作しません。

236
00:10:35,410 --> 00:10:37,750
それでは、この上check50を実行してみましょう。

237
00:10:37,750 --> 00:10:39,440
50 20-- OOPを確認してください。

238
00:10:39,440 --> 00:10:43,221

239
00:10:43,221 --> 00:10:43,720
2？

240
00:10:43,720 --> 00:10:44,990
そのpset2はありますか？

241
00:10:44,990 --> 00:10:46,870
うん。

242
00:10:46,870 --> 00:10:47,520
ああ、PSET1。

243
00:10:47,520 --> 00:10:50,970

244
00:10:50,970 --> 00:10:52,890
OK。

245
00:10:52,890 --> 00:10:53,900
だから我々はcheck50を実行します。

246
00:10:53,900 --> 00:11:01,550

247
00:11:01,550 --> 00:11:07,170
>> そして、あなたたちはここで見ることができるように、
それは例のカップルを失敗しています。

248
00:11:07,170 --> 00:11:10,165
そして、あなたのいくつかのために、中
問題のセットをしているもちろん、

249
00:11:10,165 --> 00:11:11,110
ああ、なぜそれが機能していない、のようにあなたがしています。

250
00:11:11,110 --> 00:11:13,318
なぜそれがいくつかのために働いています
値ではなく、他人のために？

251
00:11:13,318 --> 00:11:17,760
さて、GDBはあなたの図を助けるために起こっています
これらの入力が機能していなかった理由を。

252
00:11:17,760 --> 00:11:18,320
>> OK。

253
00:11:18,320 --> 00:11:21,640
それでは、、のいずれかを見てみましょう
私はcheck50に失敗したチェック

254
00:11:21,640 --> 00:11:24,920
0.41の入力値でした。

255
00:11:24,920 --> 00:11:27,830
正解だから
あなたは4で取得する必要があります。

256
00:11:27,830 --> 00:11:33,090
しかし、その代わりに、私はプリントアウトしていますどのような
間違っている3-nは、あります。

257
00:11:33,090 --> 00:11:36,190
だから、ちょうどこれを手動で実行してみましょう
check50が動作していることを確認してください。

258
00:11:36,190 --> 00:11:36,940
それでは、./greedyやってみましょう。

259
00:11:36,940 --> 00:11:40,130

260
00:11:40,130 --> 00:11:43,340
おっと、私は欲張りようにする必要があります。

261
00:11:43,340 --> 00:11:43,840
そうしよう。

262
00:11:43,840 --> 00:11:44,381
今./greedy。

263
00:11:44,381 --> 00:11:46,950

264
00:11:46,950 --> 00:11:47,670
>> どのくらいを負っているのですか？

265
00:11:47,670 --> 00:11:49,550
それでは、0.41を実行してみましょう。

266
00:11:49,550 --> 00:11:52,590
そして、うん、私たちはここを参照してください
それは3を出力するということ

267
00:11:52,590 --> 00:11:55,160
ときに正しい答えは、
実際には、4でなければなりません。

268
00:11:55,160 --> 00:12:01,460
それでは、GDBを入力して、どのように我々を見てみましょう
この問題を修正するに取り掛かることができます。

269
00:12:01,460 --> 00:12:03,992
>> の最初のステップそう
常にあなたのコードのデバッグ

270
00:12:03,992 --> 00:12:05,950
ブレークポイントを設定することで、
で、あなたやポイント

271
00:12:05,950 --> 00:12:09,079
コンピュータまたはたい
デバッガが見て開始します。

272
00:12:09,079 --> 00:12:11,120
だから、あなたが本当にない場合は
あなたの問題が何であるかを知っています、

273
00:12:11,120 --> 00:12:14,670
通常、典型的なものは、私たちがしたいです
行うには、主に私たちのブレークポイントを設定することです。

274
00:12:14,670 --> 00:12:18,520
だから、あなたたちはこれを見ることができれば
右が赤いボタン、

275
00:12:18,520 --> 00:12:22,860
うん、それは私が設定しました
主な機能のためのブレークポイントを設定します。

276
00:12:22,860 --> 00:12:24,130
私はそれをクリックします。

277
00:12:24,130 --> 00:12:26,130
>> そして私は私のデバッグボタンまで行くことができます。

278
00:12:26,130 --> 00:12:27,036
私は、そのボタンを押してください。

279
00:12:27,036 --> 00:12:31,710

280
00:12:31,710 --> 00:12:36,555
私ができるなら、私はズームアウトしてみましょう。

281
00:12:36,555 --> 00:12:38,020
そうしよう。

282
00:12:38,020 --> 00:12:40,730
だから我々は、ここでは、右側のパネルを持っています。

283
00:12:40,730 --> 00:12:43,680
私は、後ろにみんなごめんなさい、あなた
本当に本当によく見ることができません。

284
00:12:43,680 --> 00:12:49,090
しかし、本質的に、すべての
この右側のパネルにはやっています

285
00:12:49,090 --> 00:12:53,130
両方の強調表示を追跡しています
コー​​ドの行である行、

286
00:12:53,130 --> 00:12:56,640
コンピュータは、現在実行されていること、
だけでなく、あなたのすべての変数

287
00:12:56,640 --> 00:12:57,600
ここでダウン。

288
00:12:57,600 --> 00:13:00,487
>> だから、セント、コイン、n個を持って、
すべての異なるものに申告

289
00:13:00,487 --> 00:13:01,070
この時点で。

290
00:13:01,070 --> 00:13:04,850
私たちが実際に持っていないので心配ありません、
まだ変数に初期化。

291
00:13:04,850 --> 00:13:07,200
お使いのコンピュータでだから、あなたの
コンピュータはただ見ています、

292
00:13:07,200 --> 00:13:14,376
ああ、32767は、最後に使用された機能
私のコンピュータにそのメモリ空間の。

293
00:13:14,376 --> 00:13:16,000
セントが現在ある場所となるようです。

294
00:13:16,000 --> 00:13:19,360
しかし、誰それ一度あなたは、コードを実行しません
それは、初期化になるはずです。

295
00:13:19,360 --> 00:13:24,110
>> それでは、通過させ、線で
ラインは、ここで何が起こっています。

296
00:13:24,110 --> 00:13:25,350
OK。

297
00:13:25,350 --> 00:13:29,400
だからここまでの3つがあります
私は説明したボタン。

298
00:13:29,400 --> 00:13:34,090
あなたがプレイ、またはファイル名を指定して実行機能を持っています、
ボタンを押すと、ボタンの上にステップを持っています、

299
00:13:34,090 --> 00:13:36,600
そして、あなたはまた、ボタンにステップを持っています。

300
00:13:36,600 --> 00:13:41,260
そして、基本的に、すべての3つの
彼らは自分のコードを行きます

301
00:13:41,260 --> 00:13:42,690
そして、異なることを行います。

302
00:13:42,690 --> 00:13:45,680
>> だから一般的に、あなたがデバッグしているとき、
私たちは、ただプレイをヒットする必要はありません

303
00:13:45,680 --> 00:13:47,930
プレイはちょうど実行されますので、
それの最後にあなたのコード。

304
00:13:47,930 --> 00:13:49,070
それから、あなたは実際にはしません
知っているあなたの問題

305
00:13:49,070 --> 00:13:51,432
あなたが複数のブレークポイントを設定しない限りです。

306
00:13:51,432 --> 00:13:53,890
あなたは複数のブレークポイントを設定した場合、
それだけで自動的になります

307
00:13:53,890 --> 00:13:56,030
1ブレークポイントから実行し、
次へ、次へ。

308
00:13:56,030 --> 00:13:58,030
しかし、このケースでは、我々はしました
私たちのためだけでは1、

309
00:13:58,030 --> 00:13:59,970
私たちのように動作するようにしたいです
ダウン上から下へ。

310
00:13:59,970 --> 00:14:04,830
だから我々はそのボタンを無視するつもりです
今、このプログラムの目的のために。

311
00:14:04,830 --> 00:14:08,230
>> 関数オーバーステップだから
すべての単一の行をステップオーバー

312
00:14:08,230 --> 00:14:11,510
とを示していますどのような
コンピュータがやっています。

313
00:14:11,510 --> 00:14:14,630
関数へのステップは行きます
実際の関数に

314
00:14:14,630 --> 00:14:16,000
それがコードのあなたのライン上にあります。

315
00:14:16,000 --> 00:14:19,070
ですから、例えば、printfのような（）、
それは右、機能ですか？

316
00:14:19,070 --> 00:14:21,980
私は物理的にステップしたい場合
printf（）関数に、

317
00:14:21,980 --> 00:14:25,610
私は実際の片に行くだろう
printf（）が書かれたコードとを参照してください

318
00:14:25,610 --> 00:14:26,730
何が起こっています。

319
00:14:26,730 --> 00:14:29,924
>> しかし、一般的に、我々はことを前提としてい
私たちはあなたを与えるコードが動作します。

320
00:14:29,924 --> 00:14:31,340
我々は、printfの（）が機能していると仮定します。

321
00:14:31,340 --> 00:14:33,170
私たちは、GetIntでは（）が動作していることを前提としています。

322
00:14:33,170 --> 00:14:35,170
そうする必要はありません
これらの関数にステップイン。

323
00:14:35,170 --> 00:14:37,170
しかし、機能があるかどう
あなたは自分自身を書くこと

324
00:14:37,170 --> 00:14:39,060
確認したいこと
で何が起こっていますか、

325
00:14:39,060 --> 00:14:41,200
あなたがステップしたいです
その関数に。

326
00:14:41,200 --> 00:14:43,940
>> だから今、私たちはちょうどつもりです
コー​​ドのこの部分の上に進みます。

327
00:14:43,940 --> 00:14:44,485
それでは見てみましょう。

328
00:14:44,485 --> 00:14:46,547
ああ、プリント、 "ああ海、どのように
多くの変更が負っているのですか？」

329
00:14:46,547 --> 00:14:47,130
私たちは気にしないでください。

330
00:14:47,130 --> 00:14:49,830
私たちは、それが働いている知っています、
私たちはそれをステップオーバー。

331
00:14:49,830 --> 00:14:53,290
>> だからnは、私たちのフロートであること
我々initialized--またはdeclared--ました

332
00:14:53,290 --> 00:14:56,810
上部にまで、私たちは今です
GetFloatをすることに等しいです（）。

333
00:14:56,810 --> 00:14:57,810
それでは、そのステップオーバーしましょう​​。

334
00:14:57,810 --> 00:14:59,580
そして、我々はでご覧ください
底のここに、プログラム

335
00:14:59,580 --> 00:15:03,360
値の入力に私を促しています。

336
00:15:03,360 --> 00:15:08,580
それでは入力私たちが望む価値を聞かせて
0.41である、ここでテストします。

337
00:15:08,580 --> 00:15:09,160
グレート。

338
00:15:09,160 --> 00:15:12,780
>> だから今N--君たちが見るん
ここで、それはだbottom--で

339
00:15:12,780 --> 00:15:15,140
我々のでstored--
まだ丸められていない、それはです

340
00:15:15,140 --> 00:15:19,540
このような巨大に保存されています
0.4099999996フロート、

341
00:15:19,540 --> 00:15:22,550
私たちに十分近いです
目的、今、0.41に。

342
00:15:22,550 --> 00:15:26,090
そして、我々は、我々のように、後に表示されます
プログラムをステップオーバー続け、

343
00:15:26,090 --> 00:15:29,850
ここでは後に、n個となっています
丸みを帯びたとセントは41となっています。

344
00:15:29,850 --> 00:15:30,350
グレート。

345
00:15:30,350 --> 00:15:32,230
だから我々は我々の丸めの作業ということを知っています。

346
00:15:32,230 --> 00:15:34,700
私たちは持っていることを知っています
セントの正確な数、

347
00:15:34,700 --> 00:15:36,990
私たちはそれがだことを知っています
本当に問題。

348
00:15:36,990 --> 00:15:40,050
>> だから我々は、ステッピング続け​​ます
このプログラムでの。

349
00:15:40,050 --> 00:15:40,900
私たちはここに行きます。

350
00:15:40,900 --> 00:15:46,139
だから、このコード行の後、我々
我々が持っているどのように多くの方面知っている必要があります。

351
00:15:46,139 --> 00:15:46,680
私たちは、ステップオーバー。

352
00:15:46,680 --> 00:15:52,040
そして、あなたは私たちが、実際には、いずれかを持っているかを参照してください。
四半期我々は25を差し引いたから

353
00:15:52,040 --> 00:15:53,790
41の私達の初期値から。

354
00:15:53,790 --> 00:15:55,890
そして、私たちは私たちのセントのための16の左を持っています。

355
00:15:55,890 --> 00:15:58,830
>> 誰もがどのように理解しています
プログラムがステップ実行され

356
00:15:58,830 --> 00:16:02,980
そしてなぜセントは現在16となっています
そしてなぜ、今、硬貨は1となっていますか？

357
00:16:02,980 --> 00:16:04,610
誰もがそのロジックを次のされていますか？

358
00:16:04,610 --> 00:16:05,110
クール。

359
00:16:05,110 --> 00:16:07,860
、この点のように、
プログラムの作業は、右？

360
00:16:07,860 --> 00:16:09,797
我々は、それが正確にやっている知っています
我々はそれをしたいのか。

361
00:16:09,797 --> 00:16:11,880
そして、我々は実際にはしませんでした
プリントアウトする必要があり、ああ、どのような

362
00:16:11,880 --> 00:16:14,430
この時点でセントです、
この時点でコインものです。

363
00:16:14,430 --> 00:16:17,170
>> 私たちは、プログラムを通過続けます。

364
00:16:17,170 --> 00:16:18,100
ステップオーバー。

365
00:16:18,100 --> 00:16:18,620
クール。

366
00:16:18,620 --> 00:16:19,700
私たちは、ダイムの上に行きます。

367
00:16:19,700 --> 00:16:20,200
グレート。

368
00:16:20,200 --> 00:16:22,367
我々は、それがかかったことがわかり
ダイムのための$ 0.10オフ。

369
00:16:22,367 --> 00:16:23,450
そして今、我々は2枚のコインを持っています。

370
00:16:23,450 --> 00:16:25,260
その通りです。

371
00:16:25,260 --> 00:16:31,555
>> 私たちは、ペニーの上に行くと、私たちは見ます
我々はセントの上に残ってしまったこと。

372
00:16:31,555 --> 00:16:32,680
うーん、それは奇妙です。

373
00:16:32,680 --> 00:16:37,540
ここでプログラムでまで、私はなっていました
私のペニーを差し引いています。

374
00:16:37,540 --> 00:16:39,400
おそらく、私はありませんでした
その行を右にやって。

375
00:16:39,400 --> 00:16:42,190
そして残念ながら、あなたが見ることができます
ここで、私たちが知っているので

376
00:16:42,190 --> 00:16:44,360
我々は、強化していること
線32及び33を介して、

377
00:16:44,360 --> 00:16:50,560
それはどこに私たちのプログラムです
不適切な変数は、実行していました。

378
00:16:50,560 --> 00:16:55,136
だから、私たちは見て、ああ、見ることができ、
私はここセントを引いています、

379
00:16:55,136 --> 00:16:57,010
しかし、私は実際にはありませんよ
私のコインの価値を加えること。

380
00:16:57,010 --> 00:16:57,860
私はセントに追加しています。

381
00:16:57,860 --> 00:17:00,234
そして、私はに追加する必要はありません
セントは、私がコインに追加します。

382
00:17:00,234 --> 00:17:05,420
だから我々は、コインのことを変更した場合、
我々は、作業プログラムを持っています。

383
00:17:05,420 --> 00:17:06,730
私はcheck50を実行することができます。

384
00:17:06,730 --> 00:17:11,063
あなたは、GDBの権利を終了することができます
ここにして、再度check50を実行します。

385
00:17:11,063 --> 00:17:11,938
私はこれを行うことができます。

386
00:17:11,938 --> 00:17:14,822

387
00:17:14,822 --> 00:17:18,480
私は欲張りようにする必要があります。

388
00:17:18,480 --> 00:17:19,940
0.41。

389
00:17:19,940 --> 00:17:22,819
そしてここで、印刷です
正解アウト。

390
00:17:22,819 --> 00:17:26,569
>> あなたたちが見ることができるように、GDB
本当に強力なツールです

391
00:17:26,569 --> 00:17:29,940
私たちは多くのコードを持っている場合の
行くと非常に多くの変数

392
00:17:29,940 --> 00:17:32,510
それが私たちのために難しいこと、など
を追跡するために人間。

393
00:17:32,510 --> 00:17:35,360
GDBでコンピュータ、
デバッガは、能力を持っています

394
00:17:35,360 --> 00:17:37,020
すべてのトラックを維持します。

395
00:17:37,020 --> 00:17:40,480
私はおそらくあなたたち、ヴィジョネアで、知っています
いくつかのセグメンテーションフォールトを打った可能性があります

396
00:17:40,480 --> 00:17:43,150
あなたが実行していたので、
あなたの配列の範囲外。

397
00:17:43,150 --> 00:17:46,510
シーザーの例では、それはです
まさに私がここで何実装しました。

398
00:17:46,510 --> 00:17:50,060
>> だから私はのためにチェックするのを忘れました
私ならば何が起こりますか

399
00:17:50,060 --> 00:17:52,510
2つのコマンドライン引数を持っていませんでした。

400
00:17:52,510 --> 00:17:53,880
私はちょうどそのチェックを入れませんでした。

401
00:17:53,880 --> 00:17:57,380
私はDebug--を実行した場合ので、私は設定します
そこに右に私のブレークポイントを設定します。

402
00:17:57,380 --> 00:17:58,055
私は、デバッグを実行します。

403
00:17:58,055 --> 00:18:15,880

404
00:18:15,880 --> 00:18:16,550
>> OK。

405
00:18:16,550 --> 00:18:17,050
うん。

406
00:18:17,050 --> 00:18:20,350
だから実際には、GDBを想定しました
そこに私に言っているように

407
00:18:20,350 --> 00:18:22,300
そこにセグメンテーションフォールトました。

408
00:18:22,300 --> 00:18:24,883
私は何が起こっていたか分かりません
右が、私は、それを実行したとき

409
00:18:24,883 --> 00:18:25,590
それが働いていました。

410
00:18:25,590 --> 00:18:29,410
あなたを介してコードの行を実行するとし、
GDBはちょうど突然、あなたに終了する可能性があります

411
00:18:29,410 --> 00:18:31,540
上がると赤のエラーが何であるかを見てください。

412
00:18:31,540 --> 00:18:33,930
それは、ちょっと、あなたにあなたを教えてあげましょう
セグメンテーションフォールトを持っていました、

413
00:18:33,930 --> 00:18:38,550
これは、あなたがアクセスしようとしたことを意味し
存在しなかった、アレイ内のスペース。

414
00:18:38,550 --> 00:18:39,050
うん。

415
00:18:39,050 --> 00:18:43,280
>> 次の問題でそう
今週設定、君たち

416
00:18:43,280 --> 00:18:45,600
おそらく多くのを持っています
変数が漂っ。

417
00:18:45,600 --> 00:18:48,560
あなたは何を確認するするつもりはありません
それらはすべて、ある時点で意味します。

418
00:18:48,560 --> 00:18:53,560
だから、GDBは本当に把握のお手伝いをします
彼らはすべて等しくされているかを

419
00:18:53,560 --> 00:18:55,940
そして、視覚的にそれを見ることができること。

420
00:18:55,940 --> 00:19:01,995
誰がどのように混乱しています
そのいずれかが働いていましたか？

421
00:19:01,995 --> 00:19:02,495
クール。

422
00:19:02,495 --> 00:19:10,121

423
00:19:10,121 --> 00:19:10,620
大丈夫。

424
00:19:10,620 --> 00:19:14,260
だから後に、我々は、
右のダイビングに行きます

425
00:19:14,260 --> 00:19:17,562
異なる4つに
今週のためのある種のタイプ。

426
00:19:17,562 --> 00:19:19,520
どのように多くのあなたの第一、第
すべての、私たちは始める前に、

427
00:19:19,520 --> 00:19:23,020
pset3のための全体の仕様を読んでいますか？

428
00:19:23,020 --> 00:19:23,824
OK。

429
00:19:23,824 --> 00:19:24,740
私はあなたたちを誇りに思います。

430
00:19:24,740 --> 00:19:29,110
それは、クラスの半分のようにするのです
前回よりはるかに多くのです。

431
00:19:29,110 --> 00:19:33,950
>> だから、素晴らしいことだときのため
私たちは、コンテンツについての話

432
00:19:33,950 --> 00:19:36,170
lecture--か残念で、
section--で私は好き

433
00:19:36,170 --> 00:19:38,210
その多くを関連付けるために
バックPSETが何であるかに

434
00:19:38,210 --> 00:19:40,210
あなたがしたいですか
あなたのpsetのそれを実装します。

435
00:19:40,210 --> 00:19:42,400
だから、あなたが持って来れば
仕様を読んで、それはよ

436
00:19:42,400 --> 00:19:45,510
あなたが理解するためにはるかに簡単です
私が言うとき、私はについて何を話しています、

437
00:19:45,510 --> 00:19:48,720
ちょっとああ、これは本当に可能性があります
このソートを実装するのに適した場所。

438
00:19:48,720 --> 00:19:52,870
読んでいるあなたの人々だから
あなたのpsetの一部として、それを知っている仕様、

439
00:19:52,870 --> 00:19:54,900
あなたがする必要があるとしています
ソートの種類を記述します。

440
00:19:54,900 --> 00:19:58,670
だから、これは非常に有用であろう
あなた方の多く今日のために。

441
00:19:58,670 --> 00:20:01,760
>> だから我々は、から始めましょう、
基本的に、最も単純なタイプ

442
00:20:01,760 --> 00:20:04,580
ソート、選択ソート。

443
00:20:04,580 --> 00:20:06,800
以下のための典型的なアルゴリズム
どのように我々はこのことについていいと思います

444
00:20:06,800 --> 00:20:10,460
ダビデはすべて、これらを経てis--
講演ので、私はすぐに沿って移動します

445
00:20:10,460 --> 00:20:13,900
here--あなたは、本質的に
値の配列を持っています。

446
00:20:13,900 --> 00:20:17,170
そして、あなたが見つけます
最小値はソートされていません

447
00:20:17,170 --> 00:20:20,200
あなたがして、その値を交換します
最初にソートされていない値。

448
00:20:20,200 --> 00:20:22,700
そしてあなただけの繰り返し続けます
あなたのリストの残りの部分と。

449
00:20:22,700 --> 00:20:25,740
>> そして、ここで視覚的な説明です
それがどのように動作するかの。

450
00:20:25,740 --> 00:20:30,460
したがって、たとえば、私たちがあった場合に起動します
5要素の配列は、インデックス付き

451
00:20:30,460 --> 00:20:35,910
3,5、2,6、および4の値を有する0〜4、
そう、今array--に配置され、

452
00:20:35,910 --> 00:20:38,530
私達はちょうど仮定するつもりです
彼らはすべてのソートされていないしていること

453
00:20:38,530 --> 00:20:41,130
我々はそれ以外の場合はテストしていませんので。

454
00:20:41,130 --> 00:20:44,130
>> それでは、どの選択ソートだろう
仕事は、それが最初であろうことです

455
00:20:44,130 --> 00:20:46,800
全体を通して実行
ソートされていない配列の。

456
00:20:46,800 --> 00:20:49,120
これは、最小値を選ぶだろう。

457
00:20:49,120 --> 00:20:51,750
この場合、図3に示すように、右
今、最小です。

458
00:20:51,750 --> 00:20:52,680
それは5になります。

459
00:20:52,680 --> 00:20:55,620
いや、5はthan--大きくありません
または申し訳ありませんが、3 than--少なくありません。

460
00:20:55,620 --> 00:20:57,779
だから、最小値はまだ3です。

461
00:20:57,779 --> 00:20:58,695
そして、あなたは2を取得。

462
00:20:58,695 --> 00:21:00,990
ああ、見ているコンピュータ、2は3未満です。

463
00:21:00,990 --> 00:21:02,750
2は現在、最小値でなければなりません。

464
00:21:02,750 --> 00:21:06,630
そして、その結果、最初の値と2スワップ。

465
00:21:06,630 --> 00:21:10,702
>> だから、1パスの後、我々は確かに見ています
図2及び3が交換されます。

466
00:21:10,702 --> 00:21:13,910
そして、私たちはただやって継続するつもりです
再びこの配列の残りの部分と。

467
00:21:13,910 --> 00:21:17,660
だから我々はちょうどを介して実行するつもりです
配列の最後の4つのインデックス。

468
00:21:17,660 --> 00:21:20,670
私たちは3であることがわかります
次の最小値。

469
00:21:20,670 --> 00:21:23,240
だから我々は4でそれを交換しようとしています。

470
00:21:23,240 --> 00:21:26,900
そして、我々はただ維持するつもりです
あなたは、最終的には、までを通じて実行されています

471
00:21:26,900 --> 00:21:33,730
でソートされた配列を取得
2、3、4、5、及び6は全てソートされます。

472
00:21:33,730 --> 00:21:37,530
誰もが論理を理解して
選択ソートがどのように動作するかの？

473
00:21:37,530 --> 00:21:39,669
>> あなただけのいくつかの並べ替えを持っています
最小値。

474
00:21:39,669 --> 00:21:41,210
あなたはそれが何であるかを追跡することです。

475
00:21:41,210 --> 00:21:45,170
あなたはそれを見つけるたびに、あなたがそれをスワップ
array--の最初の値を持ちます

476
00:21:45,170 --> 00:21:48,740
または、ない最初va​​lue--
配列内の次の値。

477
00:21:48,740 --> 00:21:50,150
クール。

478
00:21:50,150 --> 00:21:55,460
>> だから君たちのような種類の
簡単な垣間見るから見て、

479
00:21:55,460 --> 00:21:58,450
我々はこれを擬似コードするつもりです。

480
00:21:58,450 --> 00:22:02,510
だから後ろに君たちがしたい場合は
テーブルの皆さん、グループを形成

481
00:22:02,510 --> 00:22:06,170
少し相手を形成することができる、私は行きますよ
あなたの3分のような連中を与えるために

482
00:22:06,170 --> 00:22:08,190
ちょうどを通して話をします
ロジック、英語で、

483
00:22:08,190 --> 00:22:14,161
我々は、実施することができるかもしれないのか
選択ソートを書き込むための擬似コード。

484
00:22:14,161 --> 00:22:14,910
そして、お菓子があります。

485
00:22:14,910 --> 00:22:16,118
出てくるとお菓子をゲットしてください。

486
00:22:16,118 --> 00:22:19,520
あなたが後ろにいる、あなたがしたい場合
キャンディは、私はあなたにお菓子を投げることができます。

487
00:22:19,520 --> 00:22:22,850
実際、you--クールを行います。

488
00:22:22,850 --> 00:22:23,552
あ、ごめんなさい。

489
00:22:23,552 --> 00:22:26,751

490
00:22:26,751 --> 00:22:27,250
OK。

491
00:22:27,250 --> 00:25:23,880

492
00:25:23,880 --> 00:25:27,140
>> だから私たちのように、したい場合
クラス、書き込み擬似コード

493
00:25:27,140 --> 00:25:30,466
一つは近づくかもしれない方法について
この問題は、単に自由に感じます。

494
00:25:30,466 --> 00:25:32,340
私は周りに行くとよ、
ために、グループを尋ねます

495
00:25:32,340 --> 00:25:35,065
の次の行のための
私たちは何をする必要があります。

496
00:25:35,065 --> 00:25:37,840
だからみんなが起動する場合
オフ、最初のものは何ですか

497
00:25:37,840 --> 00:25:40,600
あなたがしようとしているときに実行します
このプログラムを解決する方法を実装

498
00:25:40,600 --> 00:25:43,480
選択リストをソートするには？

499
00:25:43,480 --> 00:25:46,349
ちょうど私達を仮定しましょう
配列、すべての権利を持っていますか？

500
00:25:46,349 --> 00:25:49,088
>> 観客：あなたはいくつかを作成したいです
並べ替え[聞こえない]あなたがしていること

501
00:25:49,088 --> 00:25:50,420
あなたの全体の配列を介して実行しています。

502
00:25:50,420 --> 00:25:51,128
>> ANDI PENG：右。

503
00:25:51,128 --> 00:25:54,100
だから、反復処理したいとしています
すべての空間を介して、右か？

504
00:25:54,100 --> 00:26:05,490
だから、素晴らしいです。

505
00:26:05,490 --> 00:26:08,600
あなたたちは私に与えたい場合
次の後ろに、ええline--。

506
00:26:08,600 --> 00:26:11,414

507
00:26:11,414 --> 00:26:13,290
>> 聴衆：それらをチェック
すべての最も小さいため。

508
00:26:13,290 --> 00:26:14,248
>> ANDI PENG：そこに私達は行きます。

509
00:26:14,248 --> 00:26:17,438
だから我々は通過し、にチェックしたいです
右、最小値が何であるかを参照してください？

510
00:26:17,438 --> 00:26:22,110

511
00:26:22,110 --> 00:26:24,840
私はにそれを短縮するつもりだ "分"

512
00:26:24,840 --> 00:26:27,658
あなたたちは、後にはどのように過ごしたいです
あなたが最小値を見つけましたか？

513
00:26:27,658 --> 00:26:28,533
>> 聴衆：[聞こえません]

514
00:26:28,533 --> 00:26:29,942

515
00:26:29,942 --> 00:26:33,150
ANDI PENG：だからあなたがしたいとしています
その配列の最初でそれを切り替えて、

516
00:26:33,150 --> 00:26:33,650
右？

517
00:26:33,650 --> 00:26:45,120

518
00:26:45,120 --> 00:26:46,850
それは私が言うつもりだ、始まりです。

519
00:26:46,850 --> 00:26:47,220
大丈夫。

520
00:26:47,220 --> 00:26:50,386
だから今、あなたが最初にスワップしたこと
1、あなたはそれの後に何をすべきかをしたいですか？

521
00:26:50,386 --> 00:26:54,840
だから今、私たちはここで、このいずれかを知っています
右、最小値でなければなりませんか？

522
00:26:54,840 --> 00:26:58,310
その後、追加の残りの部分を持っています
ソートされていないのです配列の。

523
00:26:58,310 --> 00:27:01,569
だから場合は、ここで何をしたいのか
みんなは私に次の行を与えたいと思いますか？

524
00:27:01,569 --> 00:27:04,610
観客は：だから、あなたは反復したいです
配列の残りの部分を通って。

525
00:27:04,610 --> 00:27:05,276
ANDI PENG：うん。

526
00:27:05,276 --> 00:27:09,857
だから何が繰り返し処理ん
種類の我々は、おそらく必要があります意味するものでは？

527
00:27:09,857 --> 00:27:10,440
どのようなタイプof--

528
00:27:10,440 --> 00:27:12,057
>> 聴衆：ああ、追加の変数？

529
00:27:12,057 --> 00:27:13,890
ANDI PENG：おそらく
別のループのために、右？

530
00:27:13,890 --> 00:27:28,914
だから我々は、おそらくするつもりです
through--偉大を反復します。

531
00:27:28,914 --> 00:27:31,830
そして、あなたが戻って行くつもりです
おそらく再び最小値をチェックし、

532
00:27:31,830 --> 00:27:32,100
右？

533
00:27:32,100 --> 00:27:34,975
そして、あなたは繰り返し続けるつもりです
この、ループがちょうど行くので、

534
00:27:34,975 --> 00:27:36,010
右、走り続けるには？

535
00:27:36,010 --> 00:27:39,190
>> だから、あなたたちは、私たちを見ることができるように
ただ、一般的な擬似コードを持っています

536
00:27:39,190 --> 00:27:41,480
私たちはこのプログラムを見てみたいかの。

537
00:27:41,480 --> 00:27:46,646
これはここで繰り返す、我々は何をすべきか
一般的に私たちのコードで記述する必要があります

538
00:27:46,646 --> 00:27:49,270
私たちはを反復処理する場合
構造体の配列、どのタイプ？

539
00:27:49,270 --> 00:27:51,030
私はクリスタベルを考えます
すでに、これは前にも言いました。

540
00:27:51,030 --> 00:27:51,500
>> 聴衆：forループ。

541
00:27:51,500 --> 00:27:52,160
>> ANDI PENG：forループのA？

542
00:27:52,160 --> 00:27:52,770
その通りです。

543
00:27:52,770 --> 00:27:56,060
だから、これはおそらくです
ループのためになるだろう。

544
00:27:56,060 --> 00:27:59,240
暗示するつもりはここでチェックとは何ですか？

545
00:27:59,240 --> 00:28:02,536
通常、チェックしたい場合は
何かが何かある場合else--

546
00:28:02,536 --> 00:28:03,270
>> 聴衆：もし。

547
00:28:03,270 --> 00:28:06,790
>> ANDI PENG：アン場合、右？

548
00:28:06,790 --> 00:28:10,790
ここスワップそして、我々はよ
後で越える、デビッドので、

549
00:28:10,790 --> 00:28:12,770
同様に講義のそれを通り抜けました。

550
00:28:12,770 --> 00:28:14,580
そして、第二の反復implies--

551
00:28:14,580 --> 00:28:15,120
>> 聴衆：ループのための別。

552
00:28:15,120 --> 00:28:16,745
>> ANDI PENG：正確には、forループ--another。

553
00:28:16,745 --> 00:28:19,870

554
00:28:19,870 --> 00:28:22,000
だから私たちは探しているなら
正しくこの時、我々

555
00:28:22,000 --> 00:28:24,680
我々は、おそらくしていることがわかります
ループのネストされたが必要になります

556
00:28:24,680 --> 00:28:28,330
そこには条件文と
コー​​ドのと、実際の作品

557
00:28:28,330 --> 00:28:31,360
値を交換する予定。

558
00:28:31,360 --> 00:28:35,980
だから、僕は、一般的に書いています
ここで擬似コードコード。

559
00:28:35,980 --> 00:28:38,910
そして、我々は実際に行っています
物理的に、クラスとして、

560
00:28:38,910 --> 00:28:40,700
今日はこれを実装してみてください。

561
00:28:40,700 --> 00:28:42,486
それでは、このIDEに戻りましょう。

562
00:28:42,486 --> 00:28:49,243

563
00:28:49,243 --> 00:28:50,230
>> おっと。

564
00:28:50,230 --> 00:28:51,754
なぜそこnot--それがあるということです。

565
00:28:51,754 --> 00:28:52,253
OK。

566
00:28:52,253 --> 00:28:55,834

567
00:28:55,834 --> 00:28:57,500
申し訳ありませんが、私はもう少しでズームしてみましょう。

568
00:28:57,500 --> 00:28:59,310
そうしよう。

569
00:28:59,310 --> 00:29:05,060
私はここでやっているすべては私が作成したあ​​ります
呼び出されたプログラム「選択/ sort.c。」

570
00:29:05,060 --> 00:29:10,860
私は9の配列を作成しました
値は、4、8、2、1、6、9、7、5、3。

571
00:29:10,860 --> 00:29:14,370
現時点では、することができますように
彼らは順序付けられていない、参照してください。

572
00:29:14,370 --> 00:29:17,880
nが、その数になるだろう
あなたの値の量を指示します

573
00:29:17,880 --> 00:29:18,920
あなたの配列を持っています。

574
00:29:18,920 --> 00:29:20,670
ここでは、9つの値を持っています。

575
00:29:20,670 --> 00:29:23,760
そして、私はちょうどここにループのため持っています
それは、ソートされていない配列を出力します。

576
00:29:23,760 --> 00:29:28,370
>> そして最後に、私はまたのために持っています
もう一度それをプリントアウトするループ。

577
00:29:28,370 --> 00:29:32,070
だから理論的には、このプログラムの場合
最後に、正しく動作しています、

578
00:29:32,070 --> 00:29:35,670
あなたはループのために印刷表示されるはずです
これは1、2、3、4、5、6、7、8、

579
00:29:35,670 --> 00:29:39,310
図9は、ために、すべて正常です。

580
00:29:39,310 --> 00:29:43,410
>> だから我々はここで私たちの擬似コードを持っています。

581
00:29:43,410 --> 00:29:46,090
私はちょうどよto--誰もが欲しいん
volunteers--を求めるに行くつもり

582
00:29:46,090 --> 00:29:49,540
場合入力する正確に何を教えて
我々は、まず、単に反復したいです

583
00:29:49,540 --> 00:29:52,840
この配列の先頭を介して？

584
00:29:52,840 --> 00:29:55,204
私はコードの行は何ですか
おそらく、ここで必要になるだろうか？

585
00:29:55,204 --> 00:29:56,990
>> 聴衆：[聞こえません]

586
00:29:56,990 --> 00:29:59,010
>> ANDI PENG：ええ、感じ
あなたは、残念to--無料

587
00:29:59,010 --> 00:30:02,318
up--感触を我慢する必要はありません
あなたの声ビットを上げて自由。

588
00:30:02,318 --> 00:30:08,190
>> 聴衆：int型のために私が等しく0--

589
00:30:08,190 --> 00:30:10,690
>> ANDI PENG：うん、良いです。

590
00:30:10,690 --> 00:30:15,220
>> 聴衆：私は、配列の長さよりも小さいです。

591
00:30:15,220 --> 00:30:19,630
>> ANDI PENG：だからでおきます
我々ので、ここでは気に

592
00:30:19,630 --> 00:30:23,060
その機能を持っていません
私たちの配列の長さを指示し、

593
00:30:23,060 --> 00:30:25,790
我々はすでに持っています
それを格納した値。

594
00:30:25,790 --> 00:30:27,920
右？

595
00:30:27,920 --> 00:30:31,010
もう一つは、維持します
配列内のmind--で

596
00:30:31,010 --> 00:30:33,940
9つの値のうち、インデックスは何ですか？

597
00:30:33,940 --> 00:30:38,720
ちょうどこの配列は、0〜3であったとしましょう​​。

598
00:30:38,720 --> 00:30:41,500
あなたは最後のことを見ます
インデックスは、実際には3です。

599
00:30:41,500 --> 00:30:45,530
それはそこだとしても、4ではありません
配列の4つの値。

600
00:30:45,530 --> 00:30:49,866
>> そこでここでは、我々は非常に注意する必要があります
長さのためにどのような私たちの条件の

601
00:30:49,866 --> 00:30:50,490
なるだろう。

602
00:30:50,490 --> 00:30:51,948
>> 観客は：それは、nマイナス1になると思いませんか？

603
00:30:51,948 --> 00:30:54,440
ANDI PENG：それが起こっています
ちょうどnマイナス1、。

604
00:30:54,440 --> 00:30:57,379
そのメイク感覚、なぜ
それは、みんなのnはマイナス1？

605
00:30:57,379 --> 00:30:58,920
配列はゼロがインデックスされているからです。

606
00:30:58,920 --> 00:31:02,010
彼らは、0から開始し、1からnマイナスまで実行します。

607
00:31:02,010 --> 00:31:03,210
ええ、それは少しトリッキーです。

608
00:31:03,210 --> 00:31:03,730
OK。

609
00:31:03,730 --> 00:31:05,929
その後 - 

610
00:31:05,929 --> 00:31:08,054
聴衆：Isnt'1こと
すでにかかわらの世話をし、

611
00:31:08,054 --> 00:31:11,400
単に "より小さいかを言っていないことにより、
等しい」とだけ言って「より小さい？」

612
00:31:11,400 --> 00:31:13,108
>> ANDI PENG：それは
本当に良い質問です。

613
00:31:13,108 --> 00:31:13,630
だから、はい。

614
00:31:13,630 --> 00:31:17,410
しかし、また、私たちがしている方法
チェック権利を実装し、

615
00:31:17,410 --> 00:31:19,120
あなたは、2つの値を比較する必要があります。

616
00:31:19,120 --> 00:31:21,009
だから、実際にしたいです
」を「空のままにしておきます。

617
00:31:21,009 --> 00:31:23,050
あなたは比較する場合ので、
これは、あなたがつもりはありません

618
00:31:23,050 --> 00:31:25,530
それの後に何を持っています
右に比較するには？

619
00:31:25,530 --> 00:31:27,460
うん。

620
00:31:27,460 --> 00:31:29,297
だから私は++しました。

621
00:31:29,297 --> 00:31:30,380
それでは、私たちの中にブラケットを追加してみましょう。

622
00:31:30,380 --> 00:31:30,880
おっと。

623
00:31:30,880 --> 00:31:33,950

624
00:31:33,950 --> 00:31:34,710
グレート。

625
00:31:34,710 --> 00:31:39,117
だから我々は始まりを持っています
私たちの外側のループの。

626
00:31:39,117 --> 00:31:41,450
だから今、私たちはおそらくしたいです
維持するための変数を作成

627
00:31:41,450 --> 00:31:43,085
最小値のトラック、右？

628
00:31:43,085 --> 00:31:45,751
誰も私に与えたいと思うん
それを行うことになるコードの行？

629
00:31:45,751 --> 00:31:48,700

630
00:31:48,700 --> 00:31:53,570
私たちが行っている場合は、私たちは何が必要です
何かを保存するには？

631
00:31:53,570 --> 00:31:55,047
>> 右。

632
00:31:55,047 --> 00:31:57,630
そのためたぶん良い名前
「TEMP」は全くworks-- be--う

633
00:31:57,630 --> 00:32:00,655
多分より適切になるであろうという名前の、
私たちは最小value--が必要な場合

634
00:32:00,655 --> 00:32:01,624
>> 聴衆：ミン。

635
00:32:01,624 --> 00:32:02,790
ANDI PENG：分、そこに私達は行きます。

636
00:32:02,790 --> 00:32:05,230
minが良いでしょう。

637
00:32:05,230 --> 00:32:08,340
だからここで、我々は何をすべきか
それを初期化したいですか？

638
00:32:08,340 --> 00:32:09,620
これは少しトリッキーです。

639
00:32:09,620 --> 00:32:13,580
そのため、今で
この配列の先頭、

640
00:32:13,580 --> 00:32:15,730
あなたは正しい、何を見ていませんか？

641
00:32:15,730 --> 00:32:19,200
それで自動的に何、あれば
我々は、ちょうど私が0に等しいにしています

642
00:32:19,200 --> 00:32:22,302
我々は、初期化するために何をしたいです
に私たちの最初の最小値はありますか？

643
00:32:22,302 --> 00:32:22,802
聴衆：私。

644
00:32:22,802 --> 00:32:24,790
ANDI PENG：私、丁度。

645
00:32:24,790 --> 00:32:27,040
クリスタベル、なぜ私たちがしたいです
私にそれを初期化するには？

646
00:32:27,040 --> 00:32:28,510
>> 聴衆：よく、そのため、
我々は0で開始しています。

647
00:32:28,510 --> 00:32:31,660
だから我々は、比較することは何もありませんので、
それは、最小値は0になってしまうでしょうします。

648
00:32:31,660 --> 00:32:32,451
>> ANDI PENG：その通り。

649
00:32:32,451 --> 00:32:34,400
そこで彼女は、まさにそうです。

650
00:32:34,400 --> 00:32:36,780
私たちは実際には持っていないので
まだ何も見て、

651
00:32:36,780 --> 00:32:38,680
私たちは最小値が何であるかを知りません。

652
00:32:38,680 --> 00:32:41,960
私達はちょうどそれを初期化します
私は、これは、現在、右ここにあります。

653
00:32:41,960 --> 00:32:44,750
そして、私たちはし続けています
この配列を下に移動、

654
00:32:44,750 --> 00:32:48,122
私たちは、それぞれに、それを参照してくださいよ
追加のパス、私は増加します。

655
00:32:48,122 --> 00:32:49,830
だからその時点で、
私はおそらく起こっています

656
00:32:49,830 --> 00:32:52,329
最小になりたいために、
それはどのようなことになるだろうので、

657
00:32:52,329 --> 00:32:54,520
ソートされていない配列の始まりです。

658
00:32:54,520 --> 00:32:55,270
クール。

659
00:32:55,270 --> 00:32:58,720
>> だから今、私たちは追加したいです
それだ、ここでループのために

660
00:32:58,720 --> 00:33:03,225
反復処理しようとして
ソートされていない、またはこの配列の残りの部分。

661
00:33:03,225 --> 00:33:05,808
誰も私に与えたいと思うん
それを行うことになるコードの行？

662
00:33:05,808 --> 00:33:08,870

663
00:33:08,870 --> 00:33:11,330
Hint--我々はここで何を下に必要なのでしょうか？

664
00:33:11,330 --> 00:33:17,320

665
00:33:17,320 --> 00:33:18,820
何ループのためにこれに行くために起こっているのですか？

666
00:33:18,820 --> 00:33:19,465
うん。

667
00:33:19,465 --> 00:33:21,590
聴衆：だから我々がしたいと思います
異なる整数値を有します

668
00:33:21,590 --> 00:33:25,080
我々は残りを実行しているので、
配列の代わりに私、ので、多分

669
00:33:25,080 --> 00:33:25,760
J。

670
00:33:25,760 --> 00:33:27,301
>> ANDI PENG：うん、jは私にはいいですね。

671
00:33:27,301 --> 00:33:27,850
等しいですか？

672
00:33:27,850 --> 00:33:33,930
>> 聴衆：だからので、私プラス1になります
あなたは、次の値で開始しています。

673
00:33:33,930 --> 00:33:40,395
そして、そのように再びend--に、jがあります
nはマイナス1、次にJ ++未満。

674
00:33:40,395 --> 00:33:41,103
ANDI PENG：グレート。

675
00:33:41,103 --> 00:33:48,510

676
00:33:48,510 --> 00:33:52,750
>> そしてここで、我々はするつもりです
私たちの条件が満たされるかどうかを確認するために、

677
00:33:52,750 --> 00:33:53,250
右？

678
00:33:53,250 --> 00:33:55,740
あなたがしたいので、
最小値を変更します

679
00:33:55,740 --> 00:33:58,700
それは何よりも実際に小さいだ場合
あなたは正しい、それを比較していますか？

680
00:33:58,700 --> 00:34:01,146
それでは、私たちはここで必要としていますか？

681
00:34:01,146 --> 00:34:04,160

682
00:34:04,160 --> 00:34:04,897
確認してください。

683
00:34:04,897 --> 00:34:06,730
文のどのような種類
我々は、おそらく行きます

684
00:34:06,730 --> 00:34:08,389
TIは、私たちならば利用したいです
何かを確認したいですか？

685
00:34:08,389 --> 00:34:09,360
>> 聴衆：if文。

686
00:34:09,360 --> 00:34:10,485
>> ANDI PENG：if文。

687
00:34:10,485 --> 00:34:13,155
だからif--となるように何が起こっていますか
我々は内側する条件

688
00:34:13,155 --> 00:34:13,988
私たちのif文の？

689
00:34:13,988 --> 00:34:18,255

690
00:34:18,255 --> 00:34:22,960
>> 者：jの値の場合
i--の値よりも小さいです

691
00:34:22,960 --> 00:34:24,600
>> ANDI PENG：その通り。

692
00:34:24,600 --> 00:34:27,480
だからif--ので、この配列には、「アレイ」と呼ばれています。

693
00:34:27,480 --> 00:34:27,980
グレート。

694
00:34:27,980 --> 00:34:30,465
その場合はそれが何でしたかarray--？

695
00:34:30,465 --> 00:34:31,090
もう一度言って。

696
00:34:31,090 --> 00:34:39,590
>> 対象：配列-jは未満である場合
配列-iは、我々は分を変更します。

697
00:34:39,590 --> 00:34:41,590
だから分がjになります。

698
00:34:41,590 --> 00:34:44,590

699
00:34:44,590 --> 00:34:47,249
>> ANDI PENG：意味がありますか？

700
00:34:47,249 --> 00:34:48,670
OK。

701
00:34:48,670 --> 00:34:52,929
そして今ダウンここで、実際に我々
右、スワップを実現したいですか？

702
00:34:52,929 --> 00:34:58,285
それでダビデは、ときに、講義では、リコール
彼が何であったかthe--を交換しようとしていました

703
00:34:58,285 --> 00:34:59,996
オレンジジュースit--とmilk--

704
00:34:59,996 --> 00:35:01,150
>> 聴衆：グロスでした。

705
00:35:01,150 --> 00:35:02,816
>> ANDI鵬：ええ、それはグロスのようなものでした。

706
00:35:02,816 --> 00:35:05,310
しかし、それはかなり良かったです
概念は、時間を実証します。

707
00:35:05,310 --> 00:35:08,430
だからここに自分の価値観を考えます。

708
00:35:08,430 --> 00:35:10,794
あなたは配列を持っています
分の、私の配列、

709
00:35:10,794 --> 00:35:12,460
または何でも私たちはここで交換しようとしていました。

710
00:35:12,460 --> 00:35:15,310
そして、あなたはおそらくにそれらを注ぐことができません
同時に互いに、右？

711
00:35:15,310 --> 00:35:17,180
だから我々は何を行っています
ここで作成する必要がありますするには

712
00:35:17,180 --> 00:35:19,126
正しく値を交換するためには？

713
00:35:19,126 --> 00:35:19,820
>> 聴衆：一時変数。

714
00:35:19,820 --> 00:35:21,370
>> ANDI PENG：一時変数。

715
00:35:21,370 --> 00:35:22,570
それでは、int型の温度を行うことができます。

716
00:35:22,570 --> 00:35:25,681
参照してください、これは良いだろう
ちょっと待ってto--時間は、それは何でしたか？

717
00:35:25,681 --> 00:35:26,180
OK。

718
00:35:26,180 --> 00:35:29,800
だから、これはもっと良かったはずです
変数名には時間 "一時を。」

719
00:35:29,800 --> 00:35:30,730
それでは、int型の温度を行うことができます。

720
00:35:30,730 --> 00:35:32,563
私たちがしようとしています
ここに等しく設定の一時？

721
00:35:32,563 --> 00:35:34,752

722
00:35:34,752 --> 00:35:35,335
聴衆：ミン？

723
00:35:35,335 --> 00:35:38,508

724
00:35:38,508 --> 00:35:39,716
ANDI PENG：それは少しトリッキーです。

725
00:35:39,716 --> 00:35:43,110

726
00:35:43,110 --> 00:35:44,880
これは、実際に最終的には関係ありません。

727
00:35:44,880 --> 00:35:47,690
これは、何が問題ではありません。
順序をスワップすることを選択します

728
00:35:47,690 --> 00:35:50,862
限り、あなたはあなたがしている作っているよう
あなたがスワッピングしているものを追跡します。

729
00:35:50,862 --> 00:35:52,250
>> 観客：それは配列-iの可能性があります。

730
00:35:52,250 --> 00:35:53,666
>> ANDI PENG：うん、の配列-Iを行うことができます。

731
00:35:53,666 --> 00:35:55,950

732
00:35:55,950 --> 00:35:59,305
そして、次の行は何ですか
コー​​ドの私たちはここに持っていたいですか？

733
00:35:59,305 --> 00:36:00,680
聴衆：配列-iは、アレイ-Jに等しいです。

734
00:36:00,680 --> 00:36:07,154

735
00:36:07,154 --> 00:36:08,070
ANDI PENG：そして最後に？

736
00:36:08,070 --> 00:36:12,070
聴衆：配列-jは、アレイ-Iに等しいです。

737
00:36:12,070 --> 00:36:14,525
聴衆：または配列-Jイコール
アレイtemp--または、一時。

738
00:36:14,525 --> 00:36:17,135

739
00:36:17,135 --> 00:36:19,430
>> ANDI PENG：[OK]をクリックします。

740
00:36:19,430 --> 00:36:21,510
それでは、これを実行して見てみましょう
それが動作するように起こっている場合。

741
00:36:21,510 --> 00:36:37,520

742
00:36:37,520 --> 00:36:39,335
ことはどこに起こっているのでしょうか？

743
00:36:39,335 --> 00:36:40,210
ああ、それが問題です。

744
00:36:40,210 --> 00:36:44,320
私たちがしている、ライン40上に、参照してください。
配列-Jを使用しようとしていますか？

745
00:36:44,320 --> 00:36:47,022
しかし、ここでjはのみに存在していますか？

746
00:36:47,022 --> 00:36:48,402
>> 聴衆：forループで。

747
00:36:48,402 --> 00:36:49,110
ANDI PENG：右。

748
00:36:49,110 --> 00:36:51,730
だから、私たちは何をする必要がありますするつもりですか？

749
00:36:51,730 --> 00:36:53,170
>> 聴衆：the--外に定義します

750
00:36:53,170 --> 00:36:57,777

751
00:36:57,777 --> 00:37:00,610
聴衆：ええ、私はあなたが持っていると思います
if文の右、別のものを使用するには？

752
00:37:00,610 --> 00:37:05,230
だからのような、場合minimum--
すべての権利、私は考えてみましょう。

753
00:37:05,230 --> 00:37:08,170

754
00:37:08,170 --> 00:37:09,990
>> ANDI PENG：みんな、みてください
外観レッツを取ります

755
00:37:09,990 --> 00:37:11,270
我々はここで行うことができるものです何を参照してください？

756
00:37:11,270 --> 00:37:11,811
>> 聴衆：[OK]をクリックします。

757
00:37:11,811 --> 00:37:15,900
だから、最小値が等しくない場合
最小である場合にj--のでまだi--

758
00:37:15,900 --> 00:37:17,570
その後、我々は交換する必要がありません。

759
00:37:17,570 --> 00:37:22,450

760
00:37:22,450 --> 00:37:24,712
>> ANDI PENG：それ同等の私はいますか？

761
00:37:24,712 --> 00:37:25,920
何がここで言いたいのですか？

762
00:37:25,920 --> 00:37:30,494
>> 聴衆：またはええ、もし
最小値はええ、私と同じではありません。

763
00:37:30,494 --> 00:37:39,627

764
00:37:39,627 --> 00:37:40,210
ANDI PENG：[OK]をクリックします。

765
00:37:40,210 --> 00:37:42,040
まあそれは、この種の、私たちの問題を解決します。

766
00:37:42,040 --> 00:37:47,265
しかし、それはまだ解決していません。
J以来j--場合に何が起こるかの問題

767
00:37:47,265 --> 00:37:49,890
何、それの外に存在しません
あなたは私たちがそれをどうしますか？

768
00:37:49,890 --> 00:37:50,698
外それを宣言？

769
00:37:50,698 --> 00:37:59,410

770
00:37:59,410 --> 00:38:02,730
それでは、このを実行してみましょう。

771
00:38:02,730 --> 00:38:04,435
おっと。

772
00:38:04,435 --> 00:38:06,200
私たちのソートが機能していません。

773
00:38:06,200 --> 00:38:10,060
>> あなたは、私たちの最初のを見ることができるように
配列は、それらの値を持っていました。

774
00:38:10,060 --> 00:38:14,800
そして、その後それが持っている必要があります
1、2、3、4、5、6、7、8、9であっ。

775
00:38:14,800 --> 00:38:15,530
それは働いていません。

776
00:38:15,530 --> 00:38:16,030
ああ。

777
00:38:16,030 --> 00:38:17,184
私たちは何をしますか？

778
00:38:17,184 --> 00:38:17,850
聴衆：デバッグ。

779
00:38:17,850 --> 00:38:21,787

780
00:38:21,787 --> 00:38:23,370
ANDI PENG：すべての権利、私たちはそれを試すことができます。

781
00:38:23,370 --> 00:38:25,030
私たちは、デバッグすることができます。

782
00:38:25,030 --> 00:38:26,042
少しズームアウト。

783
00:38:26,042 --> 00:38:31,177

784
00:38:31,177 --> 00:38:33,656
私たちのブレークポイントを設定してみましょう。

785
00:38:33,656 --> 00:38:37,280
のがOK like--行きましょう。

786
00:38:37,280 --> 00:38:40,444
>> だから我々はすでにそれを知っているので、
これらの線、15〜22、

787
00:38:40,444 --> 00:38:43,610
私がやっているすべてであるためworking--されています
ちょうどを反復処理し、printing--

788
00:38:43,610 --> 00:38:45,406
私が先に行くとそれをスキップすることができます。

789
00:38:45,406 --> 00:38:47,280
ライン25で開始してみましょう。

790
00:38:47,280 --> 00:38:48,712
OOPは、私はそのを取り除くましょう。

791
00:38:48,712 --> 00:38:51,598

792
00:38:51,598 --> 00:38:54,057
>> 聴衆：だからブレークポイントの
デバッグが始まりますか？

793
00:38:54,057 --> 00:38:54,890
ANDI PENG：または停止しました。

794
00:38:54,890 --> 00:38:55,670
聴衆：または停止しました。

795
00:38:55,670 --> 00:38:55,930
ANDI PENG：うん。

796
00:38:55,930 --> 00:38:58,640
あなたは、複数のブレークポイントを設定することができますし、
それだけで一方から他方へジャンプすることができます。

797
00:38:58,640 --> 00:39:01,590
しかし、このケースでは、我々は知りません
どこでエラーが起こっています。

798
00:39:01,590 --> 00:39:03,780
だから我々はちょうどしたいです
トップダウンからのスタート。

799
00:39:03,780 --> 00:39:05,020
うん。

800
00:39:05,020 --> 00:39:05,550
OK。

801
00:39:05,550 --> 00:39:08,460
>> そこでここでは、この行は、我々がでステップ実行することができます。

802
00:39:08,460 --> 00:39:11,499
あなたは、ここでダウンして見ることができます
我々は配列を持っています。

803
00:39:11,499 --> 00:39:13,290
それらは値であり、
アレイ内にあること。

804
00:39:13,290 --> 00:39:16,360
あなたが、どのようにインデックス0、それ参照しています
ああvalue--に対応し、

805
00:39:16,360 --> 00:39:17,526
私はズームインしようとするつもりです。

806
00:39:17,526 --> 00:39:20,650
申し訳ありませんが、それは本当に難しいです
配列のインデックス0でsee--します、

807
00:39:20,650 --> 00:39:24,090
我々は、4の値を有し、そして
その後、などのように。

808
00:39:24,090 --> 00:39:25,670
私たちは、ローカル変数を持っています。

809
00:39:25,670 --> 00:39:28,570
今、私はに等しいです。
我々はそれになりたい0、。

810
00:39:28,570 --> 00:39:31,540

811
00:39:31,540 --> 00:39:33,690
>> そしてそうのが通過ステッピング維持させます。

812
00:39:33,690 --> 00:39:36,850
私たちの最小値は0に等しく、
これは私たちもそれになりたいです。

813
00:39:36,850 --> 00:39:39,470

814
00:39:39,470 --> 00:39:45,560
そして、私たちは私たちの第二を入力してください
ループ配列-jは配列-Iよりも小さい場合、

815
00:39:45,560 --> 00:39:46,380
これはそうではありませんでした。

816
00:39:46,380 --> 00:39:48,130
だから、どのように見ました
それはその上をスキップ？

817
00:39:48,130 --> 00:39:52,430
>> 聴衆：だからべきか
最低限、すべてのthat--べきではないこと

818
00:39:52,430 --> 00:39:55,424
ループの最初の内側にありますか？

819
00:39:55,424 --> 00:39:57,340
ANDI PENG：いいえ、なぜなら
あなたはまだテストしたいです。

820
00:39:57,340 --> 00:40:00,329
あなたは、すべての比較をしたいです
時間、あなたはそれを介して実行した後でも。

821
00:40:00,329 --> 00:40:02,620
あなたはそれを行うにはしたくありません
最初のパス・スルーに。

822
00:40:02,620 --> 00:40:05,240
あなたはでそれをやってみたいです
再び各追加パス。

823
00:40:05,240 --> 00:40:07,198
だからかどうかを確認したいです
内部のあなたの状態。

824
00:40:07,198 --> 00:40:11,610

825
00:40:11,610 --> 00:40:13,746
だから我々はちょうどしようとしています
ここを走り続けます。

826
00:40:13,746 --> 00:40:17,337

827
00:40:17,337 --> 00:40:18,420
私はあなたたちにヒントを与えるでしょう。

828
00:40:18,420 --> 00:40:23,910
それは時という事実に関係しています
あなたは、あなたの条件をチェックしています

829
00:40:23,910 --> 00:40:26,600
あなたがチェックしていません
正しいインデックスの。

830
00:40:26,600 --> 00:40:32,510
だから、今あなたがチェックしています
jの配列インデックスが配列よりも小さいです

831
00:40:32,510 --> 00:40:33,970
私のインデックス。

832
00:40:33,970 --> 00:40:36,580
しかし、あなたはで何をやっています
forループの始まり？

833
00:40:36,580 --> 00:40:38,260
あなたは私に等しいJを設定していませんか？

834
00:40:38,260 --> 00:40:41,260

835
00:40:41,260 --> 00:40:45,415
>> ええ、私たちは実際にすることができます
ここで、デバッガを終了します。

836
00:40:45,415 --> 00:40:47,040
それでは、私たちの擬似コードを見てみましょう。

837
00:40:47,040 --> 00:40:50,070

838
00:40:50,070 --> 00:40:52,580
我々はするつもりですFor--
私は0に等しいから始まります。

839
00:40:52,580 --> 00:40:54,760
私たちは、1からnマイナスまで行くつもりです。

840
00:40:54,760 --> 00:40:58,040
それでは、確認してみましょう、我々は正しいことをしていたのですか？

841
00:40:58,040 --> 00:40:59,580
うん、それは正しかったです。

842
00:40:59,580 --> 00:41:02,080
>> それでは、ここで内側に、私たちはしています
最小値を作成するつもり

843
00:41:02,080 --> 00:41:03,630
私にそれが等しくなるように設定。

844
00:41:03,630 --> 00:41:04,950
我々はそれをしましたか？

845
00:41:04,950 --> 00:41:06,270
うん、それをしました。

846
00:41:06,270 --> 00:41:10,430
現在、私たちの内側のためのループでは、我々はしています
Jをするつもりは、iがnはマイナス1に等しいです。

847
00:41:10,430 --> 00:41:11,950
我々はそれをしましたか？

848
00:41:11,950 --> 00:41:15,540
確かに、我々はそれをしました。

849
00:41:15,540 --> 00:41:19,922
>> だからしかし、我々はここで何を比較していますか？

850
00:41:19,922 --> 00:41:20,925
>> 聴衆：Jプラス1。

851
00:41:20,925 --> 00:41:21,716
ANDI PENG：その通り。

852
00:41:21,716 --> 00:41:24,184

853
00:41:24,184 --> 00:41:27,350
そして、あなたが設定したいとしています
Jプラス1と同様に等しいあなたの最小値。

854
00:41:27,350 --> 00:41:31,057

855
00:41:31,057 --> 00:41:32,640
だから私は本当にすぐにそれを経​​験しました。

856
00:41:32,640 --> 00:41:36,190
あなたたちは理解しています
なぜそれがjプラス1ですか？

857
00:41:36,190 --> 00:41:36,890
OK。

858
00:41:36,890 --> 00:41:40,700
>> だからあなたのアレイでは、中
あなたの最初のパス、

859
00:41:40,700 --> 00:41:44,850
あなたのループのために、int型のため
私は0に等しい、ちょうどしてみましょう

860
00:41:44,850 --> 00:41:46,740
これはまだ変更されていないと仮定します。

861
00:41:46,740 --> 00:41:53,180

862
00:41:53,180 --> 00:41:56,760
我々は、完全に、の配列を有します
わずか4ソートされていない要素は、右？

863
00:41:56,760 --> 00:42:00,760
だから私たちは私が0に等しい初期化したいです。

864
00:42:00,760 --> 00:42:03,650
そして、私はちょうどしようとしています
このループを実行します。

865
00:42:03,650 --> 00:42:08,560
だから最初のパスでは、我々が行っています
"分"と呼ばれる変数を初期化します

866
00:42:08,560 --> 00:42:11,245
そのためにも、私に等しいです
私たちは、最小値を持っていません。

867
00:42:11,245 --> 00:42:12,870
だから、同様に0に現在と同じです。

868
00:42:12,870 --> 00:42:16,182

869
00:42:16,182 --> 00:42:17,640
そして、我々が通過しようとしています。

870
00:42:17,640 --> 00:42:19,270
そして、私たちは再び反復したいと思います。

871
00:42:19,270 --> 00:42:22,900
今、私たちは見つけたことをどのような私たちの最小
我々は反復処理したいです

872
00:42:22,900 --> 00:42:25,190
それは右、比較だ場合には、再度参照してくださいするには？

873
00:42:25,190 --> 00:42:40,440
だからjは、ここでは、起こっています
同じ私に、0です。

874
00:42:40,440 --> 00:42:46,320
そして、アレイJプラス私の場合、これは
以下のように、次の終わったものです

875
00:42:46,320 --> 00:42:49,270
何あなたの現在の最小値よりも
値はあなたが交換したいです。

876
00:42:49,270 --> 00:42:56,850
>> それでは、ちょうど私達がしたとします。
2、5、1、8、のようになりました。

877
00:42:56,850 --> 00:43:01,610
今、私はに等しいです。
0およびjは0に等しいです。

878
00:43:01,610 --> 00:43:05,210
そして、それは私たちの最小値です。

879
00:43:05,210 --> 00:43:09,950
配列-Jの場合プラスi-- 1もしそうであれば
それは、私たちが見ているものの後です

880
00:43:09,950 --> 00:43:13,450
それ以前に1よりも大きいです、
それが最小となるだろう。

881
00:43:13,450 --> 00:43:18,120
>> そこでここでは、5ていることがわかり
それ以上です。

882
00:43:18,120 --> 00:43:19,730
だから、5にならないだろう。

883
00:43:19,730 --> 00:43:23,580
我々は右、1が2未満であることを確認？

884
00:43:23,580 --> 00:43:32,970
だから今、私たちは私たちの最小であることを知っています
0、1、2のインデックス値になるだろう。

885
00:43:32,970 --> 00:43:34,030
うん？

886
00:43:34,030 --> 00:43:39,170
そして、あなたはここに降りたときに、
あなたは正しい値を入れ替えることができます。

887
00:43:39,170 --> 00:43:42,610
>> だから、あなたたちはただJを持ったとき、
前に、1つを見ていませんでした

888
00:43:42,610 --> 00:43:43,260
それの後。

889
00:43:43,260 --> 00:43:44,520
あなたが見ていました
同じ値が、その

890
00:43:44,520 --> 00:43:46,290
それだけで何もしていなかった理由です。

891
00:43:46,290 --> 00:43:49,721
それは誰にでも意味がありますか、
なぜ我々がそのプラス1が必要？

892
00:43:49,721 --> 00:43:50,220
OK。

893
00:43:50,220 --> 00:43:53,345
それでは、ただ作るためにそれを介して実行してみましょう
必ず残りのコードは正しいです。

894
00:43:53,345 --> 00:44:04,424

895
00:44:04,424 --> 00:44:05,340
それはなぜ起こっているのでしょうか？

896
00:44:05,340 --> 00:44:14,780

897
00:44:14,780 --> 00:44:16,364
ああ、それはここ分です。

898
00:44:16,364 --> 00:44:17,780
我々は間違った値を比較しました。

899
00:44:17,780 --> 00:44:24,944

900
00:44:24,944 --> 00:44:25,906
ああ、いや。

901
00:44:25,906 --> 00:44:30,720

902
00:44:30,720 --> 00:44:33,482
>> そうそう、ダウンここではなかったです
同様に誤った値を交換します。

903
00:44:33,482 --> 00:44:34,940
我々は、iとjを見ていたので。

904
00:44:34,940 --> 00:44:36,440
これらは、私たちがチェックされたものです。

905
00:44:36,440 --> 00:44:39,160
私たちは、実際に交換したいです
最小、現在の最小値、

906
00:44:39,160 --> 00:44:40,550
何で1外です。

907
00:44:40,550 --> 00:44:59,510

908
00:44:59,510 --> 00:45:05,402
そして、あなたたちがダウンして見ることができるように
ここでは、ソートされた配列を持っています。

909
00:45:05,402 --> 00:45:07,110
それはちょうどとしなければなりませんでした
その事実

910
00:45:07,110 --> 00:45:09,350
我々はチェックし、
我々が比較された値、

911
00:45:09,350 --> 00:45:11,226
我々は正しい値を見ていませんでした。

912
00:45:11,226 --> 00:45:13,850
私たちは、同じものを見ていました
ここで、実際にそれをスワップありません。

913
00:45:13,850 --> 00:45:17,135
あなたは次のものを見ています
それにしてから、交換することができます。

914
00:45:17,135 --> 00:45:19,260
だから、一種のだったものです
前私たちのコードを盗聴。

915
00:45:19,260 --> 00:45:22,460
そして、私はここでやったことはすべてです
デバッガはあなたのために行っている可能性が

916
00:45:22,460 --> 00:45:23,810
私はちょうどにそれをやりました
ボード、それは簡単ですので、

917
00:45:23,810 --> 00:45:26,320
しようとするのではなく、確認してください
デバッガにズームインします。

918
00:45:26,320 --> 00:45:29,391
それは誰にでも意味がありますか？

919
00:45:29,391 --> 00:45:29,890
クール。

920
00:45:29,890 --> 00:45:34,800

921
00:45:34,800 --> 00:45:35,410
>> 大丈夫。

922
00:45:35,410 --> 00:45:41,070
私たちは話してに進むことができます
漸近記法、これ

923
00:45:41,070 --> 00:45:44,580
言うだけの空想の方法です
これらの種類のすべてのランタイム。

924
00:45:44,580 --> 00:45:47,650
だから私は講義で、ダビデを知っています、
ランタイム時に触れました。

925
00:45:47,650 --> 00:45:52,124
そして、彼は全体の式を経て
実行時間を計算する方法。

926
00:45:52,124 --> 00:45:53,040
そのことについて心配はありません。

927
00:45:53,040 --> 00:45:54,660
あなたは本当に好奇心旺盛であれば
それがどのように機能するかについて、

928
00:45:54,660 --> 00:45:55,810
セクションの後に私に話をして自由に感じます。

929
00:45:55,810 --> 00:45:57,560
私たちは、ウォークスルーすることができます
一緒に式。

930
00:45:57,560 --> 00:46:00,689
しかし、すべてあなたたちは本当に必要な
知っている、nが2の上に乗ということです

931
00:46:00,689 --> 00:46:01,980
nが乗と同じことです。

932
00:46:01,980 --> 00:46:04,710
最も多くあるため、
指数は、最も成長します。

933
00:46:04,710 --> 00:46:06,590
だから、私たちの目的のために、
私たちは気にすべて

934
00:46:06,590 --> 00:46:09,470
成長しているということ巨大な数です。

935
00:46:09,470 --> 00:46:13,340
>> だから何が最善のケースです
選択ソートの実行時？

936
00:46:13,340 --> 00:46:15,830
あなたが必要があるとしている場合
リストを反復します

937
00:46:15,830 --> 00:46:18,712
して、反復処理
そのリストの残りの部分、

938
00:46:18,712 --> 00:46:20,420
何回あります
あなたは、おそらくに行きます

939
00:46:20,420 --> 00:46:24,612
最悪case--で
最良の場合は、を介して実行しますかsorry--？

940
00:46:24,612 --> 00:46:27,070
たぶん良い質問です
聞いて、最悪の場合何であります

941
00:46:27,070 --> 00:46:28,153
選択ソートの実行時間。

942
00:46:28,153 --> 00:46:29,366
聴衆：nの二乗。

943
00:46:29,366 --> 00:46:30,740
ANDI PENG：それはnは、右の二乗です。

944
00:46:30,740 --> 00:46:36,986
だから、これを考えるための簡単​​な方法は、似ています
あなたは、ループのための2つのネストされている任意の時間、

945
00:46:36,986 --> 00:46:38,110
それは、n乗することになるだろう。

946
00:46:38,110 --> 00:46:40,386
あなたがしているためだけでなく、
再び通ります、

947
00:46:40,386 --> 00:46:42,260
あなたが戻って行かなければなりません
周りとそれを介して実行します

948
00:46:42,260 --> 00:46:44,980
もう一度すべての値のための内部。

949
00:46:44,980 --> 00:46:48,640
だから、その場合には、あなたは、nを実行しています
n倍、申し訳ありませんis--れ、乗

950
00:46:48,640 --> 00:46:50,505
n回N、N-二乗等しいです。

951
00:46:50,505 --> 00:46:53,230

952
00:46:53,230 --> 00:46:56,360
>> そして、ソートも少しあります
意味でユニーク

953
00:46:56,360 --> 00:46:59,774
これらの場合、それは問題ではないこと
値が順番に既にあります。

954
00:46:59,774 --> 00:47:01,440
それはまだとにかく介して実行するために起こっています。

955
00:47:01,440 --> 00:47:03,872
ちょうどこれは1、2、3、4であったとしましょう​​。

956
00:47:03,872 --> 00:47:07,080
かかわらずであったか否か
順序は、それはまだ通って走っているだろう

957
00:47:07,080 --> 00:47:08,620
まだ最小値をチェックします。

958
00:47:08,620 --> 00:47:10,100
それはいただろう
チェックの同数

959
00:47:10,100 --> 00:47:12,780
毎回、でもそれならば
実際には何も触れていません。

960
00:47:12,780 --> 00:47:16,940
>> だから、このような場合には、最高の最悪
ランタイムは、実際には等価です。

961
00:47:16,940 --> 00:47:19,160
そこで期待されるランタイム
選択ソートの、

962
00:47:19,160 --> 00:47:23,790
これは、我々は記号で指定します
シータの、シータ、この場合には、

963
00:47:23,790 --> 00:47:24,790
また、N乗されることになります。

964
00:47:24,790 --> 00:47:26,480
これらのすべての3つは、n乗されることになります。

965
00:47:26,480 --> 00:47:29,653
理由の誰もが明確です
ランタイムは、n乗のですか？

966
00:47:29,653 --> 00:47:33,360

967
00:47:33,360 --> 00:47:33,980
>> 大丈夫。

968
00:47:33,980 --> 00:47:39,120
だから、僕はすぐに実行するつもりです
ある種の残りを。

969
00:47:39,120 --> 00:47:41,137
以下のためのアルゴリズム
バブルは、覚えてsort--

970
00:47:41,137 --> 00:47:43,220
これは最初のものでした
ダビデは講義に渡りました。

971
00:47:43,220 --> 00:47:46,000
基本的には、ステップ
リスト全体を通じ

972
00:47:46,000 --> 00:47:48,950
あなたはちょうどあなたがswap--
一度に2つを比較します。

973
00:47:48,950 --> 00:47:51,350
そして、もう一つの大きい場合は、
あなたよりも、単にそれらを交換。

974
00:47:51,350 --> 00:47:53,590
これらは大きいのであれば、あなたは交換します。

975
00:47:53,590 --> 00:47:56,180
私はここの公式持っています。

976
00:47:56,180 --> 00:47:59,100
>> それでは、あなたが8、6、4、2を持っていたとしましょう​​。

977
00:47:59,100 --> 00:48:00,571
あなたは8と6を比較すると思います。

978
00:48:00,571 --> 00:48:01,570
あなたはそれらを交換する必要があると思います。

979
00:48:01,570 --> 00:48:02,610
あなたは8と4を比較します。

980
00:48:02,610 --> 00:48:03,609
あなたはそれらを交換する必要があると思います。

981
00:48:03,609 --> 00:48:07,000
あなたは8を交換する必要がある場合と
2、同様にそれらを変更します。

982
00:48:07,000 --> 00:48:10,760
だから、そのような意味で、あなたは、見ることができます
長期間にわたって演じ、

983
00:48:10,760 --> 00:48:13,730
どのようにバブルの値は親切に
我々はそれを呼んで終了し、

984
00:48:13,730 --> 00:48:15,320
バブルソート。

985
00:48:15,320 --> 00:48:19,950
>> 私達はちょうど上で再びを通じて実行されます
私たちの第二のパス、と私たちの3番目のパス、

986
00:48:19,950 --> 00:48:21,150
私たちの4パス。

987
00:48:21,150 --> 00:48:25,820
本質的には、バブルソートだけで実行されます
あなたまで、それ以上のスワップを行いません。

988
00:48:25,820 --> 00:48:31,109
だから、そういう意味では、これはただです
それのための一般的な擬似コード。

989
00:48:31,109 --> 00:48:32,650
心配しないで、これらはすべてオンラインになることはありません。

990
00:48:32,650 --> 00:48:34,990
私たちは、実際にこの上を行く必要はありません。

991
00:48:34,990 --> 00:48:38,134
>> 私達はちょうどカウンターを初期化します
0から始まり、変数。

992
00:48:38,134 --> 00:48:39,800
そして、我々は全体の配列を反復処理。

993
00:48:39,800 --> 00:48:43,420
そして、この場合は、1つの値がis--場合
値は、その値よりも大きいです

994
00:48:43,420 --> 00:48:44,610
あなたはそれらを交換するつもりです。

995
00:48:44,610 --> 00:48:46,860
そして、あなただけです
続けるつもり。

996
00:48:46,860 --> 00:48:47,970
そして、あなたはカウントするつもりです。

997
00:48:47,970 --> 00:48:50,845
そして、あなたはただやり続けるつもりです
このカウンタは大きいながら

998
00:48:50,845 --> 00:48:53,345
ことを意味よりも0、
毎回あなたが交換する必要があり、

999
00:48:53,345 --> 00:48:55,220
あなたが行きたい知っています
バックして再度確認してください。

1000
00:48:55,220 --> 00:48:59,510
あなたが知っているまでチェックを維持したいです
あなたはもう交換する必要がありません。

1001
00:48:59,510 --> 00:49:05,570
>> だから最善と最悪のものです
ケースは、バブルソートのためのランタイムを？

1002
00:49:05,570 --> 00:49:09,300
そしてhint--これは実際に異なっています
意味での選択ソートから

1003
00:49:09,300 --> 00:49:11,810
これらの2つの答えは同じではないこと。

1004
00:49:11,810 --> 00:49:14,709
中に何が起こるかを考えてみて
それはすでにソートされている場合場合。

1005
00:49:14,709 --> 00:49:16,500
そして、何について考えます
それがあった場合はどうなります

1006
00:49:16,500 --> 00:49:18,372
ケースでは、ソートされませんでした。

1007
00:49:18,372 --> 00:49:20,580
そして、あなたは一種の実行することができます
なぜを通じてそれが起こっています。

1008
00:49:20,580 --> 00:49:22,954
私は、30のように、君たちをあげます
それについて考える秒。

1009
00:49:22,954 --> 00:49:52,330

1010
00:49:52,330 --> 00:49:53,540
>> OK。

1011
00:49:53,540 --> 00:49:57,462
誰もがどのように推測を持っています
バブルソートの最悪の場合の実行時間はありますか？

1012
00:49:57,462 --> 00:49:57,962
うん。

1013
00:49:57,962 --> 00:50:07,810
>> 聴衆：それは、のように、n回だろう
nはマイナス1またはそのような何か？

1014
00:50:07,810 --> 00:50:10,650
同様に、それが実行されるたび、
それは1スワップ以下のような、ちょうどです

1015
00:50:10,650 --> 00:50:10,960
どんなことがありました。

1016
00:50:10,960 --> 00:50:12,668
>> ANDI PENG：うん、そう
あなたは完全に正しいです。

1017
00:50:12,668 --> 00:50:15,940
そして、これはであなたのケースであります
答えは実際にはより複雑でした

1018
00:50:15,940 --> 00:50:17,240
1よりも我々が与える必要があります。

1019
00:50:17,240 --> 00:50:19,772
だから、私はrun--になるだろう
ここでこのすべてを消去する予定。

1020
00:50:19,772 --> 00:50:20,480
誰もが良いですか？

1021
00:50:20,480 --> 00:50:21,869
私はこれを消去することはできますか？

1022
00:50:21,869 --> 00:50:22,368
OK。

1023
00:50:22,368 --> 00:50:27,904

1024
00:50:27,904 --> 00:50:30,320
あなたは、nを介して実行するつもりです
回初めて、右？

1025
00:50:30,320 --> 00:50:33,200
そして、彼らは介し​​て実行するつもりです
nはマイナス1秒の時間、右か？

1026
00:50:33,200 --> 00:50:37,130
そして、あなたは維持するつもりです
行く、nは鉱山2、エトセトラ。

1027
00:50:37,130 --> 00:50:40,210
ダビデはどこに、講義でこれをやりました、
あなたはすべてのそれらの値を追加した場合、

1028
00:50:40,210 --> 00:50:48,080
あなたが何かを得ますlike-- yeah--
基本的にだけ削減され、2オーバー

1029
00:50:48,080 --> 00:50:49,784
までのn乗。

1030
00:50:49,784 --> 00:50:51,700
あなたが取得するつもりです
そこに奇妙な割合。

1031
00:50:51,700 --> 00:50:53,892
そして、これだけのことを知っています
nが常に乗

1032
00:50:53,892 --> 00:50:55,350
割合よりも優先されます。

1033
00:50:55,350 --> 00:50:58,450
ので、この場合には、最悪の
ランタイムは、n乗されることになります。

1034
00:50:58,450 --> 00:51:00,210
それが降順にあった場合
ため、思う、あなた

1035
00:51:00,210 --> 00:51:02,530
スワップ毎回行う必要があります。

1036
00:51:02,530 --> 00:51:05,170
>> 潜在的に、何だろう、
最良の場合ランタイム？

1037
00:51:05,170 --> 00:51:08,580
リストがすでにあった場合は、ちょうど言ってみましょう
ためには、ランタイムは何でしょうか？

1038
00:51:08,580 --> 00:51:09,565
>> 聴衆：N。

1039
00:51:09,565 --> 00:51:10,690
ANDI PENG：それはまさに、n個です。

1040
00:51:10,690 --> 00:51:11,600
そして、なぜそれがn個ありますか？

1041
00:51:11,600 --> 00:51:13,850
聴衆：あなただけのため、
各一度にチェックする必要があります。

1042
00:51:13,850 --> 00:51:14,770
ANDI PENG：その通り。

1043
00:51:14,770 --> 00:51:17,150
だから、可能な限り最高のランタイムで、
このリストには、すでにあった場合

1044
00:51:17,150 --> 00:51:20,270
あなたは4--、のは1、2、3を言わせsorted--
ちょうどあなたがチェックする、通過だろう、

1045
00:51:20,270 --> 00:51:21,720
あなたは彼らのすべてが出てパン、ああ、見ることになります。

1046
00:51:21,720 --> 00:51:22,636
私は交換する必要はありませんでした。

1047
00:51:22,636 --> 00:51:23,370
私はこれで終わりです。

1048
00:51:23,370 --> 00:51:26,500
だから、その場合には、それだけのn
ちょうどまたはステップの数は、

1049
00:51:26,500 --> 00:51:29,870
最初のリストで確認しなければなりませんでした。

1050
00:51:29,870 --> 00:51:33,990
>> そして、後に我々は今ヒット
挿入ソート、

1051
00:51:33,990 --> 00:51:39,260
このアルゴリズムは、本質的に分割することです
それソートし、ソートされていない部分に。

1052
00:51:39,260 --> 00:51:42,810
そして、一つ一つ、
ソートされていない値は、

1053
00:51:42,810 --> 00:51:46,880
それらの適切なに挿入
リストの最初のポジション。

1054
00:51:46,880 --> 00:51:52,120
>> したがって、たとえば、私たちは持っています
再び3、5、2、6、4のリスト。

1055
00:51:52,120 --> 00:51:54,750
我々は、それが現在だことを知っています
ソートされていない私たちはただたので

1056
00:51:54,750 --> 00:51:57,030
それを見て始めました。

1057
00:51:57,030 --> 00:52:00,610
私たちは見て、我々はことを知っています
最初の値は、右のソートされて？

1058
00:52:00,610 --> 00:52:04,190
あなただけの配列を見ている場合
サイズ1、あなたはそれがソートだことを知っています。

1059
00:52:04,190 --> 00:52:08,230
>> だから我々はことを知っています
他の4つは、ソートされていないです。

1060
00:52:08,230 --> 00:52:10,980
我々は通過し、我々はその値を参照してください。

1061
00:52:10,980 --> 00:52:11,730
それでは、戻りましょう。

1062
00:52:11,730 --> 00:52:13,130
5の値を参照してください？

1063
00:52:13,130 --> 00:52:14,110
我々はそれを見てみましょう。

1064
00:52:14,110 --> 00:52:15,204
我々は3と比較します。

1065
00:52:15,204 --> 00:52:17,870
我々は、それがより大きいだことを知っています
3、私たちはそれがソートされたということを知っています。

1066
00:52:17,870 --> 00:52:22,940
だから我々は今、最初の二つのことを知っています
ソートされ、最後の3つがありませんされています。

1067
00:52:22,940 --> 00:52:24,270
>> 私たちは2を見てみましょう。

1068
00:52:24,270 --> 00:52:25,720
我々は最初の5でそれを確認してください。

1069
00:52:25,720 --> 00:52:26,700
それが5未満のですか？

1070
00:52:26,700 --> 00:52:27,240
そうではない。

1071
00:52:27,240 --> 00:52:29,510
だから我々は見下ろして維持する必要があります。

1072
00:52:29,510 --> 00:52:30,940
その後、3から2をご確認ください。

1073
00:52:30,940 --> 00:52:31,850
それはより少ないですか？

1074
00:52:31,850 --> 00:52:32,350
いいえ。

1075
00:52:32,350 --> 00:52:35,430
だから、2を挿入する必要があります知っています
フロントに3と5

1076
00:52:35,430 --> 00:52:38,200
両方が押し出されなければなりません。

1077
00:52:38,200 --> 00:52:42,190
6と4で再びこれを行います。

1078
00:52:42,190 --> 00:52:48,962
そして、私たちはただ、基本的にチェックしておきます
ここで私たちは、チェックチェック、チェックしてください。

1079
00:52:48,962 --> 00:52:51,170
そして、それは右になるまで
位置、我々の種類のちょうど

1080
00:52:51,170 --> 00:52:54,890
正しい位置に挿入し、
それの名前はどこから来たのです。

1081
00:52:54,890 --> 00:52:59,830
>> だから、それはただのアルゴリズムですが、
擬似コード自体、一種の、

1082
00:52:59,830 --> 00:53:04,990
我々が実装する方法について
挿入ソート。

1083
00:53:04,990 --> 00:53:05,954
擬似コードはこちらです。

1084
00:53:05,954 --> 00:53:06,620
これは、すべてのオンラインです。

1085
00:53:06,620 --> 00:53:10,720
心配ない君たちがある場合
これを下にコピーしようとしています。

1086
00:53:10,720 --> 00:53:14,500
だからもう一度、同じquestion--何
最良と最悪のランタイムになります

1087
00:53:14,500 --> 00:53:16,120
挿入ソートのために？

1088
00:53:16,120 --> 00:53:17,750
それは、最後の質問に非常によく似ています。

1089
00:53:17,750 --> 00:53:20,479
私は、30のように、君たちをあげます
同様にこのことについて考える秒。

1090
00:53:20,479 --> 00:53:47,150

1091
00:53:47,150 --> 00:53:50,071
>> 誰もがしたいん[OK]
私は最悪のランタイムを与えますか？

1092
00:53:50,071 --> 00:53:50,570
うん。

1093
00:53:50,570 --> 00:53:51,490
>> 聴衆：nの二乗。

1094
00:53:51,490 --> 00:53:52,573
>> ANDI PENG：それは、n乗です。

1095
00:53:52,573 --> 00:53:53,730
そして、なぜそれがn個の二乗のですか？

1096
00:53:53,730 --> 00:53:57,562
>> 聴衆：であるため
順序を逆に、あなたが持っています

1097
00:53:57,562 --> 00:54:02,619
is--れ、n回を経るNに

1098
00:54:02,619 --> 00:54:03,660
ANDI PENG：うん、まさに。

1099
00:54:03,660 --> 00:54:06,610
バブルソートのようにだから同じこと。

1100
00:54:06,610 --> 00:54:08,720
このリストは、内にある場合
降順、あなたがしています

1101
00:54:08,720 --> 00:54:11,240
最初の一度をチェックしているつもり。

1102
00:54:11,240 --> 00:54:13,470
そして、すべてのと
付加価値、あなたがしています

1103
00:54:13,470 --> 00:54:16,390
それをチェックしているつもり
右のすべての単一の値、？

1104
00:54:16,390 --> 00:54:20,290
だから完全に、あなたはするつもりです
n個のパスの時間は、他のnは、通過します

1105
00:54:20,290 --> 00:54:21,750
nが2乗さ。

1106
00:54:21,750 --> 00:54:22,860
何最良の場合はどうですか？

1107
00:54:22,860 --> 00:54:24,360
うん。

1108
00:54:24,360 --> 00:54:28,840
>> 聴衆：nはマイナス1、理由
最初のものは、すでに2乗さ。

1109
00:54:28,840 --> 00:54:30,270
>> ANDI PENG：だから、近接しています。

1110
00:54:30,270 --> 00:54:31,850
その答えは、実際にはnです。

1111
00:54:31,850 --> 00:54:37,189
最初のものであるのに対しので、
並べ替え、それをactually--ない場合があります

1112
00:54:37,189 --> 00:54:38,980
私達はちょうどで、運が尽き
その例、その2

1113
00:54:38,980 --> 00:54:40,930
最小数であることが起こりました。

1114
00:54:40,930 --> 00:54:43,680
しかし、それは必ずしもそうではありません。

1115
00:54:43,680 --> 00:54:48,040
図2は、すでに最初にソートされている場合
しかし、あなたは、見て、ここで1あります

1116
00:54:48,040 --> 00:54:49,144
1はそれをバンプする予定です。

1117
00:54:49,144 --> 00:54:51,060
そして、それが終了になるだろう
とにかくぶつかっさアップ。

1118
00:54:51,060 --> 00:54:56,250
>> そのように最良の場合のシナリオにおいて、
それは実際にはn個になるだろう。

1119
00:54:56,250 --> 00:54:59,090
あなたが持っている場合は1、2、3、
4、5、6、7、8、あなたがいます

1120
00:54:59,090 --> 00:55:00,940
介して実行しようとして
一度そのリスト全体

1121
00:55:00,940 --> 00:55:03,430
すべてが正常かどうかを確認します。

1122
00:55:03,430 --> 00:55:07,390
ランニングの全員が明確にされています
同様に選択の時代？

1123
00:55:07,390 --> 00:55:09,960
私が通って行くよ知っています
これらの本当に速いです。

1124
00:55:09,960 --> 00:55:13,330
しかし、ちょうどあなたが知っていればことを知っています
一般的な概念は、あなたが良いことがあります。

1125
00:55:13,330 --> 00:55:16,070
OK。

1126
00:55:16,070 --> 00:55:19,790
だから私はちょうどのように、多分君たちを与えるでしょう、
あなたの隣人に話をする分

1127
00:55:19,790 --> 00:55:21,890
ちょうどいくつかであるものに
主な相違点の

1128
00:55:21,890 --> 00:55:23,540
ある種のこれらのタイプの間。

1129
00:55:23,540 --> 00:56:24,571

1130
00:56:24,571 --> 00:56:25,570
我々はすぐにその上を行きますよ。

1131
00:56:25,570 --> 00:56:26,444
聴衆：ああ、[OK]をクリックします。

1132
00:56:26,444 --> 00:56:27,320
ANDI PENG：うん。

1133
00:56:27,320 --> 00:56:28,380
OK。

1134
00:56:28,380 --> 00:56:33,420
クール、のクラスとして再召集しましょう​​。

1135
00:56:33,420 --> 00:56:34,330
OK。

1136
00:56:34,330 --> 00:56:37,579
だから、これはあったような
意味でオープンエンドの質問

1137
00:56:37,579 --> 00:56:39,120
それらへの回答の多くがあること。

1138
00:56:39,120 --> 00:56:40,746
そして、我々は簡単にそれらのいくつかの上に行きますよ。

1139
00:56:40,746 --> 00:56:43,411
私はちょうどあなたたち取得したいです
差別何を考えます

1140
00:56:43,411 --> 00:56:44,530
ある種のすべての3つのタイプ。

1141
00:56:44,530 --> 00:56:47,440
そして、私は偉大な、また、聞きました
何をするマージソートんquestion--？

1142
00:56:47,440 --> 00:56:50,110
グレート質問、それはだから
私たちは次のカバーしています。

1143
00:56:50,110 --> 00:56:52,850
>> だから一種であるマージ
その機能一種

1144
00:56:52,850 --> 00:56:56,100
非常に異なる他の種類から。

1145
00:56:56,100 --> 00:56:58,180
君たちはsee--ように
ダビデはそのデモを行いました

1146
00:56:58,180 --> 00:57:01,130
彼はすべてのクールなを持っていたところ
マージ方法を見てのノイズ

1147
00:57:01,130 --> 00:57:04,010
ソート無限に、のように、走りました
他の二つのタイプよりも速いですか？

1148
00:57:04,010 --> 00:57:04,510
OK。

1149
00:57:04,510 --> 00:57:07,580
だから、マージためです
ソートその格差を実装

1150
00:57:07,580 --> 00:57:11,020
私たちはきた概念を征服
講義で多くについて話しました。

1151
00:57:11,020 --> 00:57:14,550
私たちが仕事をしたいという意味で
あなたが分裂するとき、難しく、賢くありません

1152
00:57:14,550 --> 00:57:18,120
及び問題を克服し、それを破ります
ダウンし、その後、それらを一緒に置きます

1153
00:57:18,120 --> 00:57:19,930
良いものは常に起こります。

1154
00:57:19,930 --> 00:57:21,960
>> マージだから方法
ソート基本的に動作します

1155
00:57:21,960 --> 00:57:24,660
それが分割していることです
半分にソートされていない配列。

1156
00:57:24,660 --> 00:57:26,500
そして、それは配列の2つの半分を持っています。

1157
00:57:26,500 --> 00:57:28,220
そして、それはちょうどそれらの二つの部分をソートします。

1158
00:57:28,220 --> 00:57:31,750
それはちょうどで、半分に分割し続けます
半分、半分にすべてがソートされるまで

1159
00:57:31,750 --> 00:57:33,680
して、再帰的に
一緒にすべてを置きます。

1160
00:57:33,680 --> 00:57:36,550
>> だから、本当に抽象です。

1161
00:57:36,550 --> 00:57:38,750
だから、これは擬似コードの少しだけです。

1162
00:57:38,750 --> 00:57:41,040
それはに意味がありますか
それが実行している方法はありますか？

1163
00:57:41,040 --> 00:57:43,870
それでは、あなたが持っているとしましょう
n個の要素の配列は、右？

1164
00:57:43,870 --> 00:57:45,450
nが2未満である場合は、返すことができます。

1165
00:57:45,450 --> 00:57:49,040
あなたが知っているので、それがあるかどう
唯一の事は、それをソートする必要があります。

1166
00:57:49,040 --> 00:57:52,600
そうでなければ、あなたは左半分をソートし、
そして、あなたは右半分をソートし、

1167
00:57:52,600 --> 00:57:54,140
そして、あなたはマージします。

1168
00:57:54,140 --> 00:57:56,979
>> だから、本当に簡単に見えますが、
現実には、それについて考えることです

1169
00:57:56,979 --> 00:58:00,270
難しいの一種。あなたが似ているので、
まあ、それはそれ自身で実行されているのようなものです。

1170
00:58:00,270 --> 00:58:00,769
右？

1171
00:58:00,769 --> 00:58:02,430
それはそれ自身で実行されています。

1172
00:58:02,430 --> 00:58:05,479
だから、その意味で、ダビデは触れ
クラスの再帰に依存します。

1173
00:58:05,479 --> 00:58:07,270
そして、それは考え方です
我々はより多くの話をします。

1174
00:58:07,270 --> 00:58:11,430
なお、このことは、これらの2つのラインです
ここでは、実際にはプログラムであり、

1175
00:58:11,430 --> 00:58:13,860
自分自身を実行するように伝えます
異なる入力を持ちます。

1176
00:58:13,860 --> 00:58:17,230
そうではなくて自分自身を実行します
n個の要素の全体を、

1177
00:58:17,230 --> 00:58:20,530
あなたがにそれを打破することができます
左半分と右半分

1178
00:58:20,530 --> 00:58:22,680
し、再度実行してください。

1179
00:58:22,680 --> 00:58:26,050
>> そして、我々は、視覚的にそれを見てみましょう
私は視覚的な学習者だから。

1180
00:58:26,050 --> 00:58:27,270
それは私のために適しています。

1181
00:58:27,270 --> 00:58:29,890
そこで、ここでは視覚的な例を見てみましょう。

1182
00:58:29,890 --> 00:58:36,237
>> 6、我々は配列があるとしましょう
要素、3,5、2,6、4,1、ソートされません。

1183
00:58:36,237 --> 00:58:37,820
すべての権利は​​、このページのたくさんあり​​ます。

1184
00:58:37,820 --> 00:58:43,179
だからみんなが見ることができる場合
ここで、第一段階、3,5、2,6、4,1、

1185
00:58:43,179 --> 00:58:44,220
あなたはそれを半分に分割することができます。

1186
00:58:44,220 --> 00:58:45,976
あなたは3,5、2,6、4,1を有しています。

1187
00:58:45,976 --> 00:58:48,850
あなたはこれらがあなたをaren't--ことを知っています
彼らはソートまたはしていない場合はわからないが、

1188
00:58:48,850 --> 00:58:52,517
あなたは半分に、それらを破壊し続けます、
半分に、半分に、最終的になるまで、

1189
00:58:52,517 --> 00:58:53,600
あなただけの1要素を持っています。

1190
00:58:53,600 --> 00:58:56,790
そして、もう一つの要素は常に正しい、ソートされていますか？

1191
00:58:56,790 --> 00:59:01,560
>> だから、私たちは知っている3、5、2、4、6、
1は、それだけではソートされています。

1192
00:59:01,560 --> 00:59:05,870
そして今、我々はそれらを一緒に戻すことができます。

1193
00:59:05,870 --> 00:59:07,510
だから我々は3,5を知っています。

1194
00:59:07,510 --> 00:59:08,510
私たちは一緒にそれらを置きます。

1195
00:59:08,510 --> 00:59:09,617
私たちは、それがソートされたことを知っています。

1196
00:59:09,617 --> 00:59:10,450
まだそこに2の。

1197
00:59:10,450 --> 00:59:11,830
私たちは一緒に4と6を置くことができます。

1198
00:59:11,830 --> 00:59:13,996
我々は、それがソートだことを知っています
私たちは一緒にそれを置きます。

1199
00:59:13,996 --> 00:59:14,940
1があります。

1200
00:59:14,940 --> 00:59:18,720
>> そして、あなただけを見て
右ここで、これらの二つの部分。

1201
00:59:18,720 --> 00:59:21,300
あなたは3,5、2、2、3、5を有しています。

1202
00:59:21,300 --> 00:59:23,465
あなたは比較することができます
すべての始まり。

1203
00:59:23,465 --> 00:59:26,340
あなたはこれがソートされていることを知っているので
あなたはそれがソートだことを知っています。

1204
00:59:26,340 --> 00:59:29,360
それでは、あなたもする必要はありません
5を比較し、あなただけの3を比較します。

1205
00:59:29,360 --> 00:59:32,070
及び2は、3未満であります
あなたは2が最後に行かなければならない知っています。

1206
00:59:32,070 --> 00:59:33,120
>> あそこ同じこと。

1207
00:59:33,120 --> 00:59:34,740
図1は、ここに行く必要があります。

1208
00:59:34,740 --> 00:59:37,330
そして、あなたが入れて行くとき
一緒にこの2つの値、

1209
00:59:37,330 --> 00:59:39,950
あなたはこれがソートされていることを知っていて、
あなたはそれがソートされていることを知っています。

1210
00:59:39,950 --> 00:59:43,240
それでは、1と
図2において、1は2未満です。

1211
00:59:43,240 --> 00:59:45,570
それは1ことを示しています
これの最後に行くべき

1212
00:59:45,570 --> 00:59:47,480
でも、3または5を見ず。

1213
00:59:47,480 --> 00:59:50,100
そして4、あなただけのことができます
チェック、それはここで右に行きます。

1214
00:59:50,100 --> 00:59:51,480
あなたは5で見てする必要はありません。

1215
00:59:51,480 --> 00:59:52,570
6と同じこと。

1216
00:59:52,570 --> 00:59:55,860
あなただけ6--ことそれを知っています
見てする必要はありません。

1217
00:59:55,860 --> 00:59:57,870
>> だからそのように、あなたがしています
自分だけを保存します

1218
00:59:57,870 --> 00:59:59,526
あなたが比較している手順の多く。

1219
00:59:59,526 --> 01:00:02,150
あなたはすべてを比較する必要はありません
他の要素に対して要素。

1220
01:00:02,150 --> 01:00:05,230
あなただけのものと比較
あなたはに対してそれを比較する必要があること。

1221
01:00:05,230 --> 01:00:06,870
だから、抽象的な概念のようなものです。

1222
01:00:06,870 --> 01:00:10,540
そうでない場合は心配ありません
かなり右まだあなたを打ちます。

1223
01:00:10,540 --> 01:00:14,740
一般的に、これは
どのようにマージソートが動作します。

1224
01:00:14,740 --> 01:00:17,750
質問、迅速なご質問、
私は上に移動する前に？

1225
01:00:17,750 --> 01:00:18,550
うん。

1226
01:00:18,550 --> 01:00:22,230
>> 聴衆：だからあなたはあなたが取ることを言いました
1、次いで4、及び図6

1227
01:00:22,230 --> 01:00:23,860
とに入れて。

1228
01:00:23,860 --> 01:00:26,800
だからthose--ではありませんされていません
あなたはそれらを見て

1229
01:00:26,800 --> 01:00:28,544
別々の要素としてではなく、全体として？

1230
01:00:28,544 --> 01:00:29,210
ANDI PENG：うん。

1231
01:00:29,210 --> 01:00:32,020
だから、何が起こっていますか
あなた、それは基本的に

1232
01:00:32,020 --> 01:00:33,650
ブランドの新しい配列を作成しています。

1233
01:00:33,650 --> 01:00:36,690
だから、ここでは、私が持っていることを知っています
サイズ3の二つの配列は、右？

1234
01:00:36,690 --> 01:00:39,600
だから、知っている私のソートされた配列
6つの要素を有する必要があります。

1235
01:00:39,600 --> 01:00:42,270
だから、あなただけの作成します
メモリの新しい金額。

1236
01:00:42,270 --> 01:00:44,270
だから、ちょっと似ています
メモリの無駄であること、

1237
01:00:44,270 --> 01:00:46,186
それは問題ではありません。
それは非常に小さいですので。

1238
01:00:46,186 --> 01:00:48,590
だから、1を見て
あなたは2を見てください。

1239
01:00:48,590 --> 01:00:50,770
そして、あなたは1が2未満であることを知っています。

1240
01:00:50,770 --> 01:00:53,840
だから、1がで行くべきことを知っています
それらの全ての始まり。

1241
01:00:53,840 --> 01:00:55,850
>> あなたもする必要はありません
3と5を見てください。

1242
01:00:55,850 --> 01:00:57,400
だから、1はそこに行く知っています。

1243
01:00:57,400 --> 01:00:59,300
次に、基本的には1を切り落とします。

1244
01:00:59,300 --> 01:01:00,370
それは、私たちに死んだ、のように、です。

1245
01:01:00,370 --> 01:01:03,690
その後、我々はわずか2を持っています、
図3、図5、及びその後4,6。

1246
01:01:03,690 --> 01:01:06,270
そして、あなたは、あなたのことを知っています
、4と2を比較します

1247
01:01:06,270 --> 01:01:07,560
ああ、2はそこに行く必要があります。

1248
01:01:07,560 --> 01:01:09,685
だから、あなたがそれを切り落とす、2ダウンをウンチ。

1249
01:01:09,685 --> 01:01:12,060
だから、あなたはわずか3を持っています
そして、4と6の5。

1250
01:01:12,060 --> 01:01:14,650
そして、あなたはそれをオフにチョッピング保ちます
あなたは配列にそれらを置くまで。

1251
01:01:14,650 --> 01:01:17,110
>> 聴衆：だから、ちょうど常にしています
[聞こえない]を比較しますか？

1252
01:01:17,110 --> 01:01:17,710
>> ANDI PENG：その通り。

1253
01:01:17,710 --> 01:01:19,590
だから、そういう意味では、あなたがしています
ただ、基本的に、比較、

1254
01:01:19,590 --> 01:01:21,240
他の数に対して1番号。

1255
01:01:21,240 --> 01:01:22,990
そして、あなたは知っているので
それは、あなたをソートだこと

1256
01:01:22,990 --> 01:01:24,350
目を通す必要はありません
数字のすべて。

1257
01:01:24,350 --> 01:01:25,870
あなただけの最初のものを見ています。

1258
01:01:25,870 --> 01:01:27,582
そしてあなただけのウンチすることができます
それらダウン、あなたが知っているので

1259
01:01:27,582 --> 01:01:29,640
彼らが属している必要がどこに属しています。

1260
01:01:29,640 --> 01:01:31,030
うん。

1261
01:01:31,030 --> 01:01:32,920
良い質問。

1262
01:01:32,920 --> 01:01:35,290
>> それから、あなたのいずれかの場合
少し野心的であり、

1263
01:01:35,290 --> 01:01:38,660
このコードを見て自由に感じます。

1264
01:01:38,660 --> 01:01:40,680
これは実際にあります
物理的実装

1265
01:01:40,680 --> 01:01:42,150
我々はマージソートを作成する方法の。

1266
01:01:42,150 --> 01:01:44,070
そして、あなたが見ることができる、それは非常に短いです。

1267
01:01:44,070 --> 01:01:46,310
背後にでもアイデア
それはかなり複雑です。

1268
01:01:46,310 --> 01:01:50,865
だから、これを描くように感じる場合
宿題で今夜は、お気軽に。

1269
01:01:50,865 --> 01:01:54,050

1270
01:01:54,050 --> 01:01:54,740
>> OK。

1271
01:01:54,740 --> 01:01:58,070
ダビデはまた、講義では、この上で行ってきました。

1272
01:01:58,070 --> 01:02:00,660
最良の場合どのようなものがあります
ランタイム、最悪の場合のランタイム、

1273
01:02:00,660 --> 01:02:05,680
そして、マージソートの予想ランタイム？

1274
01:02:05,680 --> 01:02:07,260
数秒だと思います。

1275
01:02:07,260 --> 01:02:11,198
これはかなり難しいですが、種類の
あなたが考えてみれば、直感的な。

1276
01:02:11,198 --> 01:02:20,090

1277
01:02:20,090 --> 01:02:23,054
大丈夫。

1278
01:02:23,054 --> 01:02:25,269
>> 聴衆：最悪の場合は、nログn？

1279
01:02:25,269 --> 01:02:26,060
ANDI PENG：その通り。

1280
01:02:26,060 --> 01:02:29,380
そして、なぜそれがnのnを記録しています。

1281
01:02:29,380 --> 01:02:32,230
>> 観客：それはないですので、
指数関数的に速くなり、

1282
01:02:32,230 --> 01:02:35,390
それは、その機能のようなものです
代わりに、単にnはの

1283
01:02:35,390 --> 01:02:37,529
乗か何か？

1284
01:02:37,529 --> 01:02:38,320
ANDI PENG：その通り。

1285
01:02:38,320 --> 01:02:40,750
だから理由
この上のランタイムは、n個のログです

1286
01:02:40,750 --> 01:02:44,310
nが、あなたが何であるかbecause--です
これらの工程の全てにやって？

1287
01:02:44,310 --> 01:02:46,190
あなたはちょうど、それを半分にチョッピングしていますか？

1288
01:02:46,190 --> 01:02:48,750
そして、私たちがやっているとき
それはやっているすべてのことを、ログ

1289
01:02:48,750 --> 01:02:53,150
半分に問題を分割され、
半分に、半分に、より多くの半分インチ

1290
01:02:53,150 --> 01:02:56,430
その意味で、あなたは親切なことができます
線形モデルを取り除きます

1291
01:02:56,430 --> 01:02:57,510
我々は、使用してきたこと。

1292
01:02:57,510 --> 01:03:00,254
あなたがチョップ時ので
半分に物事は、それがログです。

1293
01:03:00,254 --> 01:03:02,420
それはちょうど、数学的です
それを表現する方法。

1294
01:03:02,420 --> 01:03:06,310
>> そして最後に、最後に、あなたがしています
一つだけ最後のパススルーを作ります

1295
01:03:06,310 --> 01:03:07,930
右の順序でそれらのすべてを置きますか？

1296
01:03:07,930 --> 01:03:10,330
だからあなただけにしている場合
一つのことを確認し、それは、nです。

1297
01:03:10,330 --> 01:03:13,420
だから、あなたは親切なのです
2一緒に乗算します。

1298
01:03:13,420 --> 01:03:17,660
あなたがその最終的なを持っているようなので、それはです
n個のログとここにダウンnのチェック

1299
01:03:17,660 --> 01:03:18,390
ここまで。

1300
01:03:18,390 --> 01:03:21,060
そして、あなたが掛けた場合
彼らは、それがN Nログです。

1301
01:03:21,060 --> 01:03:26,100
>> だから最高のケースと最悪
場合、すべてのnのnを記録していると予想。

1302
01:03:26,100 --> 01:03:27,943
それは別の一種のようなものです。

1303
01:03:27,943 --> 01:03:30,090
これは、選択ソートのようなものです
それその意味で

1304
01:03:30,090 --> 01:03:32,131
何あなたの問題ではありません。
リストには、それだけで起こっているのであり、

1305
01:03:32,131 --> 01:03:34,801
同じことを一つ一つの時間をすることができません。

1306
01:03:34,801 --> 01:03:35,300
OK。

1307
01:03:35,300 --> 01:03:39,950
かかわらず、あなたたちが見ることができるように
我々は、n through--行ってきたのソート

1308
01:03:39,950 --> 01:03:41,660
乗、それは非常に効率的ではありません。

1309
01:03:41,660 --> 01:03:47,060
とにもこのNログnは
最も効率的ではありません。

1310
01:03:47,060 --> 01:03:49,720
あなたたちは興味があれば、
ソート・メカニズムがあります

1311
01:03:49,720 --> 01:03:54,310
彼らはしているように効率的であること
ランタイムではほぼ横ばい。

1312
01:03:54,310 --> 01:03:55,420
>> あなたは、いくつかのログのnを持っています。

1313
01:03:55,420 --> 01:03:58,190
あなたは、いくつかのログログのnを持っています。

1314
01:03:58,190 --> 01:04:00,330
私たちはそれらに触れないでください
このクラスの今。

1315
01:04:00,330 --> 01:04:02,663
しかし、あなたたちは好奇心旺盛であれば、
何、Googleにお気軽に

1316
01:04:02,663 --> 01:04:04,392
最も効率的な並べ替えのメカニズム。

1317
01:04:04,392 --> 01:04:06,350
私はありますが、知りません
いくつかの本当に面白いもの、

1318
01:04:06,350 --> 01:04:09,860
いくつかは実際にありますlike--
人々が作る面白いもの。

1319
01:04:09,860 --> 01:04:12,210
そして、あなたはどのように疑問に思います
今までそのことを考えて。

1320
01:04:12,210 --> 01:04:15,730
あなたには、いくつかのスペアを持っているのであれば、Googleの
時間は、上、いくつかの面白い方法は何ですか

1321
01:04:15,730 --> 01:04:17,730
それは同様にpeople--
効率的ways--人

1322
01:04:17,730 --> 01:04:20,371
ソートを実装することができました。

1323
01:04:20,371 --> 01:04:20,870
OK。

1324
01:04:20,870 --> 01:04:22,880
そして、ここだけの便利な小さなチャートです。

1325
01:04:22,880 --> 01:04:26,850
私は、そのクイズ0の前に、あなたのすべてを知っています
お部屋になりますおそらくしよう

1326
01:04:26,850 --> 01:04:27,960
それを記憶します。

1327
01:04:27,960 --> 01:04:30,940
だから、あなたたちのためにそこにうれしいです。

1328
01:04:30,940 --> 01:04:37,120
ただmade--ロジックを忘れないでください
なぜこれらの数字が発生しました。

1329
01:04:37,120 --> 01:04:39,870
あなたは常に失われている場合は、単に作ります
必ず、種類が何であるかを知っています。

1330
01:04:39,870 --> 01:04:40,820
そして、あなたはを通して実行することができます
あなたの心の中でそれら

1331
01:04:40,820 --> 01:04:42,903
なぜそれらを把握します
答えはそれらの答えです。

1332
01:04:42,903 --> 01:04:46,250

1333
01:04:46,250 --> 01:04:47,600
>> 大丈夫。

1334
01:04:47,600 --> 01:04:49,680
だから我々は移動するつもりです
最終的には、検索に、上。

1335
01:04:49,680 --> 01:04:51,638
あなたのもののようなので、
誰がPSETを読んでいます、

1336
01:04:51,638 --> 01:04:55,175
検索もの一部であります
今週の問題が設定されます。

1337
01:04:55,175 --> 01:04:57,300
あなたが実現するように求められます
検索の2種類。

1338
01:04:57,300 --> 01:05:00,070
一つは、線形検索で、
一つは二分探索です。

1339
01:05:00,070 --> 01:05:01,760
>> だから、線形探索はかなり簡単です。

1340
01:05:01,760 --> 01:05:04,070
あなただけの要素を検索します
あなたはそれを得るかどうかを確認するために、リストの。

1341
01:05:04,070 --> 01:05:05,444
あなただけを反復処理する必要があります。

1342
01:05:05,444 --> 01:05:08,170
そして、それは何かと等しい場合、
あなたはちょうど、それを返すことができますか？

1343
01:05:08,170 --> 01:05:10,890
しかし、私たちが最もている1つを
話に興味

1344
01:05:10,890 --> 01:05:14,550
バイナリ検索、右は、あります
分割機構を征服します

1345
01:05:14,550 --> 01:05:18,190
ダビデは講演で実証されました。

1346
01:05:18,190 --> 01:05:20,810
>> 電話帳の例を思い出してみましょう
彼が育て続けていること、

1347
01:05:20,810 --> 01:05:23,960
彼は一種の苦労1
この1年間のビット、

1348
01:05:23,960 --> 01:05:27,530
あなたは半分に問題を分割する場合は、
半分に、半分に、何度も何度も、

1349
01:05:27,530 --> 01:05:30,730
あなたが探しているものを見つけるまで？

1350
01:05:30,730 --> 01:05:33,727
そして、あなたが持っています
その実行時にも。

1351
01:05:33,727 --> 01:05:35,810
そして、あなたが見ることができる、それはです
著しく効率的

1352
01:05:35,810 --> 01:05:39,080
検索の他の型よりも。

1353
01:05:39,080 --> 01:05:41,880
>> だから、私たちが行くと道
バイナリ検索を実装

1354
01:05:41,880 --> 01:05:46,510
で、我々は配列を持っていた場合、
インデックス0〜6、7つの要素、

1355
01:05:46,510 --> 01:05:49,790
我々はright--、途中で見ることができます
申し訳ありませんが、私たちの質問であればfirst--

1356
01:05:49,790 --> 01:05:53,840
私たちはの質問をしたい場合は、ありません
アレイは、7の要素が含まれています

1357
01:05:53,840 --> 01:05:56,840
明らかに、人間であること、およびHAVING
このような小さな配列は、それが私たちのために簡単です

1358
01:05:56,840 --> 01:05:58,210
そう言って。

1359
01:05:58,210 --> 01:06:05,750
しかし、方法は、バイナリを実装します
検索は、途中で見えるようになるであろう。

1360
01:06:05,750 --> 01:06:08,020
>> 我々は、インデックス3であることを知っています
途中、私たちのため

1361
01:06:08,020 --> 01:06:09,270
7つの要素があることを知っています。

1362
01:06:09,270 --> 01:06:10,670
何7 2で割りましたか？

1363
01:06:10,670 --> 01:06:12,850
あなたは余分な1ことを切り落とすことができます。

1364
01:06:12,850 --> 01:06:14,850
あなたが途中で3を持っています。

1365
01:06:14,850 --> 01:06:17,590
だから7に等しい3の配列ですか？

1366
01:06:17,590 --> 01:06:18,900
それは右、ではないのですか？

1367
01:06:18,900 --> 01:06:21,050
しかし、我々は、チェックのカップルを行うことができます。

1368
01:06:21,050 --> 01:06:25,380
3 7未満かの配列です
7より大きい3の配列ですか？

1369
01:06:25,380 --> 01:06:27,240
>> そして、我々はそれが7未満だということを知っています。

1370
01:06:27,240 --> 01:06:30,259
だから我々は、ああ、それはしなければならない、ということを知っています
左半分にはなりません。

1371
01:06:30,259 --> 01:06:32,300
我々は、それがなければならないことを知っています
右半分には、右？

1372
01:06:32,300 --> 01:06:34,662
だから我々はちょうど半​​分の配列を切り落とすことができます。

1373
01:06:34,662 --> 01:06:36,370
私たちもする必要はありません
もうそれを見てください。

1374
01:06:36,370 --> 01:06:38,711
我々はそれを知っているので
私たちのproblem--の半分

1375
01:06:38,711 --> 01:06:41,210
我々は答えがであることを知っています
私たちの問題の右半分。

1376
01:06:41,210 --> 01:06:42,580
だから我々はちょうど今を見てください。

1377
01:06:42,580 --> 01:06:44,860
>> だから今、私たちは見て
残っているものの真ん中。

1378
01:06:44,860 --> 01:06:46,880
そのインデックス5。

1379
01:06:46,880 --> 01:06:50,200
私たちは再び同じチェックを行います
そして我々はそれが小さいということを参照してください。

1380
01:06:50,200 --> 01:06:52,050
だから我々はその左に目を向けます。

1381
01:06:52,050 --> 01:06:53,430
そして、我々はそのチェックを参照してください。

1382
01:06:53,430 --> 01:06:57,600
配列の値ではあり
インデックス7に等しい4？

1383
01:06:57,600 --> 01:06:58,260
それは。

1384
01:06:58,260 --> 01:07:03,580
だから我々はので、trueを返すことができます
私たちは私たちのリストの値を発見しました。

1385
01:07:03,580 --> 01:07:06,738
私は通過した方法はありません
それは誰にでも意味をなさない？

1386
01:07:06,738 --> 01:07:08,760
OK。

1387
01:07:08,760 --> 01:07:11,670
私のような、多分君たちを与えるでしょう、
把握するには、3つ、4分

1388
01:07:11,670 --> 01:07:13,270
どのようにこれを擬似コードします。

1389
01:07:13,270 --> 01:07:18,070
>> だから私は書くためにあなたに尋ねた想像
返される関数と呼ばれる検索（）

1390
01:07:18,070 --> 01:07:20,640
値、ブール値、
それは、本当だったかのようにfalse--

1391
01:07:20,640 --> 01:07:22,970
あなたが見つかった場合はtrue
値、あなたがなかった場合はfalse。

1392
01:07:22,970 --> 01:07:25,230
そして、あなたがました
値で渡されます

1393
01:07:25,230 --> 01:07:28,410
値に探していたました
ああ、私は間違いなくarray--入れます

1394
01:07:28,410 --> 01:07:29,410
間違った場所にあること。

1395
01:07:29,410 --> 01:07:29,580
OK。

1396
01:07:29,580 --> 01:07:31,829
とにかく、それは持っている必要があります
値の右側に行きました。

1397
01:07:31,829 --> 01:07:36,280
そして、int型のn数であります
その配列の要素の。

1398
01:07:36,280 --> 01:07:39,430
どのようにしようとしに行きますか
でその問題を擬似コードには？

1399
01:07:39,430 --> 01:07:41,630
私はあなたのような人をあげます
それを行うには3分。

1400
01:07:41,630 --> 01:08:00,137

1401
01:08:00,137 --> 01:08:02,595
いいえ、私はonly--あると思います
ええ、ここで1右のアップがあります。

1402
01:08:02,595 --> 01:08:03,261
聴衆：私はできますか？

1403
01:08:03,261 --> 01:08:04,388
ANDI鵬：ええ、私はあなたを得ました。

1404
01:08:04,388 --> 01:08:09,410

1405
01:08:09,410 --> 01:08:11,050
作業ということですか？

1406
01:08:11,050 --> 01:08:12,290
うんいいね。

1407
01:08:12,290 --> 01:10:43,590

1408
01:10:43,590 --> 01:10:44,720
>> OK。

1409
01:10:44,720 --> 01:10:47,630
すべての権利みんな、私たちがしています
でそれを抑制するに行きます。

1410
01:10:47,630 --> 01:10:49,730
OK。

1411
01:10:49,730 --> 01:10:54,020
だから我々は、この素敵なを持っていると仮定
その中のn個の値を持つ小さな配列。

1412
01:10:54,020 --> 01:10:55,170
私は線を描画しませんでした。

1413
01:10:55,170 --> 01:10:58,649
しかし、どのように我々は、約行くだろう
これを書き込もうか！

1414
01:10:58,649 --> 01:11:00,440
誰もがしたいん
私の最初の行を与えますか？

1415
01:11:00,440 --> 01:11:02,814
あなたは私に与えたい場合
この擬似コードの最初の行。

1416
01:11:02,814 --> 01:11:06,563

1417
01:11:06,563 --> 01:11:08,430
>> 聴衆：[聞こえません]

1418
01:11:08,430 --> 01:11:10,138
観客：あなたがしたいと思います
through--反復します

1419
01:11:10,138 --> 01:11:11,094
聴衆：ちょうど別のループのために？

1420
01:11:11,094 --> 01:11:11,760
聴衆：--for。

1421
01:11:11,760 --> 01:11:15,880

1422
01:11:15,880 --> 01:11:17,780
>> ANDI PENG：だからこの1つは少しトリッキーです。

1423
01:11:17,780 --> 01:11:23,130
あなたがしたいと思いますabout--
このループを実行し続けるように

1424
01:11:23,130 --> 01:11:27,950
何度も繰り返し時まで？

1425
01:11:27,950 --> 01:11:30,819
>> 聴衆：[聞こえない]まで
値は、その値に等しいです。

1426
01:11:30,819 --> 01:11:31,610
ANDI PENG：その通り。

1427
01:11:31,610 --> 01:11:33,900
だから、実際にはwrite--ことができます
我々は、さらにそれを簡素化することができます。

1428
01:11:33,900 --> 01:11:35,630
私達はちょうど、whileループを行うことができますか？

1429
01:11:35,630 --> 01:11:39,380
だから、あなただけloop--持つことができます
我々はそれがしばらくだということを知っています。

1430
01:11:39,380 --> 01:11:42,850
しかし、今、私は行きますよ
何を通して -  "ループ"と言うには？

1431
01:11:42,850 --> 01:11:46,640
ループがあるものuntil--
私たちの終了条件？

1432
01:11:46,640 --> 01:11:47,510
私はそれを聞いたと思います。

1433
01:11:47,510 --> 01:11:48,530
私は、誰かがそれを言うのを聞きました。

1434
01:11:48,530 --> 01:11:51,255
>> 聴衆：値が真ん中に等しいです。

1435
01:11:51,255 --> 01:11:52,255
ANDI PENG：再びそれを言います。

1436
01:11:52,255 --> 01:11:54,470
聴衆：または、まで
あなたが探している値

1437
01:11:54,470 --> 01:11:58,470
ためには、中間値に等しいです。

1438
01:11:58,470 --> 01:12:00,280
>> ANDI PENG：それはそこにない場合はどうすれば？

1439
01:12:00,280 --> 01:12:03,113
あなたが検索している場合は、値
ためには、この配列に実際にはないのですか？

1440
01:12:03,113 --> 01:12:05,890
観客：あなたは1を返します。

1441
01:12:05,890 --> 01:12:08,850
>> ANDI PENG：しかし、私たちがしたいですか
我々は条件を持っている場合までループ？

1442
01:12:08,850 --> 01:12:09,350
うん。

1443
01:12:09,350 --> 01:12:11,239
>> 聴衆：唯一つの値がありますまで？

1444
01:12:11,239 --> 01:12:13,530
ANDI PENG：あなたができるループ
だから、あなたがしていることを知っていますuntil--

1445
01:12:13,530 --> 01:12:15,714
右の最大値を、持っているつもり？

1446
01:12:15,714 --> 01:12:18,130
そして、あなたはあなたが行っていることを知っています
右の最小値を、持っていますか？

1447
01:12:18,130 --> 01:12:20,379
また、それが何かだから
私は、前に言うのを忘れました

1448
01:12:20,379 --> 01:12:22,640
だその何か
二分探索に関する重要な

1449
01:12:22,640 --> 01:12:24,182
あなたの配列がすでにソートされていることです。

1450
01:12:24,182 --> 01:12:26,973
行うための方法はありませんので
この彼らはランダムな値をしている場合。

1451
01:12:26,973 --> 01:12:29,190
1のの場合は知りません
他よりも大きく、右？

1452
01:12:29,190 --> 01:12:32,720
>> だから、あなたが知っているあなたのmaxと
あなたの分、右ここにありますか！

1453
01:12:32,720 --> 01:12:35,590
あなたが調整するつもりなら
あなたの分とmid--であなたの最大値

1454
01:12:35,590 --> 01:12:38,470
ちょうどあなたを仮定しましょう
ミッド値は右here--です

1455
01:12:38,470 --> 01:12:43,910
あなたは基本的に行っています
ループあなたの最小になるまで

1456
01:12:43,910 --> 01:12:47,510
右、あなたの最大と同じ、または約
あなたの最大は、あなたの分と同じでない場合。

1457
01:12:47,510 --> 01:12:48,040
右？

1458
01:12:48,040 --> 01:12:51,340
それが起こるとき、あなたがいることを知っているので、
あなたは最終的には同じ値をヒットしました。

1459
01:12:51,340 --> 01:12:59,135
つまり、あなたの分まで、ループにしたいです
以下to--は、おっとあります

1460
01:12:59,135 --> 01:13:01,510
以下に等しくありません、
最大around--他の方法があります。

1461
01:13:01,510 --> 01:13:15,110

1462
01:13:15,110 --> 01:13:16,160
>> それは意味を成していましたか？

1463
01:13:16,160 --> 01:13:18,810
私は、その権利を取得するためにいくつかの試みを取りました。

1464
01:13:18,810 --> 01:13:21,869
しかし、ループあなたの最大値まで
基本的にはほとんど少ないです

1465
01:13:21,869 --> 01:13:23,410
か、最小限に等しく、右？

1466
01:13:23,410 --> 01:13:25,201
あなたが知っているときです
あなたが収束したこと。

1467
01:13:25,201 --> 01:13:29,290
聴衆：ときにあなたの最大のでしょう
値が最小値よりも小さいですか？

1468
01:13:29,290 --> 01:13:31,040
ANDI PENG：あなたが続ける場合
それを調整し、これ

1469
01:13:31,040 --> 01:13:32,380
私たちが行っているものです
この中でやっています。

1470
01:13:32,380 --> 01:13:33,460
それは理にかなっていますか？

1471
01:13:33,460 --> 01:13:35,750
最小値と最大値だけです
我々は、おそらくされている整数

1472
01:13:35,750 --> 01:13:39,260
維持するために作成するつもり
私たちが見ている場所のトラック。

1473
01:13:39,260 --> 01:13:41,790
配列が存在するため、
かかわらず、我々がやっているの。

1474
01:13:41,790 --> 01:13:45,030
同様に、我々は実際に物理的じゃありません
右の配列を、オフにチョッピング？

1475
01:13:45,030 --> 01:13:47,261
私達はちょうど調整しています
ここで我々は探しています。

1476
01:13:47,261 --> 01:13:48,136
それは理にかなっていますか？

1477
01:13:48,136 --> 01:13:48,472
>> 聴衆：うん。

1478
01:13:48,472 --> 01:13:49,110
>> ANDI PENG：[OK]をクリックします。

1479
01:13:49,110 --> 01:13:57,090
だから、私たちのループの条件だと、
我々は、このループの内側に何をしたいですか？

1480
01:13:57,090 --> 01:13:58,700
私たちがやりたいと思っされようとしていますか？

1481
01:13:58,700 --> 01:14:02,390
だから今、私たちは持っています
最大値と最小値、右、

1482
01:14:02,390 --> 01:14:04,962
おそらくどこかにここに作成しました。

1483
01:14:04,962 --> 01:14:07,170
我々は、おそらくするつもりです
右、中央を見つけるには？

1484
01:14:07,170 --> 01:14:08,450
どのように我々はあることを行っています
中央を見つけることができますか？

1485
01:14:08,450 --> 01:14:09,491
何mathematical--

1486
01:14:09,491 --> 01:14:11,079
聴衆：マックスプラス2で割った分。

1487
01:14:11,079 --> 01:14:11,870
ANDI PENG：その通り。

1488
01:14:11,870 --> 01:14:20,300

1489
01:14:20,300 --> 01:14:21,620
それは理にかなっていますか？

1490
01:14:21,620 --> 01:14:25,780
なぜ私たちとあなたたちは見ています
我々はこれをしなかった理由はただuse--ませんでした

1491
01:14:25,780 --> 01:14:27,850
だけではなく、やってN 2で割りましたの？

1492
01:14:27,850 --> 01:14:30,310
nが値であるからです
それは同じままになるだろう。

1493
01:14:30,310 --> 01:14:30,979
右？

1494
01:14:30,979 --> 01:14:34,020
しかし、我々は我々の最小値を調整するとし、
最大値は、彼らが変更しようとしています。

1495
01:14:34,020 --> 01:14:36,040
その結果、私たちの真ん中
あまりにも変更する予定です。

1496
01:14:36,040 --> 01:14:37,873
私たちが望むだから、なぜです
ここでこの権利を行います。

1497
01:14:37,873 --> 01:14:38,510
OK。

1498
01:14:38,510 --> 01:14:41,600
>> そして、今では
我々はええour--がわかりました。

1499
01:14:41,600 --> 01:14:44,270
>> 聴衆：だけで簡単にquestion--
あなたは最小値と最大値を言うとき、

1500
01:14:44,270 --> 01:14:46,410
我々はそれを想定しています
それはすでにソートですか？

1501
01:14:46,410 --> 01:14:48,400
>> ANDI PENG：ええ、それは実際にはです
二分探索のための前提条件、

1502
01:14:48,400 --> 01:14:49,816
あなたはそれがソートであることを知っている必要があること。

1503
01:14:49,816 --> 01:14:53,660
並べ替え、あなたに書く理由であります
問題は、二分探索の前に設定してください。

1504
01:14:53,660 --> 01:14:55,910
OK。

1505
01:14:55,910 --> 01:14:58,876
だから今我々はどこに私達の中間点を知っていること
あなたがここで何をしたいか、何ですか？

1506
01:14:58,876 --> 01:15:01,789

1507
01:15:01,789 --> 01:15:04,319
>> 観客：我々は比較したいです
他のものにそれ。

1508
01:15:04,319 --> 01:15:05,110
ANDI PENG：その通り。

1509
01:15:05,110 --> 01:15:12,280
だから、比較しようとしています
値半ば、右？

1510
01:15:12,280 --> 01:15:14,900

1511
01:15:14,900 --> 01:15:18,670
そして、それは何を教えてくれありません
私たち私たちは比較すると？

1512
01:15:18,670 --> 01:15:22,226
私たちは、その後何をしたいですか？

1513
01:15:22,226 --> 01:15:25,389
>> 観客：値が大きい場合
半ばより、我々はそれをカットします。

1514
01:15:25,389 --> 01:15:26,180
ANDI PENG：その通り。

1515
01:15:26,180 --> 01:15:33,940
値が大きい場合にはそう
半ばよりも、私たちはしています

1516
01:15:33,940 --> 01:15:36,550
これらを変更するつもり
最小値とmaxes、右？

1517
01:15:36,550 --> 01:15:38,980
私たちは、変更したいのですか？

1518
01:15:38,980 --> 01:15:42,145
私たちが知っているのであれば値がどこかにありま​​す
ここで、あなたは私たちが何を変更するのですか？

1519
01:15:42,145 --> 01:15:44,758
私たちはを変更したいです
半ば、正しいと最小？

1520
01:15:44,758 --> 01:15:49,420

1521
01:15:49,420 --> 01:15:54,292
そして、他の、それはこの中だ場合
半分、私たちは、変更したいのですか？

1522
01:15:54,292 --> 01:15:55,306
>> 聴衆：あなたの最大。

1523
01:15:55,306 --> 01:15:55,972
ANDI PENG：うん。

1524
01:15:55,972 --> 01:16:02,597

1525
01:16:02,597 --> 01:16:04,680
そしてあなただけのつもり
右、ループ維持するには？

1526
01:16:04,680 --> 01:16:08,920
今あるので、一回の反復後
あなたはここで最大を持っています。

1527
01:16:08,920 --> 01:16:10,760
そして、あなたは半ばを再計算することができます。

1528
01:16:10,760 --> 01:16:11,990
そして、あなたは比較することができます。

1529
01:16:11,990 --> 01:16:14,766
そして、あなたは続けるつもりです
分、maxesまで

1530
01:16:14,766 --> 01:16:15,890
基本的に収束しました。

1531
01:16:15,890 --> 01:16:17,890
そして、あなたがいることを知っているときそれはです
あなたはそれの終わりをヒットしました。

1532
01:16:17,890 --> 01:16:20,280
そして、あなたはそれを見つけたのいずれか
または、あなたはその時点で持っていません。

1533
01:16:20,280 --> 01:16:23,170
>> これは誰にでも意味がありますか？

1534
01:16:23,170 --> 01:16:26,020

1535
01:16:26,020 --> 01:16:26,770
OK。

1536
01:16:26,770 --> 01:16:27,900
これはかなり重要であり、
あなたが持っているだろうから

1537
01:16:27,900 --> 01:16:29,760
コー​​ド今夜でこれを書いてください。

1538
01:16:29,760 --> 01:16:32,660
しかし、あなたたちはかなり良いを持っています
あなたがやるべきことの意味、

1539
01:16:32,660 --> 01:16:34,051
これは良いです。

1540
01:16:34,051 --> 01:16:34,550
OK。

1541
01:16:34,550 --> 01:16:38,840
だから我々は、約7を持っています
分は、セクションを残しました。

1542
01:16:38,840 --> 01:16:43,170
だから我々はについて話をするつもりです
私たちがやっているだろう、このPSET。

1543
01:16:43,170 --> 01:16:46,410
だから、PSETは半分ずつに分かれています。

1544
01:16:46,410 --> 01:16:50,230
前半は含ま
検索を実装

1545
01:16:50,230 --> 01:16:54,210
これであなたは、線形探索、Aを書き込みます
バイナリ検索、ソートアルゴリズム。

1546
01:16:54,210 --> 01:16:56,690
>> だから、これは最初のものです
ここで、PSETの時間

1547
01:16:56,690 --> 01:17:00,050
呼ばれるもの私たちはあなたにみんなを与えることでしょう
配信コード、コードは

1548
01:17:00,050 --> 01:17:02,740
我々は、事前に書かれていること、
ちょうどオフいくつかの作品を残しました

1549
01:17:02,740 --> 01:17:04,635
あなたが書き込みを完了するため。

1550
01:17:04,635 --> 01:17:07,510
だからみんな、あなたがこれを見て
コー​​ド、あなたは本当に怖いかもしれません。

1551
01:17:07,510 --> 01:17:08,630
あなたは、私は、ああ、同じようにしている場合
それはやっているかわかりません、

1552
01:17:08,630 --> 01:17:11,670
私のような、それはそう、知りません
ああ、リラックス、非常に複雑。

1553
01:17:11,670 --> 01:17:12,170
大丈夫です。

1554
01:17:12,170 --> 01:17:12,930
仕様をお読みください。

1555
01:17:12,930 --> 01:17:16,920
仕様は正確にあなたに説明します
これらのプログラムのすべてが何をしています。

1556
01:17:16,920 --> 01:17:20,560
>> 例えば、generate.cはプログラムであります
それはあなたのpsetが付属します。

1557
01:17:20,560 --> 01:17:24,060
あなたが実際にそれに触れる必要はありませんが、
あなたはそれがやっているかを理解する必要があります。

1558
01:17:24,060 --> 01:17:28,550
そしてgenerate.c、それはやっているすべてがあります
いずれかの乱数を生成します

1559
01:17:28,550 --> 01:17:32,400
または、あなたは次のように、それにシードを与えることができます
それが取る事前に決められた数、

1560
01:17:32,400 --> 01:17:34,140
それはより多くの数を生成します。

1561
01:17:34,140 --> 01:17:37,170
だから、特有の方法があります
ここでgenerate.cを実装

1562
01:17:37,170 --> 01:17:42,760
あなただけの数の束を作ることができます
あなたは他の方法でテストするため。

1563
01:17:42,760 --> 01:17:45,900
>> だから、あなたがしたい場合のために
例えば、あなたの検索をテストし、

1564
01:17:45,900 --> 01:17:48,970
あなたがgenerate.cを実行したいと思います、
数字の束を生成し、

1565
01:17:48,970 --> 01:17:50,880
そして、あなたのヘルパー関数を実行します。

1566
01:17:50,880 --> 01:17:53,930
あなたのヘルパー関数君がいる場所です
実際に物理的にコードを書きます。

1567
01:17:53,930 --> 01:17:59,330
また、ライブラリファイルとしてヘルパーを考えます
あなたは、検索を呼び出していること書いています。

1568
01:17:59,330 --> 01:18:02,950
そうhelpers.c内および、あなたはよ
検索とソートを行います。

1569
01:18:02,950 --> 01:18:06,500
>> そして、あなたは本質的になるだろう
ただ一緒にすべてを置きます。

1570
01:18:06,500 --> 01:18:10,350
スペックはどのように教えてくれます
コマンドラインでそれを置きます。

1571
01:18:10,350 --> 01:18:14,880
そして、あなたがいるかどうかをテストすることができるでしょうか
ないあなたのソートや検索が働いています。

1572
01:18:14,880 --> 01:18:15,870
クール。

1573
01:18:15,870 --> 01:18:18,720
誰もがすでに始まっていると
遭遇した問題や疑問

1574
01:18:18,720 --> 01:18:20,520
彼らはこれを今持っていますか？

1575
01:18:20,520 --> 01:18:21,020
OK。

1576
01:18:21,020 --> 01:18:21,476
>> 聴衆：待ちます。

1577
01:18:21,476 --> 01:18:21,932
質問があります。

1578
01:18:21,932 --> 01:18:22,844
>> ANDI PENG：うん。

1579
01:18:22,844 --> 01:18:28,390
>> 聴衆：だから私は始め
helpers.cで線形検索

1580
01:18:28,390 --> 01:18:29,670
そしてそれは実際に働いていませんでした。

1581
01:18:29,670 --> 01:18:34,590
しかし、その後、私はちょうど私たちを発見
それを削除して、二分探索を行う必要があります。

1582
01:18:34,590 --> 01:18:36,991
それが動作しないのであればそれは問題ではありませんか？

1583
01:18:36,991 --> 01:18:39,700

1584
01:18:39,700 --> 01:18:41,510
>> ANDI PENG：短い答えはノーです。

1585
01:18:41,510 --> 01:18:42,642
しかし、我々はnot--ているので、

1586
01:18:42,642 --> 01:18:44,350
聴衆：しかし、誰の
実際に確認します。

1587
01:18:44,350 --> 01:18:46,058
ANDI PENG：私たちは決してなりません
それを見に行きます。

1588
01:18:46,058 --> 01:18:49,590
しかし、あなたはおそらくしたいです
必ずあなたの検索が機能しています。

1589
01:18:49,590 --> 01:18:51,700
あなたの線形場合ので、
検索が動作しません、

1590
01:18:51,700 --> 01:18:54,410
その後、チャンスはあなたのバイナリで
検索は、同様に仕事に行くされていません。

1591
01:18:54,410 --> 01:18:56,646
あなたが同様の持っているので
それらの両方のロジック。

1592
01:18:56,646 --> 01:18:58,020
そして、いや、それは本当に問題ではありません。

1593
01:18:58,020 --> 01:19:01,300
だから、唯一のものはあなたが有効にします
ソート、バイナリ検索があります。

1594
01:19:01,300 --> 01:19:02,490
うん。

1595
01:19:02,490 --> 01:19:06,610
>> そしてまた、子供たちがたくさんいました
helpers.cをコンパイルしようとしています。

1596
01:19:06,610 --> 01:19:09,550
あなたが実際に許可されていません
これを行うには、helpers.c理由

1597
01:19:09,550 --> 01:19:11,200
主な機能はありません。

1598
01:19:11,200 --> 01:19:13,550
だからあなただけのはず
実際にコンパイルします

1599
01:19:13,550 --> 01:19:18,670
呼び出しを見つけるために、生成して見つけます
helpers.cとその中の機能。

1600
01:19:18,670 --> 01:19:20,790
だから、デバッグになります
お尻の痛み。

1601
01:19:20,790 --> 01:19:22,422
しかし、それは私たちがしなければならないものです。

1602
01:19:22,422 --> 01:19:23,880
観客：あなたはちょうど、すべてを作りますか？

1603
01:19:23,880 --> 01:19:27,290
ANDI PENG：あなただけのことができます
ええ、すべて同様に作ります。

1604
01:19:27,290 --> 01:19:28,060
OK。

1605
01:19:28,060 --> 01:19:32,570
だから、何の観点から、それです
PSETはあなたのすべてが何を求めています。

1606
01:19:32,570 --> 01:19:35,160
ご質問があれば、感じます
セクションの後に私に質問して自由に。

1607
01:19:35,160 --> 01:19:37,580
私は20分、のような、のためにここにいますよ。

1608
01:19:37,580 --> 01:19:40,500
>> そして、ええ、PSET年代
本当に悪いことではありません。

1609
01:19:40,500 --> 01:19:41,680
君たちはOKである必要があります。

1610
01:19:41,680 --> 01:19:43,250
これらは、単にガイドラインに従ってください。

1611
01:19:43,250 --> 01:19:47,840
種類の、論理的に、何の意味を持っています
起こってされるべきであり、あなたは大丈夫です。

1612
01:19:47,840 --> 01:19:48,690
あまりにも怖がってはいけません。

1613
01:19:48,690 --> 01:19:50,220
多くのコードがあります
すでにそこに書かれました。

1614
01:19:50,220 --> 01:19:53,011
あなたがいない場合、あまりにも怖がってはいけません
すべてのことが何を意味するのか理解しています。

1615
01:19:53,011 --> 01:19:54,749
それは多くの場合は、それは完全に罰金です。

1616
01:19:54,749 --> 01:19:55,790
また、営業時間に来ます。

1617
01:19:55,790 --> 01:19:57,520
私たちは、あなたが見てお手伝いします。

1618
01:19:57,520 --> 01:20:00,810
>> 聴衆：余分付き
機能は、私たちはそれらを求めますか？

1619
01:20:00,810 --> 01:20:03,417
>> ANDI PENG：ええ、それらはコードです。

1620
01:20:03,417 --> 01:20:05,750
15のゲームでは、の半分
それは既にあなたのために書かれています。

1621
01:20:05,750 --> 01:20:09,310
だから、それらの機能があります
すでにコードインチ

1622
01:20:09,310 --> 01:20:12,020
うん。

1623
01:20:12,020 --> 01:20:12,520
大丈夫。

1624
01:20:12,520 --> 01:20:14,000
まあ、最高の幸運。

1625
01:20:14,000 --> 01:20:15,180
それは嫌な日です。

1626
01:20:15,180 --> 01:20:19,370
だから、うまくいけば、あなたたちは、あまりにも感じることはありません
内部滞在し、コーディングの悪いです。

1627
01:20:19,370 --> 01:20:22,133