1
00:00:00,000 --> 00:00:08,250

2
00:00:08,250 --> 00:00:12,680
>> JASONハーシュホーン：みんなを歓迎
第七。

3
00:00:12,680 --> 00:00:15,040
我々はもちろん、週7である。

4
00:00:15,040 --> 00:00:18,440
この今後の木曜日
ハロウィーンは、私は私である

5
00:00:18,440 --> 00:00:21,420
カボチャのようにドレスアップ。

6
00:00:21,420 --> 00:00:23,460
私は腰をかがめると装着ができませんでした
私の靴、私はなぜそれがだ

7
00:00:23,460 --> 00:00:25,660
ちょうど靴下を着用しています。

8
00:00:25,660 --> 00:00:29,220
私はまた、下に何も着ていないよ
これ、それはですので、もし、私はそれを取ることはできません

9
00:00:29,220 --> 00:00:29,950
あなたに邪魔。

10
00:00:29,950 --> 00:00:31,860
私はそのため、事前にお詫び申し上げます。

11
00:00:31,860 --> 00:00:33,170
あなたが想像する必要はありません。
何が起こっている。

12
00:00:33,170 --> 00:00:34,240
私はボクサーを着ています。

13
00:00:34,240 --> 00:00:36,170
だから、すべての良いことだ。

14
00:00:36,170 --> 00:00:41,120
>> 私は、私は理由について長い話を持っている
カボチャに扮したが、私はするつもりだ

15
00:00:41,120 --> 00:00:45,110
後でこのセクションのためにそれを保存
私は始めたくないからです。

16
00:00:45,110 --> 00:00:47,720
我々はエキサイティングなことがたくさんある
今週の上に行くために。

17
00:00:47,720 --> 00:00:51,810
それらのほとんどは、これに直接関係
今週の問題セット、スペルミス。

18
00:00:51,810 --> 00:00:54,680
また、リンクされた上で行くことになるだろう
リストやハッシュテーブル

19
00:00:54,680 --> 00:00:57,160
セクション全体のため。

20
00:00:57,160 --> 00:01:02,490
私は、毎週のリストをこのリストを設置
あなたとあなたを助けるためにするためのリソース

21
00:01:02,490 --> 00:01:04,120
このコースに重要。

22
00:01:04,120 --> 00:01:07,600
損失で、またはいくつかを探していた場合：
詳細については、次のいずれかをチェックしてください

23
00:01:07,600 --> 00:01:09,930
これらのリソース。

24
00:01:09,930 --> 00:01:14,530
>> ここでも、pset6はスペル​​ミスで、
今週のPSET。

25
00:01:14,530 --> 00:01:17,690
そしてそれはまた、あなたを奨励し、私
他のいくつかを使用するように、なることをお勧めします

26
00:01:17,690 --> 00:01:20,320
特にこのPSETためのリソース。

27
00:01:20,320 --> 00:01:23,390
特に、3は私だ
画面上にリストアップ - 

28
00:01:23,390 --> 00:01:27,160
我々は精通してきたGDB、
そして今、しばらくの間使用してきている

29
00:01:27,160 --> 00:01:29,270
今週非常に参考になるだろう。

30
00:01:29,270 --> 00:01:30,190
だから私はここにそれを広げた。

31
00:01:30,190 --> 00:01:32,910
しかし、いつでも、Cで作業している、
あなたはいつもにGDBを使用する必要があります

32
00:01:32,910 --> 00:01:34,430
プログラムをデバッグします。

33
00:01:34,430 --> 00:01:36,660
今週もValgrindは。

34
00:01:36,660 --> 00:01:38,535
誰もがValgrindのが何を知っていますか？

35
00:01:38,535 --> 00:01:42,184

36
00:01:42,184 --> 00:01:43,890
>> 観客：これは、メモリリークをチェックする？

37
00:01:43,890 --> 00:01:45,950
>> JASONハーシュホーン：Valgrindの
メモリリークをチェックします。

38
00:01:45,950 --> 00:01:49,970
もしそうなら、あなたのmalloc何かお
プログラムは、メモリーのために求めている。

39
00:01:49,970 --> 00:01:52,920
あなたのプログラムの最後には、次のものが
あなたがしたすべてのものに無料で書き込む

40
00:01:52,920 --> 00:01:54,800
メモリをお返しするためにmallocさ。

41
00:01:54,800 --> 00:01:58,420
あなたが最後に自由記述していない場合は
あなたのプログラムは、結論に来る、

42
00:01:58,420 --> 00:02:00,000
すべてが自動的になります
解放される。

43
00:02:00,000 --> 00:02:02,340
と小さなプログラムのために、それはだ
ていないことを大したこと。

44
00:02:02,340 --> 00:02:05,250
しかし、あなたは長いランニングを書いているのであれば
終了しないプログラム、

45
00:02:05,250 --> 00:02:09,180
必ずしも、分またはAのカップルで
数秒後、メモリリーク

46
00:02:09,180 --> 00:02:10,710
巨大な契約になることができます。

47
00:02:10,710 --> 00:02:14,940
>> そうpset6ため、期待があることである
あなたは、ゼロメモリリークを持つことになります

48
00:02:14,940 --> 00:02:15,910
あなたのプログラム。

49
00:02:15,910 --> 00:02:18,690
メモリリークをチェックするには、実行してvalgrindの
そしてそれはあなたにいくつかの素敵なをあげる

50
00:02:18,690 --> 00:02:21,190
出力しているかどうかを知らせる
またはすべてが無料だったわけではありません。

51
00:02:21,190 --> 00:02:23,940
我々は、後でそれを練習します
今日では、うまくいけば。

52
00:02:23,940 --> 00:02:25,790
>> 最後に、diffコマンド。

53
00:02:25,790 --> 00:02:28,900
あなたはそれに似たものを使用
PEEKツールでpset5中。

54
00:02:28,900 --> 00:02:30,780
あなたの中に見ることができました。

55
00:02:30,780 --> 00:02:33,400
また、あたりも、差分を使用
問題は、仕様を設定してください。

56
00:02:33,400 --> 00:02:35,950
しかし、あなたはに許可された
2つのファイルを比較します。

57
00:02:35,950 --> 00:02:39,180
あなたは、ビットマップファイルとを比較することができ
インフォスタッフ液のヘッダと

58
00:02:39,180 --> 00:02:42,200
pset5でソリューションの場合
あなたはそれを使用することにしました。

59
00:02:42,200 --> 00:02:44,030
diffはあなたができるようになります
だけでなく、それを行う。

60
00:02:44,030 --> 00:02:48,620
あなたがのために正しい答えを比較することができます
あなたの答えに設定今週の問題

61
00:02:48,620 --> 00:02:52,210
と表示された場合、それまでの線または参照
どこにエラーがある。

62
00:02:52,210 --> 00:02:55,870
>> ので、これらは3つの良いツールであることを
あなたは今週のために使用する必要がありますし、

63
00:02:55,870 --> 00:02:58,130
間違いなくあなたのプログラムをチェック
これら3つのツールで

64
00:02:58,130 --> 00:03:00,520
それをインチにする前に

65
00:03:00,520 --> 00:03:04,650
繰り返しますが、私は毎週述べたように、
両方 - あなたは私のためのフィードバックがあれば

66
00:03:04,650 --> 00:03:06,470
正かつ建設 - 

67
00:03:06,470 --> 00:03:09,930
ウェブサイトに向かう気軽に
このスライドの下部にある

68
00:03:09,930 --> 00:03:11,270
そして入力がそれ。

69
00:03:11,270 --> 00:03:13,440
私は実際にどんな感謝
そしてすべてのフィードバック。

70
00:03:13,440 --> 00:03:17,360
そして、あなたは私にその具体的なものを与える場合は、
私は、私はあることを改善するために、またはすることができます

71
00:03:17,360 --> 00:03:21,350
あなたはに私をしたいことをよくやって
続けて、私は心にそれを取ると、

72
00:03:21,350 --> 00:03:24,040
本当に耳を傾ける努力
ご意見·ご感想を。

73
00:03:24,040 --> 00:03:27,720
私は私がするつもりだ約束することはできません
すべてのものは、しかし、身に着けているような

74
00:03:27,720 --> 00:03:30,700
毎週コスチュームパンプキン。

75
00:03:30,700 --> 00:03:34,020
>> だから我々はの大半を過ごすつもりです
セクションには、私が述べたように、の話

76
00:03:34,020 --> 00:03:37,240
リンクリストやハッシュテーブル、その
に直接適用されます

77
00:03:37,240 --> 00:03:38,780
問題は、この一週間に設定。

78
00:03:38,780 --> 00:03:42,580
リンクリストは、我々は比較的オーバー行くよ
すぐに我々は公平なビットを費やしてきたので、

79
00:03:42,580 --> 00:03:44,930
時間の欄でその上を行く。

80
00:03:44,930 --> 00:03:48,680
そして私たちはまっすぐに買ってあげる
リンクされたリストのための問題をコードする。

81
00:03:48,680 --> 00:03:52,740
した後、最後に、我々はについて話します
彼らがこれにどのように適用されるかのテーブルをハッシュし、

82
00:03:52,740 --> 00:03:55,280
今週の問題は、設定してください。

83
00:03:55,280 --> 00:03:57,560
>> あなたは前に、このコードを見てきました。

84
00:03:57,560 --> 00:04:02,730
これは構造体であり、それは定義されている
ノードと呼ばれる新しい何か。

85
00:04:02,730 --> 00:04:10,660
およびノー​​ド内の整数があります
右こことへのポインタがあります

86
00:04:10,660 --> 00:04:11,830
別のノード。

87
00:04:11,830 --> 00:04:12,790
我々は前にこれを見てきました。

88
00:04:12,790 --> 00:04:14,830
これはのために控えてきた
今数週間。

89
00:04:14,830 --> 00:04:18,680
それは我々がしてきたポインタを兼ね備え
可能にし、構造体を操作

90
00:04:18,680 --> 00:04:22,079
私たちは、別の2を結合する
1データ型に物事。

91
00:04:22,079 --> 00:04:24,830

92
00:04:24,830 --> 00:04:26,490
>> 画面上で起こってたくさんあり​​ます。

93
00:04:26,490 --> 00:04:30,220
しかし、それはすべて、比較的であるべき
あなたに精通している。

94
00:04:30,220 --> 00:04:33,810
最初の行では、我々
新しいノードを宣言します。

95
00:04:33,810 --> 00:04:41,650
そして、その新しいノードの内部で、私はセット
1にそのノード内の整数。

96
00:04:41,650 --> 00:04:44,950
私たちは、私がやっている次の行を参照してください
printfコマンドが、私はグレー表示されました

97
00:04:44,950 --> 00:04:48,080
printfコマンドは本当に理由
重要な部分はここに、このラインである - 

98
00:04:48,080 --> 00:04:50,020
new_node.n。

99
00:04:50,020 --> 00:04:51,270
ドットは何を意味するのでしょうか？

100
00:04:51,270 --> 00:04:53,810

101
00:04:53,810 --> 00:04:57,240
>> 観客：ノードに移動し、
それのためのn値を評価します。

102
00:04:57,240 --> 00:04:58,370
>> JASONハーシュホーン：それです。
まったく正しい。

103
00:04:58,370 --> 00:05:03,300
ドットは、n個の部分にアクセスを意味
この新しいノードの。

104
00:05:03,300 --> 00:05:05,690
この次の行は何をしますか？

105
00:05:05,690 --> 00:05:16,140

106
00:05:16,140 --> 00:05:17,050
マイケル。

107
00:05:17,050 --> 00:05:21,910
>> 観客：それは別のノードを作成します
つまり、新しいノードを指すようになります。

108
00:05:21,910 --> 00:05:24,870
>> JASONハーシュホーン：だからそれはしていません
新しいノードを作成します。

109
00:05:24,870 --> 00:05:26,120
それは何を作成します？

110
00:05:26,120 --> 00:05:28,300

111
00:05:28,300 --> 00:05:29,300
>> 観客：ポインター。

112
00:05:29,300 --> 00:05:33,460
>> JASONハーシュホーン：ノードへのポインタ、
ここで、このノード*で示すように

113
00:05:33,460 --> 00:05:34,800
だから、ノードへのポインタを作成します。

114
00:05:34,800 --> 00:05:37,490
そして、それはどのノードを指している
マイケルに？

115
00:05:37,490 --> 00:05:38,440
>> 観客：新しいノード？

116
00:05:38,440 --> 00:05:39,240
>> JASONハーシュホーン：新しいノード。

117
00:05:39,240 --> 00:05:43,020
我々はしましたので、それはそこに指して
それを新たなノードのアドレスを与えられた。

118
00:05:43,020 --> 00:05:45,820
そして今、この行では、参照してください。
の2種類の方法

119
00:05:45,820 --> 00:05:46,910
同じことを表現する。

120
00:05:46,910 --> 00:05:49,650
と私は指摘したいと思ったどのようにこれらの
二つのことは同じです。

121
00:05:49,650 --> 00:05:54,740
最初の行では、間接参照
ポインター。

122
00:05:54,740 --> 00:05:55,830
だから我々はノードに移動します。

123
00:05:55,830 --> 00:05:56,830
つまり、この星が何を意味するのです。

124
00:05:56,830 --> 00:05:57,930
私たちは、ポインタを持つ前に、それを見てきました。

125
00:05:57,930 --> 00:05:59,280
そのノードに移動します。

126
00:05:59,280 --> 00:06:00,370
これはカッコ内にあります。

127
00:06:00,370 --> 00:06:04,610
して、ドット演算子を経由してアクセスする
そのノードのn個の要素。

128
00:06:04,610 --> 00:06:08,430
>> だから構文を取っている
我々は今ここで見た

129
00:06:08,430 --> 00:06:09,670
ポインタとそれを用いた。

130
00:06:09,670 --> 00:06:13,730
もちろん、もし忙しいの種類を取得します
あなたは、これらの括弧を書いている - 

131
00:06:13,730 --> 00:06:14,940
あの星とそのドット。

132
00:06:14,940 --> 00:06:16,220
それは少し忙しい。

133
00:06:16,220 --> 00:06:18,500
だから我々は、いくつかのシンタックスシュガーを持っています。

134
00:06:18,500 --> 00:06:19,920
この行はここ - 

135
00:06:19,920 --> 00:06:21,170
ptr_node-> N。

136
00:06:21,170 --> 00:06:25,400

137
00:06:25,400 --> 00:06:28,000
つまり、まったく同じことを行います。

138
00:06:28,000 --> 00:06:30,840
ように、コードの2行があります
同等と行います

139
00:06:30,840 --> 00:06:31,650
まったく同じこと。

140
00:06:31,650 --> 00:06:34,210
>> しかし、私は前にそれらを指摘したかった
あなたが理解しておりますので先に進む

141
00:06:34,210 --> 00:06:39,000
本当に正しいここにこの事があることを
逆参照のためだけ糖衣構文

142
00:06:39,000 --> 00:06:44,200
ポインタ、その後に行く
その構造体のnの部分。

143
00:06:44,200 --> 00:06:45,525
このスライドについてのご質問？

144
00:06:45,525 --> 00:06:53,020

145
00:06:53,020 --> 00:06:54,390
[OK]をクリックします。

146
00:06:54,390 --> 00:06:58,510
>> だから我々は、カップルを通過しようとしている
あなたが行うことができます操作の

147
00:06:58,510 --> 00:06:59,730
リンクされたリスト。

148
00:06:59,730 --> 00:07:05,770
リンクリスト、リコールは、一連の
互いを指すノード。

149
00:07:05,770 --> 00:07:12,470
そして、我々は一般的にはポインタで始まる
一般的に、ヘッドと呼ばれる、を指していることを

150
00:07:12,470 --> 00:07:14,040
リストの最初のもの。

151
00:07:14,040 --> 00:07:18,900
我々は、ここで最初の行にそう
まず私たちのオリジナルのLを持っています。

152
00:07:18,900 --> 00:07:21,370
だから、そのことは、あなたが考えることができます - この
テキスト右ここでは、などと考えることができます

153
00:07:21,370 --> 00:07:23,560
我々は保存されてきたばかりのポインタ
どこかのポイント

154
00:07:23,560 --> 00:07:24,670
最初の要素へ。

155
00:07:24,670 --> 00:07:27,500
このリンクリスト内の
我々は4つのノードがあります。

156
00:07:27,500 --> 00:07:29,530
各ノードは、大きな箱です。

157
00:07:29,530 --> 00:07:33,430
大きな内部大きな箱
ボックスには、整数部分である。

158
00:07:33,430 --> 00:07:37,400
そして、我々は、ポインタの部分を持っている。

159
00:07:37,400 --> 00:07:39,630
>> これらのボックスは、描かれていない
スケールの大きさとは理由

160
00:07:39,630 --> 00:07:42,320
バイト単位の整数？

161
00:07:42,320 --> 00:07:43,290
どのくらいになりました？

162
00:07:43,290 --> 00:07:43,710
四つ。

163
00:07:43,710 --> 00:07:45,470
ポインタはどのように大きいです！

164
00:07:45,470 --> 00:07:45,940
四つ。

165
00:07:45,940 --> 00:07:48,180
だから本当に、我々は描画した場合
この両方のボックスをスケールする

166
00:07:48,180 --> 00:07:49,690
同じサイズになります。

167
00:07:49,690 --> 00:07:52,870
このケースでは、挿入する
リンクされたリストに、何か。

168
00:07:52,870 --> 00:07:57,190
だから、我々は挿入している、ここでダウンして見ることができます
5私たちはを横断

169
00:07:57,190 --> 00:08:01,310
リンクリスト、5見つける
行くし、それを挿入します。

170
00:08:01,310 --> 00:08:03,560
>> それを打破してみましょうと行く
もう少しゆっくり。

171
00:08:03,560 --> 00:08:05,510
私は、ボードを指すことにします。

172
00:08:05,510 --> 00:08:09,930
だから我々は我々のノードが5という
私たちは、mallocはで作成しました。

173
00:08:09,930 --> 00:08:11,190
なぜ誰もが笑っている？

174
00:08:11,190 --> 00:08:12,130
ほんの冗談です。

175
00:08:12,130 --> 00:08:13,310
[OK]をクリックします。

176
00:08:13,310 --> 00:08:14,820
だから我々は5をmallocさだ。

177
00:08:14,820 --> 00:08:16,310
私たちは、このノードを作成しました
どこか別の場所。

178
00:08:16,310 --> 00:08:17,740
我々は行くこと準備ができている。

179
00:08:17,740 --> 00:08:20,130
私たちは、目の前に開始
2との私たちのリスト。

180
00:08:20,130 --> 00:08:22,380
そして、我々は挿入したい
ソートされた方法で。

181
00:08:22,380 --> 00:08:27,550
>> だから我々は2を参照してください、私たちは入れたい場合は、
我々が見たときに5に、私たちは何をしますか

182
00:08:27,550 --> 00:08:28,800
私たちより少ない何か？

183
00:08:28,800 --> 00:08:31,850

184
00:08:31,850 --> 00:08:33,520
何が？

185
00:08:33,520 --> 00:08:36,750
我々は、この中に5を挿入したい
リンクリスト、それがソート保つ。

186
00:08:36,750 --> 00:08:37,520
私たちは、数2を参照してください。

187
00:08:37,520 --> 00:08:38,769
だから我々は何をしますか？

188
00:08:38,769 --> 00:08:39,179
マーカス？

189
00:08:39,179 --> 00:08:40,679
>> 観客：ポインタを呼び出し
次のノードに。

190
00:08:40,679 --> 00:08:42,530
>> JASONハーシュホーン：そしてなぜ
私たちは、次のいずれかに行く？

191
00:08:42,530 --> 00:08:45,970
>> 観客：それはだから
リスト内の次のノード。

192
00:08:45,970 --> 00:08:48,310
そして、我々はそれだけで、他の場所を知っている。

193
00:08:48,310 --> 00:08:50,410
>> JASONハーシュホーン：そして5は大きい
特に、2つより。

194
00:08:50,410 --> 00:08:51,600
我々は、ソートそれを維持したいので。

195
00:08:51,600 --> 00:08:52,730
そのように5つが2以上である。

196
00:08:52,730 --> 00:08:54,460
だから我々は、次のものに移動する。

197
00:08:54,460 --> 00:08:55,240
そして今、我々は4に達する。

198
00:08:55,240 --> 00:08:56,490
我々は4に達したときに、何が起こりますか？

199
00:08:56,490 --> 00:08:58,920

200
00:08:58,920 --> 00:09:00,310
>> ファイブは4より大きい。

201
00:09:00,310 --> 00:09:01,460
だから我々は続ける。

202
00:09:01,460 --> 00:09:03,110
そして今、我々は6にいる。

203
00:09:03,110 --> 00:09:04,360
そして、我々は6で何を見ていますか？

204
00:09:04,360 --> 00:09:08,672

205
00:09:08,672 --> 00:09:09,608
はい、カルロス·？

206
00:09:09,608 --> 00:09:10,544
>> 観客：シックス5より大きい。

207
00:09:10,544 --> 00:09:11,480
>> JASONハーシュホーン：シックスです
5よりも大きい。

208
00:09:11,480 --> 00:09:13,660
私たちが望む場所だからです
5を挿入します。

209
00:09:13,660 --> 00:09:17,320
しかし、覚えておいて、もし私たち
ここでしか1ポインタを持っている - 

210
00:09:17,320 --> 00:09:19,840
これはです私達の余分なポインタである
リストを横断する。

211
00:09:19,840 --> 00:09:21,860
そして、我々は6を指しています。

212
00:09:21,860 --> 00:09:25,010
私たちは何のトラックを失ってしまった
6の前に来る。

213
00:09:25,010 --> 00:09:29,130
だから我々はに何かを挿入したい場合は、
このリストはソートされ、それを維持し、我々は

214
00:09:29,130 --> 00:09:31,630
おそらくどのように多くのポインタが必要ですか？

215
00:09:31,630 --> 00:09:32,280
>> 観客：二つ。

216
00:09:32,280 --> 00:09:32,920
>> JASON HIRSCHORN：二つ。

217
00:09:32,920 --> 00:09:35,720
電流を追跡するOne
1とを追跡するための1

218
00:09:35,720 --> 00:09:37,050
以前の1。

219
00:09:37,050 --> 00:09:38,450
これは、シングルリンクリストです。

220
00:09:38,450 --> 00:09:39,670
これは、一方向のみに進む。

221
00:09:39,670 --> 00:09:43,220
私たちは二重にリンクされたリストを持っていた場合、どこで
すべてが事を指していた

222
00:09:43,220 --> 00:09:46,240
ITとその前のものは、後
我々はそれをする必要はありません。

223
00:09:46,240 --> 00:09:49,350
しかし、このケースでは、失いたくない
ケースで私たちの前に来たもののトラック

224
00:09:49,350 --> 00:09:53,350
我々は5のどこかに挿入する必要があります
真ん中に。

225
00:09:53,350 --> 00:09:55,610
我々は9を挿入されたと言う。

226
00:09:55,610 --> 00:09:57,260
ときに何が起こるか
我々は8になった？

227
00:09:57,260 --> 00:10:01,860

228
00:10:01,860 --> 00:10:04,880
>> 読者：あなたがする必要があるだろう
そのヌルポイントを得る。

229
00:10:04,880 --> 00:10:07,820
代わりに、あなたが持っているだろうヌル点を持っていることの
要素を追加してから持っている

230
00:10:07,820 --> 00:10:09,216
それは9を指す。

231
00:10:09,216 --> 00:10:09,700
>> JASON HIRSCHORN：その通りです。

232
00:10:09,700 --> 00:10:10,600
だから我々は8を得る。

233
00:10:10,600 --> 00:10:13,140
我々は、リストの最後に到達するため、
これはNULLを指している。

234
00:10:13,140 --> 00:10:16,330
そして今、代わりになるのが、を指す
ヌル我々はそれが私たちの新しいノードを指す必要があります。

235
00:10:16,330 --> 00:10:19,870
そして、我々は中にポインタを設定
nullに私たちの新しいノード。

236
00:10:19,870 --> 00:10:21,445
誰もが疑問を持っていますか
挿入はどうでしょうか？

237
00:10:21,445 --> 00:10:25,620

238
00:10:25,620 --> 00:10:28,100
私は気にしない場合はどう
ソートされたリストを保持する？

239
00:10:28,100 --> 00:10:31,701

240
00:10:31,701 --> 00:10:34,350
>> 観客：でそれをスティック
先頭または末尾。

241
00:10:34,350 --> 00:10:35,510
>> JASON HIRSCHORN：でそれをスティック
先頭または末尾。

242
00:10:35,510 --> 00:10:37,276
その1、我々は何をすべき？

243
00:10:37,276 --> 00:10:38,770
ボビー？

244
00:10:38,770 --> 00:10:41,020
なぜ終わり？

245
00:10:41,020 --> 00:10:43,250
>> 観客：ので、初め
すでに満たされている。

246
00:10:43,250 --> 00:10:43,575
>> JASON HIRSCHORN：わかりました。

247
00:10:43,575 --> 00:10:44,360
初めはすでに満たされている。

248
00:10:44,360 --> 00:10:46,090
誰がボビーに反論したいと考えています。

249
00:10:46,090 --> 00:10:47,290
マーカス。

250
00:10:47,290 --> 00:10:48,910
>> 観客：さてあなたはおそらくしたい
先頭に付いているので

251
00:10:48,910 --> 00:10:50,140
そうでなければあなたがでそれを置けば
あなたがする必要があるだろう終わり

252
00:10:50,140 --> 00:10:51,835
リスト全体を横断する。

253
00:10:51,835 --> 00:10:52,990
>> JASON HIRSCHORN：その通りです。

254
00:10:52,990 --> 00:10:57,970
だから我々は、ランタイムを考えている場合は、
最後に挿入するランタイム

255
00:10:57,970 --> 00:11:00,110
N、これのサイズになります。

256
00:11:00,110 --> 00:11:03,080
挿入するビッグOランタイムは何ですか
先頭の？

257
00:11:03,080 --> 00:11:04,170
一定の時間。

258
00:11:04,170 --> 00:11:07,075
だから、維持を気にしない場合は、
ただへより良いものにソート、

259
00:11:07,075 --> 00:11:08,420
このリストの先頭に挿入します。

260
00:11:08,420 --> 00:11:10,320
そして、それは一定の時間で行うことができます。

261
00:11:10,320 --> 00:11:13,900

262
00:11:13,900 --> 00:11:14,690
>> [OK]をクリックします。

263
00:11:14,690 --> 00:11:18,870
次の操作は、見つける他のどのです - 
我々は、検索としてこれを言葉で表現しました。

264
00:11:18,870 --> 00:11:22,470
しかし、我々は目を通すつもりだ
いくつかのオブジェクトのリンクリスト。

265
00:11:22,470 --> 00:11:26,000
君たちはのためのコードを見てきました
講義で前に検索します。

266
00:11:26,000 --> 00:11:29,490
しかし、我々は一種だけでそれをやった
挿入、または少なくとも挿入

267
00:11:29,490 --> 00:11:30,580
何か替え。

268
00:11:30,580 --> 00:11:36,350
あなたを介して見て、ノードがノードを行く、
あなたがしている番号を見つけるまで、

269
00:11:36,350 --> 00:11:37,780
探している。

270
00:11:37,780 --> 00:11:39,670
あなたが到達した場合はどうなりますか
リストの最後に？

271
00:11:39,670 --> 00:11:43,020
私は9と私を探していますと言う
リストの最後に到達する。

272
00:11:43,020 --> 00:11:44,270
私たちは何をしますか？

273
00:11:44,270 --> 00:11:47,147

274
00:11:47,147 --> 00:11:48,110
>> 観客：falseを返します？

275
00:11:48,110 --> 00:11:48,690
>> JASON HIRSCHORN：falseを返します。

276
00:11:48,690 --> 00:11:49,960
我々はそれを見つけることができませんでした。

277
00:11:49,960 --> 00:11:52,010
あなたがリストの最後に到達した場合
あなたがしている番号を見つけられませんでした

278
00:11:52,010 --> 00:11:54,170
を探している、それはそこにない。

279
00:11:54,170 --> 00:11:55,420
に関するご質問は見つける？

280
00:11:55,420 --> 00:11:59,530

281
00:11:59,530 --> 00:12:04,615
これはソートされたリストであった場合、どのようだろう
私たちの検索に異なること？

282
00:12:04,615 --> 00:12:07,370

283
00:12:07,370 --> 00:12:08,103
うん。

284
00:12:08,103 --> 00:12:10,600
>> 観客：それは最初の値を見つけるだろう
それは、2以上の

285
00:12:10,600 --> 00:12:12,390
あなたが探していると、
その後、falseを返します。

286
00:12:12,390 --> 00:12:13,190
>> JASON HIRSCHORN：その通りです。

287
00:12:13,190 --> 00:12:17,310
だから、我々が取得する場合には、ソートされたリストの場合は、
何よりも大きいの何か

288
00:12:17,310 --> 00:12:20,180
私たちが探している、我々はする必要はありません
リストの最後に続ける。

289
00:12:20,180 --> 00:12:24,060
私たちは、その時点でfalseを返すことができます
我々はそれを見つけるつもりはないので。

290
00:12:24,060 --> 00:12:27,340
質問は今、我々は話をしましたされている
並べ替えリンクリストを保持することは、

291
00:12:27,340 --> 00:12:28,180
ソートされていないそれらを維持。

292
00:12:28,180 --> 00:12:30,050
それはあなたがしているものになるだろう
おそらくについて考える必要があるとして

293
00:12:30,050 --> 00:12:34,240
コー​​ディング問題があれば5を設定したとき
別々にハッシュテーブルを選ぶ

294
00:12:34,240 --> 00:12:36,360
チェーン化のアプローチ、その
我々は、後で説明。

295
00:12:36,360 --> 00:12:41,400
>> しかし、それはリストを維持するために価値がある
ソートされ、多分持ってできるように

296
00:12:41,400 --> 00:12:42,310
より速く検索する？

297
00:12:42,310 --> 00:12:47,220
またはそれはすぐに挿入することをお勧めします
一定のランタイムで何かが、その後

298
00:12:47,220 --> 00:12:48,430
検索長く持っている？

299
00:12:48,430 --> 00:12:52,250
つまり、その権利があるトレードオフです
より適切であるかを決めるために取得

300
00:12:52,250 --> 00:12:53,590
特定の問題のために。

301
00:12:53,590 --> 00:12:56,680
そして1は必ずしもありません
絶対的に正しい答え。

302
00:12:56,680 --> 00:12:59,520
それは確かにあなたが得る決断だ
にするために、そしておそらく良い守るために

303
00:12:59,520 --> 00:13:05,270
その中で、たとえば、コメントや2理由
あなたは他の上1を選択しました。

304
00:13:05,270 --> 00:13:06,490
>> 最後に、削除。

305
00:13:06,490 --> 00:13:08,100
我々は、削除を見てきました。

306
00:13:08,100 --> 00:13:09,180
それは、検索に似ています。

307
00:13:09,180 --> 00:13:11,020
私たちは、要素を探します。

308
00:13:11,020 --> 00:13:12,390
我々は6を削除しようとしていると言う。

309
00:13:12,390 --> 00:13:14,450
だから我々はここ6を見つける。

310
00:13:14,450 --> 00:13:18,860
私たちは必ず私たちをしなければならない事
何何をを指しているということです

311
00:13:18,860 --> 00:13:21,220
6  - 私たちはステップで見るように
ダウンここに2  - 

312
00:13:21,220 --> 00:13:26,500
6つのニーズを指しているのはどのような
今6をスキップして、に変更する

313
00:13:26,500 --> 00:13:28,160
何でも6は、を指している。

314
00:13:28,160 --> 00:13:31,410
私たちは、これまでの残りの部分を孤立させたくない
それを設定し忘れることで私たちのリスト

315
00:13:31,410 --> 00:13:32,960
前のポインタ。

316
00:13:32,960 --> 00:13:35,960
して、時々、依存
プログラムでは、彼らはちょうどよ

317
00:13:35,960 --> 00:13:37,380
完全にこのノードを削除してください。

318
00:13:37,380 --> 00:13:40,135
時には、あなたが戻ってしたいと思う
このノードでの値。

319
00:13:40,135 --> 00:13:42,490
だから、作品を削除する方法を説明します。

320
00:13:42,490 --> 00:13:44,610
上の任意の質問は削除しますか？

321
00:13:44,610 --> 00:13:51,280

322
00:13:51,280 --> 00:13:53,850
>> 観客：だから、削除しようとしている場合は、
それは、あなただけの自由な使用になるため

323
00:13:53,850 --> 00:13:55,655
おそらくそれはmallocされたのですか？

324
00:13:55,655 --> 00:13:57,976
>> JASON HIRSCHORN：あなたは無料にする場合
まったく正しいとあなたです、何か

325
00:13:57,976 --> 00:13:58,540
それをmallocさ。

326
00:13:58,540 --> 00:14:00,410
我々は、この値を返すように思ったと言う。

327
00:14:00,410 --> 00:14:04,010
我々は、返される可能性があります6、その後自由
このノードとその上に自由に連絡してください。

328
00:14:04,010 --> 00:14:06,180
または我々は、おそらく最初のフリー呼びたい
して、6を返します。

329
00:14:06,180 --> 00:14:11,210

330
00:14:11,210 --> 00:14:11,580
>> [OK]をクリックします。

331
00:14:11,580 --> 00:14:14,010
それでは、コーディングの練習に移りましょう。

332
00:14:14,010 --> 00:14:16,090
我々は3つの機能をコーディングするつもりだ。

333
00:14:16,090 --> 00:14:18,260
最初の1はinsert_nodeと呼ばれています。

334
00:14:18,260 --> 00:14:22,170
だから、私はあなたを電子メールで送信するコードがあると、
後で、これを見ている場合

335
00:14:22,170 --> 00:14:28,020
あなたはlinked.cにコードにアクセスすることができます
CS50のウェブサイトで。

336
00:14:28,020 --> 00:14:30,880
しかしlinked.cに、いくつかあります
既にのスケルトンコード

337
00:14:30,880 --> 00:14:32,280
あなたのために書かれて。

338
00:14:32,280 --> 00:14:34,560
して、カップルの関数があります
あなたが記述する必要があります。

339
00:14:34,560 --> 00:14:36,380
>> まず、するつもりだ
insert_nodeを記述します。

340
00:14:36,380 --> 00:14:39,800
そして、何insert_nodeん
整数値を挿入する。

341
00:14:39,800 --> 00:14:42,440
そして、あなたは整数を与えている
リンクされたリストに変換する。

342
00:14:42,440 --> 00:14:45,470
特に、次のものが必要
ソートされたリストを維持する

343
00:14:45,470 --> 00:14:47,650
最小から最大まで。

344
00:14:47,650 --> 00:14:51,360
また、あなたはしたくない
任意の重複を挿入します。

345
00:14:51,360 --> 00:14:54,600
最後に、insert_nodeを見ることができるように
BOOLを返します。

346
00:14:54,600 --> 00:14:57,140
だから、ユーザーが知っているようになっている
インサートがあったか否か

347
00:14:57,140 --> 00:15:00,800
trueまたはfalseを返すことにより、成功した。

348
00:15:00,800 --> 00:15:02,580
このプログラムの終わりに - 

349
00:15:02,580 --> 00:15:05,750
この段階のためにあなたがする必要はありません
何を解放することを心配する。

350
00:15:05,750 --> 00:15:11,790
あなたがやっているすべては、整数を取っている
そして、リストに挿入する。

351
00:15:11,790 --> 00:15:13,890
>> それは私が今することを求めているものです。

352
00:15:13,890 --> 00:15:17,620
もう一度、linked.cにおいて、その必要
ならないすべては、スケルトンコードです。

353
00:15:17,620 --> 00:15:20,980
そして、あなたは一番下の方に表示されるはずです
サンプル関数の宣言。

354
00:15:20,980 --> 00:15:27,390
しかし、それをコーディングに入る前に
C言語で、私は非常に行くことをお勧めします

355
00:15:27,390 --> 00:15:29,330
の工程を経て、我々はしてきた
毎週練習。

356
00:15:29,330 --> 00:15:31,100
我々はすでにを通じて行ってきた
これの絵。

357
00:15:31,100 --> 00:15:33,380
だから、いくつか理解している必要があります
これがどのように動作するかの。

358
00:15:33,380 --> 00:15:36,590
しかし、私は書くことをお勧めだろう
インチダイビング前にいくつかの擬似コード

359
00:15:36,590 --> 00:15:38,640
そして、我々は以上行くつもり
グループとしての擬似コード。

360
00:15:38,640 --> 00:15:41,470
それから、あなたが書いた回は
擬似コード、そして我々は我々を書いたら

361
00:15:41,470 --> 00:15:45,850
グループとしての擬似コードは、次の操作を実行でき
C言語でそれをコーディングに入る

362
00:15:45,850 --> 00:15:49,980
>> ヘッドアップ、insert_node関数として
おそらくのトリッキーです

363
00:15:49,980 --> 00:15:53,550
3我々は書くつもりですので、私
にいくつかの追加の制約を追加しました

364
00:15:53,550 --> 00:15:57,190
特に、プログラミング、その
あなたがいずれかを挿入するつもりはない

365
00:15:57,190 --> 00:15:59,880
重複して、そのリスト
ソートされたままにしてください。

366
00:15:59,880 --> 00:16:02,660
だから、これは些細なプログラムであり、
あなたがコードする必要がある。

367
00:16:02,660 --> 00:16:06,470
そして、なぜあなたは7に5を取ることはありません
分だけで動作させるために

368
00:16:06,470 --> 00:16:07,640
擬似コードとコード。

369
00:16:07,640 --> 00:16:09,460
そして、我々が開始されます
グループとして行く。

370
00:16:09,460 --> 00:16:11,680
もう一度、あなただけの質問がある場合
手を挙げて、私は周りに来る。

371
00:16:11,680 --> 00:16:15,258

372
00:16:15,258 --> 00:16:16,508
。

373
00:16:16,508 --> 00:18:28,370

374
00:18:28,370 --> 00:18:30,120
>> 我々はまた、一般的に、これらを行う - 

375
00:18:30,120 --> 00:18:32,070
または私は明示的に言うことはありません
人々と働くことができる。

376
00:18:32,070 --> 00:18:36,500
しかし、明らかに、私は非常になることをお勧めします、
ご質問がある場合には、依頼する

377
00:18:36,500 --> 00:18:39,840
隣人があなたの隣に座って
あるいは誰かと仕事

378
00:18:39,840 --> 00:18:40,510
他にあなたがしたい場合。

379
00:18:40,510 --> 00:18:42,600
これは、個々である必要はありません
サイレント活動。

380
00:18:42,600 --> 00:20:11,770

381
00:20:11,770 --> 00:20:16,330
>> それでは、いくつかを書き始めましょう
ボード上の擬似コード。

382
00:20:16,330 --> 00:20:19,395
誰が私の最初の行を与えることができます
このプログラムの擬似コード？

383
00:20:19,395 --> 00:20:22,240

384
00:20:22,240 --> 00:20:23,640
この機能のために、むしろ - 
insert_node。

385
00:20:23,640 --> 00:20:29,960

386
00:20:29,960 --> 00:20:31,830
オールデン？

387
00:20:31,830 --> 00:20:36,560
>> 観客：だから私がした最初のものだった
ノードに新しいポインタを作成し、私

388
00:20:36,560 --> 00:20:41,320
それは、同じを指す初期化
リストが指しているもの。

389
00:20:41,320 --> 00:20:41,550
>> JASON HIRSCHORN：わかりました。

390
00:20:41,550 --> 00:20:45,190
だから、新しいポインタを作成している
リストにはなく、ノードに。

391
00:20:45,190 --> 00:20:45,420
>> 観客：そうです。

392
00:20:45,420 --> 00:20:46,150
うん。

393
00:20:46,150 --> 00:20:46,540
>> JASON HIRSCHORN：わかりました。

394
00:20:46,540 --> 00:20:48,221
した後、私たちは何をしたいのですか？

395
00:20:48,221 --> 00:20:49,163
その後何ですか？

396
00:20:49,163 --> 00:20:50,105
どのようなノードはどうでしょうか？

397
00:20:50,105 --> 00:20:51,050
私たちは、ノードを持っていません。

398
00:20:51,050 --> 00:20:52,300
我々だけで価値がある。

399
00:20:52,300 --> 00:20:55,918

400
00:20:55,918 --> 00:20:58,890
我々はノードを挿入したい場合は、何を行っており
私たちも、できる前に最初に行う必要があります

401
00:20:58,890 --> 00:20:59,980
それを挿入する方法はないでしょうか？

402
00:20:59,980 --> 00:21:00,820
>> 観客：ああ、申し訳ありません。

403
00:21:00,820 --> 00:21:02,160
我々は、ノードのためのスペースをのmallocする必要があります。

404
00:21:02,160 --> 00:21:02,455
>> JASON HIRSCHORN：優秀。

405
00:21:02,455 --> 00:21:03,210
それではやってみましょう - 

406
00:21:03,210 --> 00:21:04,628
[OK]をクリックします。

407
00:21:04,628 --> 00:21:06,065
その高に到達することはできません。

408
00:21:06,065 --> 00:21:08,939

409
00:21:08,939 --> 00:21:09,897
[OK]をクリックします。

410
00:21:09,897 --> 00:21:13,236
私たちはダウン行くつもりしてから、している
我々は2つ​​の列を使用している。

411
00:21:13,236 --> 00:21:13,732
私はそれを行くことができない - 

412
00:21:13,732 --> 00:21:14,982
[OK]をクリックします。

413
00:21:14,982 --> 00:21:23,660

414
00:21:23,660 --> 00:21:25,130
新しいノードを作成します。

415
00:21:25,130 --> 00:21:29,380
リストには、別のポインタを作成することができます
それが存在するか、あなただけのリストを使用することができます。

416
00:21:29,380 --> 00:21:30,720
あなたは本当にそれをする必要はありません。

417
00:21:30,720 --> 00:21:31,750
>> だから我々は、新しいノードを作成します。

418
00:21:31,750 --> 00:21:32,010
素晴らしい。

419
00:21:32,010 --> 00:21:32,840
それは我々が最初に何をすべきかだ。

420
00:21:32,840 --> 00:21:34,870
次は何ですか？

421
00:21:34,870 --> 00:21:35,080
>> 観客：待ってください。

422
00:21:35,080 --> 00:21:38,330
我々は今、新しいノードを作成する必要がありますか
我々はそれを確認するために待機しなければならない

423
00:21:38,330 --> 00:21:42,260
ノードのない重複はありません
リスト上の我々はそれを作成する前に？

424
00:21:42,260 --> 00:21:43,100
>> JASON HIRSCHORN：良い質問。

425
00:21:43,100 --> 00:21:47,770
ので、後でそれを保持してみましょう
我々は作成されます時間の大半

426
00:21:47,770 --> 00:21:48,220
新しいノード。

427
00:21:48,220 --> 00:21:49,110
だから我々は、ここでそれをしておこう。

428
00:21:49,110 --> 00:21:51,006
しかし、それは良い質問です。

429
00:21:51,006 --> 00:21:53,250
我々はそれを作成し、我々は見つけた場合
何をすべき重複し、

430
00:21:53,250 --> 00:21:54,490
私たちは、返す前にいますか？

431
00:21:54,490 --> 00:21:55,190
>> 観客：それを解放。

432
00:21:55,190 --> 00:21:55,470
>> JASON HIRSCHORN：うん。

433
00:21:55,470 --> 00:21:56,500
おそらくそれを解放します。

434
00:21:56,500 --> 00:21:56,760
[OK]をクリックします。

435
00:21:56,760 --> 00:21:59,850
我々は、我々の後に何をしますか
新しいノードを作成しますか？

436
00:21:59,850 --> 00:22:02,260
アニー？

437
00:22:02,260 --> 00:22:04,780
>> 観客：我々は置く
ノード内の数字？

438
00:22:04,780 --> 00:22:05,140
>> JASON HIRSCHORN：その通りです。

439
00:22:05,140 --> 00:22:07,190
我々は数を入れて - 私たちはスペースをのmalloc。

440
00:22:07,190 --> 00:22:08,160
私はそれを残すつもりだ
すべて1行として。

441
00:22:08,160 --> 00:22:08,720
しかし、あなたは正しい。

442
00:22:08,720 --> 00:22:10,305
それから、スペースををmallocし、
私たちは、インチ数を入れて

443
00:22:10,305 --> 00:22:12,585
私たちも、ポインタを設定することができます
nullにその一部。

444
00:22:12,585 --> 00:22:13,720
それはまさにそうです。

445
00:22:13,720 --> 00:22:17,400
した後、どのようなことをした後はどうでしょうか？

446
00:22:17,400 --> 00:22:18,490
我々は、ボード上でこの絵を描きました。

447
00:22:18,490 --> 00:22:21,190
だから我々は何をしますか？

448
00:22:21,190 --> 00:22:22,680
>> 読者：私たちは、リストを通過します。

449
00:22:22,680 --> 00:22:23,930
>> JASON HIRSCHORN：リストを通過します。

450
00:22:23,930 --> 00:22:30,620

451
00:22:30,620 --> 00:22:31,100
[OK]をクリックします。

452
00:22:31,100 --> 00:22:34,280
そして、我々は、各ノードでのために何をチェックしますか。

453
00:22:34,280 --> 00:22:35,955
クルト、私たちは何をチェックしますか
各ノードでのために？

454
00:22:35,955 --> 00:22:41,640
>> 読者：のN値かどうかを参照してください
そのノードはnの値よりも大きい

455
00:22:41,640 --> 00:22:43,070
私たちのノードの。

456
00:22:43,070 --> 00:22:43,340
>> JASON HIRSCHORN：わかりました。

457
00:22:43,340 --> 00:22:44,280
私は何をするつもりだ - 

458
00:22:44,280 --> 00:22:45,855
[OK]を、ええ。

459
00:22:45,855 --> 00:22:48,160
だから、Nさん - 

460
00:22:48,160 --> 00:22:59,040
値が大きい場合は私が言おうとしています
このノードよりも、我々は何をしますか？

461
00:22:59,040 --> 00:23:07,290
>> 観客：さて、私たちは、挿入
右その前の事。

462
00:23:07,290 --> 00:23:07,970
>> JASON HIRSCHORN：わかりました。

463
00:23:07,970 --> 00:23:09,410
だから、これより大きいなら、
その後、我々は挿入する。

464
00:23:09,410 --> 00:23:14,010
しかし、我々は右の前にそれを挿入したい
我々はまた、である必要があるので、

465
00:23:14,010 --> 00:23:16,070
追跡し、次いで、
前だったかの。

466
00:23:16,070 --> 00:23:22,690
そうする前に挿入します。

467
00:23:22,690 --> 00:23:25,120
だから我々は、おそらく何かを逃した
それ以前に。

468
00:23:25,120 --> 00:23:27,770
我々は、おそらく維持される必要がある
何が起こっているかを追跡。

469
00:23:27,770 --> 00:23:28,460
しかし、我々はそこに戻って得られます。

470
00:23:28,460 --> 00:23:30,160
それがどうした値よりも小さい？

471
00:23:30,160 --> 00:23:38,030

472
00:23:38,030 --> 00:23:39,710
クルト、私たちは、次の場合に何をしますか
値がより小さい？

473
00:23:39,710 --> 00:23:43,000
>> 観客：それからちょうど続ける
それは、最後の1でない限り。

474
00:23:43,000 --> 00:23:43,550
>> JASON HIRSCHORN：私はそれが好きです。

475
00:23:43,550 --> 00:23:44,800
だから、次のノードに移動します。

476
00:23:44,800 --> 00:23:47,410

477
00:23:47,410 --> 00:23:48,930
それは、最後の1でない限り - 

478
00:23:48,930 --> 00:23:51,100
我々は、おそらくそのためにチェックしている
条件の面で。

479
00:23:51,100 --> 00:23:54,870
しかし、ええ、次のノード。

480
00:23:54,870 --> 00:23:58,680
そして、それは、低すぎるなってきた
私たちはこっちに移動します。

481
00:23:58,680 --> 00:24:02,030
しかし、もし - 

482
00:24:02,030 --> 00:24:03,280
誰もがこれを見ることができますか？

483
00:24:03,280 --> 00:24:07,230

484
00:24:07,230 --> 00:24:11,610
我々は等しいなら、私たちは何をしますか？

485
00:24:11,610 --> 00:24:15,740
値は、私たちは、挿入しようとしている場合
このノードの値に等しいか？

486
00:24:15,740 --> 00:24:16,320
うん？

487
00:24:16,320 --> 00:24:18,400
>> 観客：[聞こえない]。

488
00:24:18,400 --> 00:24:18,850
>> JASON HIRSCHORN：うん。

489
00:24:18,850 --> 00:24:19,290
この与えられた - 

490
00:24:19,290 --> 00:24:20,090
マーカスは正しい。

491
00:24:20,090 --> 00:24:21,330
私たちは、多分行っている可能性が
何か違う。

492
00:24:21,330 --> 00:24:25,360
しかし、ここで、我々はそれを作成したことを考えると
我々は自由として返す必要があります。

493
00:24:25,360 --> 00:24:26,774
ああ。

494
00:24:26,774 --> 00:24:30,080
それが良いですか？

495
00:24:30,080 --> 00:24:31,850
どのようにそれはです？

496
00:24:31,850 --> 00:24:33,100
[OK]をクリックします。

497
00:24:33,100 --> 00:24:35,360

498
00:24:35,360 --> 00:24:37,640
我々は何をすべきか、空きと
リターン、[聞こえない]？

499
00:24:37,640 --> 00:24:41,330

500
00:24:41,330 --> 00:24:44,110
[OK]をクリックします。

501
00:24:44,110 --> 00:24:45,360
我々は何が不足している？

502
00:24:45,360 --> 00:24:53,500

503
00:24:53,500 --> 00:24:59,650
だからここで我々は追跡している
前ノードの？

504
00:24:59,650 --> 00:25:02,370
>> 読者：私はそれが行くと思う
後に新しいノードを作成します。

505
00:25:02,370 --> 00:25:02,600
>> JASON HIRSCHORN：わかりました。

506
00:25:02,600 --> 00:25:03,940
だから、初めに我々は、おそらくよ - 

507
00:25:03,940 --> 00:25:07,175
ええ、私たちは新しい体へのポインタを作成することができます
前のノードポインタのようなノード、および

508
00:25:07,175 --> 00:25:09,600
現在のノードのポインタ。

509
00:25:09,600 --> 00:25:12,640
それでは、ここでそれを挿入してみましょう。

510
00:25:12,640 --> 00:25:15,610

511
00:25:15,610 --> 00:25:26,900
現在および以前の作成
ノードへのポインタ。

512
00:25:26,900 --> 00:25:28,955
しかし、ときに我々はこれらのポインタを調整しますか？

513
00:25:28,955 --> 00:25:30,205
我々は、コード内でそれをどこで行うのですか？

514
00:25:30,205 --> 00:25:33,830

515
00:25:33,830 --> 00:25:34,160
ジェフ？

516
00:25:34,160 --> 00:25:35,170
>> 読者： - 値の条件？

517
00:25:35,170 --> 00:25:36,420
>> JASON HIRSCHORN：どの
特に1？

518
00:25:36,420 --> 00:25:39,862

519
00:25:39,862 --> 00:25:40,720
>> 読者：私は困惑している。

520
00:25:40,720 --> 00:25:44,200
値は、このノードよりも大きい場合
つまり、どこに行きたいということではありません

521
00:25:44,200 --> 00:25:45,320
次のノードに？

522
00:25:45,320 --> 00:25:49,515
>> JASONハーシュホーン：だから私たちの値である場合
このノードの値よりも大きい。

523
00:25:49,515 --> 00:25:52,130
>> 観客：うん、あなたがしたいと思う
右、ラインのさらに下に行く？

524
00:25:52,130 --> 00:25:52,590
>> JASONハーシュホーン：右。

525
00:25:52,590 --> 00:25:53,840
だから我々はそれをここに挿入しないでください。

526
00:25:53,840 --> 00:25:58,430

527
00:25:58,430 --> 00:26:03,240
値は、このノードよりも小さい場合、
我々は次のノードに移動する - あるいは、私たち

528
00:26:03,240 --> 00:26:03,835
前に挿入します。

529
00:26:03,835 --> 00:26:05,966
>> 観客：これはこれであり、待ってください
ノードとの値はありますか？

530
00:26:05,966 --> 00:26:08,510

531
00:26:08,510 --> 00:26:09,280
>> JASONハーシュホーン：良い質問。

532
00:26:09,280 --> 00:26:13,260
この関数の定義あたりの値
我々は与えられているものである。

533
00:26:13,260 --> 00:26:16,910
だから、値は我々が与えられている番号です。

534
00:26:16,910 --> 00:26:21,120
そう値がこれより小さい場合
ノードは、我々は挿入する時間が必要です。

535
00:26:21,120 --> 00:26:24,575
値は、このノードよりも大きい場合
我々は次のノードに移動します。

536
00:26:24,575 --> 00:26:26,790
そして、元の質問に、
しかし、どこに - 

537
00:26:26,790 --> 00:26:29,060
>> 観客：値が大きい場合
このノードより。

538
00:26:29,060 --> 00:26:30,310
>> JASONハーシュホーン：だから
我々はここで何をしますか？

539
00:26:30,310 --> 00:26:36,790

540
00:26:36,790 --> 00:26:38,160
甘い。

541
00:26:38,160 --> 00:26:38,860
それは正しいです。

542
00:26:38,860 --> 00:26:41,370
私は書くつもりだ
更新ポインタ。

543
00:26:41,370 --> 00:26:44,010
しかし、はい、現在の1に
あなたはそれを更新してしまう

544
00:26:44,010 --> 00:26:46,080
次の1を指す。

545
00:26:46,080 --> 00:26:47,330
我々は他の何欠落している？

546
00:26:47,330 --> 00:26:52,710

547
00:26:52,710 --> 00:26:54,940
だから私は、これを入力するつもりです
geditのにコード。

548
00:26:54,940 --> 00:26:58,375
私はこれを行うながら、あなたが持つことができます
コー​​ディングで動作するようにカップル分以上

549
00:26:58,375 --> 00:28:19,240
このCの

550
00:28:19,240 --> 00:28:20,940
>> だから私は、入力の擬似コードを持っている。

551
00:28:20,940 --> 00:28:22,940
私たちは始める前に、簡単なメモ。

552
00:28:22,940 --> 00:28:25,560
我々は完全にできないことがあります
すべてでこれを終える

553
00:28:25,560 --> 00:28:27,300
これらの機能の3。

554
00:28:27,300 --> 00:28:30,630
それらへの正しい解決策があります
私はあなたたちに出てメールでお知らせいたしますことを

555
00:28:30,630 --> 00:28:33,730
セクションの後、それは意志
CS50.netに掲載される。

556
00:28:33,730 --> 00:28:35,640
だから私はすることをお勧めしません。
のセクションを見に行く。

557
00:28:35,640 --> 00:28:40,550
私はあなたにこれらを試してみることをお勧めします
所有してから練習を使用

558
00:28:40,550 --> 00:28:41,760
あなたの答えをチェックする問題。

559
00:28:41,760 --> 00:28:47,070
これらはすべて密接に設計されています
に関連し、どのように付着

560
00:28:47,070 --> 00:28:48,400
あなたは、問題のセットで行う必要があります。

561
00:28:48,400 --> 00:28:53,820
だから私は、これを実践することをお勧めします
自分で、その後にコードを使用し

562
00:28:53,820 --> 00:28:54,660
あなたの答えをチェックしてください。

563
00:28:54,660 --> 00:28:57,060
私はハッシュへ移動したいないので、
節のある時点でのテーブル。

564
00:28:57,060 --> 00:28:58,150
だから我々はそれをすべてを介して取得されない場合があります。

565
00:28:58,150 --> 00:28:59,960
しかし、我々は今我々はできる限りやる。

566
00:28:59,960 --> 00:29:00,370
>> [OK]をクリックします。

567
00:29:00,370 --> 00:29:01,960
私たちは始めましょう。

568
00:29:01,960 --> 00:29:04,770
ASAM、どのように我々は、新しいノードを作成するのですか？

569
00:29:04,770 --> 00:29:06,810
>> 読者：あなたは*構造です。

570
00:29:06,810 --> 00:29:09,640
>> JASONハーシュホーン：だから我々
ここでそれをアップする必要があります。

571
00:29:09,640 --> 00:29:10,040
あ、ごめん。

572
00:29:10,040 --> 00:29:13,530
あなたは、構造体*を言っていた。

573
00:29:13,530 --> 00:29:17,260
>> 観客：そして、[？種類は？]
ノードまたはCノード。

574
00:29:17,260 --> 00:29:17,780
>> JASONハーシュホーン：わかりました。

575
00:29:17,780 --> 00:29:19,740
私はそれを呼び出すつもりで、new_node
私たちは一貫して滞在することができます。

576
00:29:19,740 --> 00:29:22,646

577
00:29:22,646 --> 00:29:33,180
>> 観客：そして、あなたはそれを設定したい
、最初のノードを頭に。

578
00:29:33,180 --> 00:29:33,580
>> JASONハーシュホーン：わかりました。

579
00:29:33,580 --> 00:29:37,290
だから今、このポインティング - ので、この
まだ新しいノードを作成していません。

580
00:29:37,290 --> 00:29:41,380
これはちょうどを指している
リスト内の最初のノード。

581
00:29:41,380 --> 00:29:42,630
どのように新しいノードを作成するのですか？

582
00:29:42,630 --> 00:29:45,490

583
00:29:45,490 --> 00:29:48,070
私は、新しいノードを作成するためのスペースが必要な場合。

584
00:29:48,070 --> 00:29:49,230
malloc関数。

585
00:29:49,230 --> 00:29:51,710
そして、どのようにビッグ？

586
00:29:51,710 --> 00:30:00,390
>> 観客：構造体のサイズ。

587
00:30:00,390 --> 00:30:01,150
>> JASONハーシュホーン：
構造体のサイズ。

588
00:30:01,150 --> 00:30:02,400
と構造体は何と呼ばれるのか？

589
00:30:02,400 --> 00:30:09,670

590
00:30:09,670 --> 00:30:09,840
>> 観客：ノード？

591
00:30:09,840 --> 00:30:11,640
>> JASONハーシュホーン：ノード。

592
00:30:11,640 --> 00:30:17,640
そうはmalloc（sizeof演算（ノード））;
私たちにスペースを提供します。

593
00:30:17,640 --> 00:30:19,740
この行は - 

594
00:30:19,740 --> 00:30:21,740
一つのことは、この行が正しくありません。

595
00:30:21,740 --> 00:30:24,430
構造体へのポインタで、new_nodeですか？

596
00:30:24,430 --> 00:30:25,650
これは一般的な名前です。

597
00:30:25,650 --> 00:30:26,520
それは何ですか - 

598
00:30:26,520 --> 00:30:27,450
ノード、正確に。

599
00:30:27,450 --> 00:30:29,340
これは、*ノードの。

600
00:30:29,340 --> 00:30:33,010
そして、我々は右の後に何をしますか
我々は牙山何かをは、malloc？

601
00:30:33,010 --> 00:30:34,476
私たちが最初に行うことは何ですか？

602
00:30:34,476 --> 00:30:38,850

603
00:30:38,850 --> 00:30:40,320
それは何が動作しない場合は？

604
00:30:40,320 --> 00:30:42,430
>> 観客：ああ、確認した場合、それ
ノードを指す？

605
00:30:42,430 --> 00:30:43,310
>> JASONハーシュホーン：その通りです。

606
00:30:43,310 --> 00:30:46,750
ですから、ここで、new_node場合、equalsに等しい
ヌル、私たちは何をしますか？

607
00:30:46,750 --> 00:30:51,650

608
00:30:51,650 --> 00:30:54,820
これはBOOL、この関数を返します。

609
00:30:54,820 --> 00:30:57,760
その通りです。

610
00:30:57,760 --> 00:30:58,450
よさそうだ。

611
00:30:58,450 --> 00:30:59,680
そこに追加するものは？

612
00:30:59,680 --> 00:31:00,670
我々は最後にものを追加します。

613
00:31:00,670 --> 00:31:03,160
しかし、それは今のところよさそうだ。

614
00:31:03,160 --> 00:31:06,170
現在と以前のポインタを作成します。

615
00:31:06,170 --> 00:31:08,650
マイケルは、私はこれをどのように行うのですか？

616
00:31:08,650 --> 00:31:12,810
>> 読者：あなたが持っているだろう
ノードを行うには*。

617
00:31:12,810 --> 00:31:21,800

618
00:31:21,800 --> 00:31:25,502
あなたは1をしないように必要があるだろう
ここで、new_nodeのためではなくのために

619
00:31:25,502 --> 00:31:26,905
我々はすでに持っているノード。

620
00:31:26,905 --> 00:31:27,230
>> JASONハーシュホーン：わかりました。

621
00:31:27,230 --> 00:31:29,255
だから、現在のノードが、我々はにしている。

622
00:31:29,255 --> 00:31:30,505
私はゴロゴロと呼ぶことにします。

623
00:31:30,505 --> 00:31:39,650

624
00:31:39,650 --> 00:31:39,770
わかりました。

625
00:31:39,770 --> 00:31:41,620
我々は維持したいことを決定した
2、我々は知っている必要がありますので、

626
00:31:41,620 --> 00:31:42,870
その前に何が。

627
00:31:42,870 --> 00:31:45,770

628
00:31:45,770 --> 00:31:47,020
彼らは何に初期化されますか？

629
00:31:47,020 --> 00:31:49,874

630
00:31:49,874 --> 00:31:54,180
>> 読者：私たちのリスト内の値。

631
00:31:54,180 --> 00:31:58,090
>> JASONハーシュホーン：だから何です
私たちのリスト上の最初の事？

632
00:31:58,090 --> 00:32:04,050
またはどのように我々は知っている場所
私たちのリストの先頭にはある？

633
00:32:04,050 --> 00:32:08,015
>> 観客：それは渡されません
関数に？

634
00:32:08,015 --> 00:32:08,466
>> JASONハーシュホーン：右。

635
00:32:08,466 --> 00:32:09,716
それは、まさにここに可決された。

636
00:32:09,716 --> 00:32:15,910

637
00:32:15,910 --> 00:32:18,980
だから、それが関数に渡されたなら、
リストの先頭、我々は何をすべき

638
00:32:18,980 --> 00:32:21,270
に等しい電流を設定します？

639
00:32:21,270 --> 00:32:22,110
>> 観客：リスト。

640
00:32:22,110 --> 00:32:22,900
>> JASONハーシュホーン：リスト。

641
00:32:22,900 --> 00:32:24,090
それはまさにそうです。

642
00:32:24,090 --> 00:32:26,290
今ではのアドレスを持っている
私たちのリストの先頭。

643
00:32:26,290 --> 00:32:28,450
そして、何前のはどうでしょうか？

644
00:32:28,450 --> 00:32:31,920
>> 観客：リストから1を引いた？

645
00:32:31,920 --> 00:32:32,690
>> JASONハーシュホーン：あります
その前に何もない。

646
00:32:32,690 --> 00:32:34,580
だから我々は何も意味しないために何ができますか？

647
00:32:34,580 --> 00:32:35,050
>> 観客：ヌル。

648
00:32:35,050 --> 00:32:35,450
>> JASONハーシュホーン：うん。

649
00:32:35,450 --> 00:32:37,950
それは良いアイデアのように聞こえる。

650
00:32:37,950 --> 00:32:38,360
完璧。

651
00:32:38,360 --> 00:32:39,630
ありがとう。

652
00:32:39,630 --> 00:32:42,850
リストを通過します。

653
00:32:42,850 --> 00:32:45,490
どのくらい私たちがしようとしているコンスタンティン、
リストを行く？

654
00:32:45,490 --> 00:32:49,010
>> 観客：我々は、NULLに達するまで。

655
00:32:49,010 --> 00:32:49,390
>> JASONハーシュホーン：わかりました。

656
00:32:49,390 --> 00:32:50,430
forループ、しばらく、もしそうであれば。

657
00:32:50,430 --> 00:32:52,200
私たちは何してるの？

658
00:32:52,200 --> 00:32:53,320
>> 観客：たぶん、forループ？

659
00:32:53,320 --> 00:32:53,910
>> JASONハーシュホーン：のループのためにやってみましょう。

660
00:32:53,910 --> 00:32:55,870
[OK]をクリックします。

661
00:32:55,870 --> 00:33:02,465
>> 観客：そして、我々はのために言う - 

662
00:33:02,465 --> 00:33:09,764

663
00:33:09,764 --> 00:33:13,390
現在のポインタになるまで
NULLと同じではありません。

664
00:33:13,390 --> 00:33:19,160
>> JASONハーシュホーン：だから我々は知っている場合
条件、どのように我々は、ループを書くことができます

665
00:33:19,160 --> 00:33:21,740
その状態オフに基づいて。

666
00:33:21,740 --> 00:33:24,380
我々は、ループのどのような種類を使用すればよいですか？

667
00:33:24,380 --> 00:33:25,260
>> 観客：ながら。

668
00:33:25,260 --> 00:33:25,590
>> JASONハーシュホーン：うん。

669
00:33:25,590 --> 00:33:27,130
つまり、ベースより理にかなって
あなたが言ったことのオフ。

670
00:33:27,130 --> 00:33:29,430
私たちはちょうど私達に行きたい場合は、だろう
ちょうどその事を知っている、それはなるだろう

671
00:33:29,430 --> 00:33:31,680
whileループを実行する感覚。

672
00:33:31,680 --> 00:33:39,880
電流が等しくないNULLをする間、
値は、このノード未満である場合。

673
00:33:39,880 --> 00:33:41,650
Aksharは、私にこのラインを与える。

674
00:33:41,650 --> 00:33:48,810

675
00:33:48,810 --> 00:33:56,955
>> 観客：電流If-> N
N値よりも小さい。

676
00:33:56,955 --> 00:34:00,170

677
00:34:00,170 --> 00:34:03,260
またはその逆を行います。

678
00:34:03,260 --> 00:34:06,140
そのブラケットを切り替えます。

679
00:34:06,140 --> 00:34:06,620
>> JASONハーシュホーン：申し訳ありません。

680
00:34:06,620 --> 00:34:08,760
>> 観客：ブラケットを変更します。

681
00:34:08,760 --> 00:34:10,914
>> JASONハーシュホーン：だからそれはだ場合には
値より大きい。

682
00:34:10,914 --> 00:34:18,719

683
00:34:18,719 --> 00:34:22,120
それはと混同だから
上記のコメントは、私はそれをするつもりです。

684
00:34:22,120 --> 00:34:22,480
しかし、はい。

685
00:34:22,480 --> 00:34:25,125
我々は、この値よりも小さい場合
ノード、我々は何をしますか？

686
00:34:25,125 --> 00:34:25,540
ああ。

687
00:34:25,540 --> 00:34:26,710
私は右のそれをここに持っている。

688
00:34:26,710 --> 00:34:27,960
前に挿入します。

689
00:34:27,960 --> 00:34:32,080

690
00:34:32,080 --> 00:34:32,370
[OK]をクリックします。

691
00:34:32,370 --> 00:34:33,933
我々はそれをどのように行うのですか？

692
00:34:33,933 --> 00:34:34,900
>> 観客は：それはまだ私ですか？

693
00:34:34,900 --> 00:34:36,150
>> JASONハーシュホーン：うん。

694
00:34:36,150 --> 00:34:38,520

695
00:34:38,520 --> 00:34:39,770
>> 読者：あなた - 

696
00:34:39,770 --> 00:34:42,909

697
00:34:42,909 --> 00:34:44,159
ここで、new_node->次。

698
00:34:44,159 --> 00:34:46,770

699
00:34:46,770 --> 00:34:50,163
>> JASONハーシュホーン：だから何だ
それが等しくなるように行きますか？

700
00:34:50,163 --> 00:34:52,070
>> 観客：これは、等しい電流になるだろう。

701
00:34:52,070 --> 00:34:53,889
>> JASONハーシュホーン：その通りです。

702
00:34:53,889 --> 00:34:55,730
だから他の - 

703
00:34:55,730 --> 00:34:56,730
我々は更新するために他に何が必要なのですか？

704
00:34:56,730 --> 00:34:59,982
>> 観客：過去がnullに等しいかどうかを確認します。

705
00:34:59,982 --> 00:35:01,870
>> JASONハーシュホーン：前の場合 - 

706
00:35:01,870 --> 00:35:03,730
その前がnullに等しい場合。

707
00:35:03,730 --> 00:35:05,990
>> 観客：それは起こっていることを意味
頭になるために。

708
00:35:05,990 --> 00:35:06,780
>> JASONハーシュホーン：その手段
それが頭になってきた。

709
00:35:06,780 --> 00:35:07,620
それでは、私たちは何をしますか？

710
00:35:07,620 --> 00:35:12,510
>> 読者：私たちは、頭を行うには、ここで、new_nodeに等しい。

711
00:35:12,510 --> 00:35:16,690
>> JASONハーシュホーン：ヘッド
ここで、new_nodeに等しい。

712
00:35:16,690 --> 00:35:20,540
そして、なぜ表示されませ、ここに向かう？

713
00:35:20,540 --> 00:35:24,940
>> 観客：頭がグローバルであるため
出発点である変数、。

714
00:35:24,940 --> 00:35:26,190
>> JASONハーシュホーン：甘い。

715
00:35:26,190 --> 00:35:33,750

716
00:35:33,750 --> 00:35:34,170
[OK]をクリックします。

717
00:35:34,170 --> 00:35:36,150
そして - 

718
00:35:36,150 --> 00:35:53,796
>> 観客：次に、あなたが他の何前のページ - >
次のここで、new_nodeは等しくなります。

719
00:35:53,796 --> 00:35:55,080
そして、あなたはtrueを返します。

720
00:35:55,080 --> 00:35:59,560

721
00:35:59,560 --> 00:36:02,700
>> JASONハーシュホーン：DO
我々はここで、new_node終わりを設定されていますか？

722
00:36:02,700 --> 00:36:04,850
>> 読者：私はでしょう - 

723
00:36:04,850 --> 00:36:06,180
私は、開始時にそれを設定してください。

724
00:36:06,180 --> 00:36:07,430
>> JASONハーシュホーン：だから何行？

725
00:36:07,430 --> 00:36:10,000

726
00:36:10,000 --> 00:36:12,598
>> 読者：IF文の後
それが知られているかどうかをチェックする。

727
00:36:12,598 --> 00:36:13,057
>> JASONハーシュホーン：右ここに？

728
00:36:13,057 --> 00:36:18,335
>> 読者：私は何をしたいで、new_node-> N
値に等しい。

729
00:36:18,335 --> 00:36:19,585
>> JASONハーシュホーン：良さそうですね。

730
00:36:19,585 --> 00:36:21,740

731
00:36:21,740 --> 00:36:25,090
おそらくそれは理にかなっている - 私たちにはありません
私たちがしているものをリスト知っておく必要があります

732
00:36:25,090 --> 00:36:26,280
我々は扱っているので、
1リストで。

733
00:36:26,280 --> 00:36:29,560
のためのとても優れた関数宣言
これはちょうどこのを取り除くことです

734
00:36:29,560 --> 00:36:34,360
完全に、ちょうど挿入
頭に値。

735
00:36:34,360 --> 00:36:35,930
私たちも知っている必要はありません
我々はインチているもののリスト

736
00:36:35,930 --> 00:36:39,140
しかし、私は今のためにそれを維持します
その後、更新の際にそれを変更

737
00:36:39,140 --> 00:36:42,590
スライドとコード。

738
00:36:42,590 --> 00:36:44,980
だから、今のよさそうだ。

739
00:36:44,980 --> 00:36:46,560
場合には、値 - この行を行うことができますか？

740
00:36:46,560 --> 00:36:47,810
もし - 

741
00:36:47,810 --> 00:36:52,240

742
00:36:52,240 --> 00:36:53,840
私たちは、ノアは、ここで何をしますか。

743
00:36:53,840 --> 00:36:57,890

744
00:36:57,890 --> 00:37:07,100
>> 観客：値が大きい場合
Nゴロゴロ - >より - 

745
00:37:07,100 --> 00:37:16,830

746
00:37:16,830 --> 00:37:18,240
>> JASONハーシュホーン：どうすれば
我々は次のノードに行く？

747
00:37:18,240 --> 00:37:27,760

748
00:37:27,760 --> 00:37:30,530
>> 観客：CURR-> nは
ここで、new_nodeに等しい。

749
00:37:30,530 --> 00:37:37,630

750
00:37:37,630 --> 00:37:39,195
>> JASONハーシュホーン：だからnは
構造体のどの部分？

751
00:37:39,195 --> 00:37:43,065

752
00:37:43,065 --> 00:37:46,020
整数。

753
00:37:46,020 --> 00:37:50,420
そしてここで、new_nodeは、ノードへのポインタである。

754
00:37:50,420 --> 00:37:51,880
だから我々はゴロゴロのどの部分を更新する必要がありますか？

755
00:37:51,880 --> 00:38:03,900

756
00:38:03,900 --> 00:38:05,400
そうでなければnを指定すると、他の部分は何ですか？

757
00:38:05,400 --> 00:38:21,680

758
00:38:21,680 --> 00:38:22,810
ノア、他の部分は何でしょう。

759
00:38:22,810 --> 00:38:23,570
>> 観客：ああ、次の。

760
00:38:23,570 --> 00:38:25,645
>> JASONハーシュホーン：次に、その通りです。

761
00:38:25,645 --> 00:38:26,410
その通りです。

762
00:38:26,410 --> 00:38:28,770
次の右の1である。

763
00:38:28,770 --> 00:38:31,540
そして、我々は他に何が必要なのですか
、ノアを更新する？

764
00:38:31,540 --> 00:38:32,840
>> 観客：ポインタ。

765
00:38:32,840 --> 00:38:34,840
>> JASONハーシュホーン：だから
我々は現在を更新しました。

766
00:38:34,840 --> 00:38:36,090
>> 観客：前のページ - >次。

767
00:38:36,090 --> 00:38:48,160

768
00:38:48,160 --> 00:38:49,410
>> JASONハーシュホーン：うん。

769
00:38:49,410 --> 00:38:57,465

770
00:38:57,465 --> 00:38:58,370
[OK]を、我々は一時停止します。

771
00:38:58,370 --> 00:39:02,200
誰がここに私たちを助けることができますか？

772
00:39:02,200 --> 00:39:03,385
マヌー、我々は何をすべきか？

773
00:39:03,385 --> 00:39:05,615
>> 読者：あなたが設定するんだ
ゴロゴロ - >次に等しいこと。

774
00:39:05,615 --> 00:39:09,110

775
00:39:09,110 --> 00:39:11,630
しかし、前の行の前にそれを行う。

776
00:39:11,630 --> 00:39:12,880
>> JASONハーシュホーン：わかりました。

777
00:39:12,880 --> 00:39:16,590

778
00:39:16,590 --> 00:39:18,260
何か他には？

779
00:39:18,260 --> 00:39:19,170
Akshar。

780
00:39:19,170 --> 00:39:22,680
>> 読者：私はあなたがいるとは思わない
ゴロゴロ - > [次へ]を変更することを意味した。

781
00:39:22,680 --> 00:39:29,270
私はあなたがゴロゴロ等号を行うことを意図していると思う
ゴロゴロ - >次のノードに移動]の横にある。

782
00:39:29,270 --> 00:39:30,500
>> JASONハーシュホーン：だから申し訳​​ありませんが、どこで？

783
00:39:30,500 --> 00:39:32,680
何行に？

784
00:39:32,680 --> 00:39:33,420
この行は？

785
00:39:33,420 --> 00:39:33,750
>> 観客：うん。

786
00:39:33,750 --> 00:39:35,745
ゴロゴロがゴロゴロ - >次に等しいことを確認します。

787
00:39:35,745 --> 00:39:39,690

788
00:39:39,690 --> 00:39:43,360
>> JASONハーシュホーン：だからそれは正しいです
電流があるため、

789
00:39:43,360 --> 00:39:45,220
ノードへのポインタ。

790
00:39:45,220 --> 00:39:48,550
そして、我々はそれが次のを指すようにしたい
現在なってきたもののノード

791
00:39:48,550 --> 00:39:49,930
を指摘した。

792
00:39:49,930 --> 00:39:54,410
ゴロゴロ自体は、次のを持っています。

793
00:39:54,410 --> 00:39:58,620
しかし、我々はcurr.nextを更新した場合、我々は
実際のノートを更新することになる

794
00:39:58,620 --> 00:40:01,430
それ自体ではなく、ここ
ポインタが指していた。

795
00:40:01,430 --> 00:40:02,680
何でも、この行について。

796
00:40:02,680 --> 00:40:05,160

797
00:40:05,160 --> 00:40:07,330
AVI？

798
00:40:07,330 --> 00:40:09,590
>> 観客：前のページ - >次のゴロゴロに等しい。

799
00:40:09,590 --> 00:40:12,500

800
00:40:12,500 --> 00:40:19,440
>> JASONハーシュホーン：だから、もう一度、前の場合はA
ノードへのポインタ、前へ - >次です

801
00:40:19,440 --> 00:40:23,020
ノード内の実際のポインタ。

802
00:40:23,020 --> 00:40:27,190
だから、これは更新されます
ゴロゴロノード内のポインタ。

803
00:40:27,190 --> 00:40:28,570
我々は更新しない
ノード内のポインタ。

804
00:40:28,570 --> 00:40:30,570
我々は前回の更新したいと思います。

805
00:40:30,570 --> 00:40:31,850
だから我々はそれをどのように行うのですか？

806
00:40:31,850 --> 00:40:34,250
>> 観客：それはちょうど前のことになる。

807
00:40:34,250 --> 00:40:34,565
>> JASONハーシュホーン：右。

808
00:40:34,565 --> 00:40:35,560
前のノードへのポインタである。

809
00:40:35,560 --> 00:40:38,750
今、私たちは、それを変更している
ノードへの新しいポインタ。

810
00:40:38,750 --> 00:40:40,830
[OK]を私たちは下に移動してみましょう。

811
00:40:40,830 --> 00:40:41,940
最後に、この最後の条件。

812
00:40:41,940 --> 00:40:44,896
ジェフは、我々はここで何をしますか？

813
00:40:44,896 --> 00:40:47,515
>> 観客：値がある場合
ゴロゴロ - > Nに等しい。

814
00:40:47,515 --> 00:40:51,030

815
00:40:51,030 --> 00:40:51,300
>> JASONハーシュホーン：申し訳ありません。

816
00:40:51,300 --> 00:40:52,372
善良私のオハイオ州。

817
00:40:52,372 --> 00:40:54,330
何が？

818
00:40:54,330 --> 00:40:55,580
値==ゴロゴロ - > N。

819
00:40:55,580 --> 00:41:01,050

820
00:41:01,050 --> 00:41:02,300
私たちは何をしますか？

821
00:41:02,300 --> 00:41:04,760

822
00:41:04,760 --> 00:41:10,950
>> 読者：あなたは私たちで、new_nodeを解放したい、
そして、あなたはfalseを返すと思います。

823
00:41:10,950 --> 00:41:21,410

824
00:41:21,410 --> 00:41:23,460
>> JASONハーシュホーン：これは何であるか
我々はこれまでに書かれている。

825
00:41:23,460 --> 00:41:25,710
誰も何も持っていますか
我々が作る前に追加するには？

826
00:41:25,710 --> 00:41:35,460

827
00:41:35,460 --> 00:41:35,710
[OK]をクリックします。

828
00:41:35,710 --> 00:41:36,960
やってみよう。

829
00:41:36,960 --> 00:41:44,180

830
00:41:44,180 --> 00:41:46,110
コントロールが最後に到達する可能性
void以外の関数の。

831
00:41:46,110 --> 00:41:48,310
AVI、何が起こっているの？

832
00:41:48,310 --> 00:41:51,380
>> 読者：あなたはリターンを置くことになっている
whileループの外に本当？

833
00:41:51,380 --> 00:41:53,900

834
00:41:53,900 --> 00:41:54,400
>> JASONハーシュホーン：私は知らない。

835
00:41:54,400 --> 00:41:54,780
あなたは私をしたいですか？

836
00:41:54,780 --> 00:41:55,520
>> 観客：気にしないで。

837
00:41:55,520 --> 00:41:56,350
いいえ。

838
00:41:56,350 --> 00:41:57,180
>> JASONハーシュホーン：Akshar？

839
00:41:57,180 --> 00:41:59,460
>> 読者：私はあなたがする意味と思う
最後にfalseを返す入れる

840
00:41:59,460 --> 00:42:02,230
whileループの。

841
00:42:02,230 --> 00:42:03,270
>> JASONハーシュホーン：だからここで
あなたはそれが行きたいですか？

842
00:42:03,270 --> 00:42:05,270
>> 読者：whileループの外のように。

843
00:42:05,270 --> 00:42:08,800
だから、その手段には、whileループを終了した場合
あなたが最後に到達したことと、

844
00:42:08,800 --> 00:42:09,980
何も起こらなかっただ。

845
00:42:09,980 --> 00:42:10,410
>> JASONハーシュホーン：わかりました。

846
00:42:10,410 --> 00:42:12,340
だから我々はここで何をしますか？

847
00:42:12,340 --> 00:42:13,702
>> 読者：あなたはfalseを返す
そこにも。

848
00:42:13,702 --> 00:42:15,040
>> JASONハーシュホーン：ああ、私たち
両方の場所でそれを行う？

849
00:42:15,040 --> 00:42:15,650
>> 観客：うん。

850
00:42:15,650 --> 00:42:16,900
>> JASONハーシュホーン：わかりました。

851
00:42:16,900 --> 00:42:24,840

852
00:42:24,840 --> 00:42:26,160
私達は行くべきでしょうか？

853
00:42:26,160 --> 00:42:26,980
善良私のオハイオ州。

854
00:42:26,980 --> 00:42:27,290
ごめんなさい。

855
00:42:27,290 --> 00:42:28,480
私は、画面をおかけして申し訳ございません。

856
00:42:28,480 --> 00:42:30,530
それは、私たちに怖がらのようなものだ。

857
00:42:30,530 --> 00:42:31,520
だから、オプションを選択します。

858
00:42:31,520 --> 00:42:35,260
ゼロは、コードごとに、プログラムを終了します。

859
00:42:35,260 --> 00:42:36,700
一つは、何かを挿入します。

860
00:42:36,700 --> 00:42:37,990
それでは3を挿入してみましょう。

861
00:42:37,990 --> 00:42:42,900

862
00:42:42,900 --> 00:42:45,380
インサートは成功しませんでした。

863
00:42:45,380 --> 00:42:46,500
私はプリントアウトするつもりです。

864
00:42:46,500 --> 00:42:48,050
私は何も持っていません。

865
00:42:48,050 --> 00:42:48,450
[OK]をクリックします。

866
00:42:48,450 --> 00:42:50,250
多分それはちょうどまぐれだった。

867
00:42:50,250 --> 00:42:52,810
1を挿入します。

868
00:42:52,810 --> 00:42:55,770
成功していない。

869
00:42:55,770 --> 00:42:57,470
[OK]をクリックします。

870
00:42:57,470 --> 00:43:02,400
それでは本当にすぐに、GDBを介​​して実行しましょう
何が起こっているかをチェックします。

871
00:43:02,400 --> 00:43:06,055
>> あなたのGDBを覚えています。/名
プログラムは、GDBに私たちを取得します。

872
00:43:06,055 --> 00:43:07,610
たくさん処理するということです？

873
00:43:07,610 --> 00:43:08,560
明滅していますか？

874
00:43:08,560 --> 00:43:10,400
多分。

875
00:43:10,400 --> 00:43:12,760
目を閉じて、いくつかの深いを取る
あなたは疲れている場合呼吸

876
00:43:12,760 --> 00:43:13,580
それを見ての。

877
00:43:13,580 --> 00:43:14,200
私は、GDBにいるよ。

878
00:43:14,200 --> 00:43:15,830
私は、GDBで最初に行うことは何ですか？

879
00:43:15,830 --> 00:43:17,050
我々は把握するんだ
ここで何が起こっている。

880
00:43:17,050 --> 00:43:17,310
見てみましょう。

881
00:43:17,310 --> 00:43:21,650
私たちは、図のように6分を持っている
何が起こっているか。

882
00:43:21,650 --> 00:43:22,900
主に折り返されます。

883
00:43:22,900 --> 00:43:25,950

884
00:43:25,950 --> 00:43:28,130
そして私は何をしますか？

885
00:43:28,130 --> 00:43:29,180
カルロス·？

886
00:43:29,180 --> 00:43:31,060
実行します。

887
00:43:31,060 --> 00:43:32,250
[OK]をクリックします。

888
00:43:32,250 --> 00:43:34,160
のオプションを選択してみましょう。

889
00:43:34,160 --> 00:43:36,330
とN何をするのでしょうか？

890
00:43:36,330 --> 00:43:38,480
次へ。

891
00:43:38,480 --> 00:43:38,950
うん。

892
00:43:38,950 --> 00:43:39,740
>> 読者：あなたは言及しなかった - 

893
00:43:39,740 --> 00:43:45,230
あなたは頭が、それがあったことを言わなかった
先頭にnullに初期化されます。

894
00:43:45,230 --> 00:43:47,140
しかし、私はあなたがそれがOKと言ったと思った。

895
00:43:47,140 --> 00:43:50,040

896
00:43:50,040 --> 00:43:52,640
>> JASONハーシュホーン：行きましょう - それでは見てみましょう
GDBにし、私たちは戻って行きます。

897
00:43:52,640 --> 00:43:54,910
しかし、あなたはすでに持っているように聞こえる
何が起こっているかについていくつかのアイデア。

898
00:43:54,910 --> 00:43:58,340
だから我々は何かを挿入したい。

899
00:43:58,340 --> 00:43:59,390
[OK]をクリックします。

900
00:43:59,390 --> 00:44:00,150
私たちは、挿入している。

901
00:44:00,150 --> 00:44:00,770
int型を入力してください。

902
00:44:00,770 --> 00:44:01,990
我々は3を挿入します。

903
00:44:01,990 --> 00:44:03,000
そして私は、この行によ。

904
00:44:03,000 --> 00:44:07,030
どのようにしてデバッグを開始する行くのですか
インサートは、機能の公知？

905
00:44:07,030 --> 00:44:08,280
善良私のオハイオ州。

906
00:44:08,280 --> 00:44:10,990

907
00:44:10,990 --> 00:44:12,240
それはたくさんある。

908
00:44:12,240 --> 00:44:14,372

909
00:44:14,372 --> 00:44:16,445
多くのことを怖がらことですか？

910
00:44:16,445 --> 00:44:19,696

911
00:44:19,696 --> 00:44:21,680
>> 観客：ああ、それは死んだ。

912
00:44:21,680 --> 00:44:22,930
>> JASONハーシュホーン：ちょうど私
それを取り出した。

913
00:44:22,930 --> 00:44:27,364

914
00:44:27,364 --> 00:44:28,310
[OK]をクリックします。

915
00:44:28,310 --> 00:44:29,560
>> 観客：多分それはだ
線のもう一方の端。

916
00:44:29,560 --> 00:44:37,000

917
00:44:37,000 --> 00:44:39,470
>> JASONハーシュホーン：うわー。

918
00:44:39,470 --> 00:44:42,330
だから、一番下の行 - 

919
00:44:42,330 --> 00:44:43,470
何て言ったの？

920
00:44:43,470 --> 00:44:46,040
>> 読者：私は言った技術的の皮肉
このクラスの難しさ。

921
00:44:46,040 --> 00:44:46,410
>> JASONハーシュホーン：私は知っている。

922
00:44:46,410 --> 00:44:48,660
場合にのみ、私はその部分を制御していた。

923
00:44:48,660 --> 00:44:49,910
[聞こえない]

924
00:44:49,910 --> 00:44:54,430

925
00:44:54,430 --> 00:44:55,400
それは素晴らしいサウンド。

926
00:44:55,400 --> 00:44:58,680
なぜあなたたちは考えて起動しない
我々は間違って行ったかもしれないもの、

927
00:44:58,680 --> 00:45:01,140
そして我々は戻って90秒になります。

928
00:45:01,140 --> 00:46:18,160

929
00:46:18,160 --> 00:46:23,010
>> Avica、私はどのように行くをお願いするつもりです
それをデバッグする内部insert_node。

930
00:46:23,010 --> 00:46:28,940

931
00:46:28,940 --> 00:46:31,460
我々は最後の中断したところにするためです。

932
00:46:31,460 --> 00:46:35,110
どのように私はinsert_node、Avica内側に行くのですか、
何が起こっているのか調べるために？

933
00:46:35,110 --> 00:46:36,360
どのようなGDBコマンド？

934
00:46:36,360 --> 00:46:41,050

935
00:46:41,050 --> 00:46:42,390
ブレークは内部の私を取らないだろう。

936
00:46:42,390 --> 00:46:46,200

937
00:46:46,200 --> 00:46:47,130
マーキスは知っていますか？

938
00:46:47,130 --> 00:46:48,240
>> 観客：何？

939
00:46:48,240 --> 00:46:51,780
>> JASONハーシュホーン：どのようなGDBコマンド
私は、この関数の中で行くことに使うのか？

940
00:46:51,780 --> 00:46:52,070
>> 観客：ステップ？

941
00:46:52,070 --> 00:46:55,140
>> JASONハーシュホーン：経てステップ
内部の私を取るS.。

942
00:46:55,140 --> 00:46:55,476
[OK]をクリックします。

943
00:46:55,476 --> 00:46:58,040
いくつかの領域をmallocingで、new_node。

944
00:46:58,040 --> 00:46:59,120
すべては行くようになっていること。

945
00:46:59,120 --> 00:47:00,370
それではここで、new_nodeを調べてみましょう。

946
00:47:00,370 --> 00:47:03,270

947
00:47:03,270 --> 00:47:05,410
これは、いくつかのメモリ·アドレスを得た。

948
00:47:05,410 --> 00:47:07,440
それでは確認してみましょう - 

949
00:47:07,440 --> 00:47:08,500
つまり、すべて正しい。

950
00:47:08,500 --> 00:47:12,220
だからここにすべてがいるようだ
正しく動作して。

951
00:47:12,220 --> 00:47:14,530
>> 観客：違いは何ですか
Pとディスプレイとの間に？

952
00:47:14,530 --> 00:47:16,160
>> JASONハーシュホーン：Pは、印刷の略です。

953
00:47:16,160 --> 00:47:19,310
だからあなたは何を求めている
その本の違いは？

954
00:47:19,310 --> 00:47:22,330
この場合は、何もない。

955
00:47:22,330 --> 00:47:26,960
しかし、一般的に存在する
いくつかの違い。

956
00:47:26,960 --> 00:47:28,220
そして、あなたは、GDBのマニュアルになっているはずです。

957
00:47:28,220 --> 00:47:29,560
しかし、この場合は、何もない。

958
00:47:29,560 --> 00:47:31,460
我々は、しかし、印刷を使用する傾向があるので、
我々はより多くを実行する必要はありません

959
00:47:31,460 --> 00:47:33,960
単一の値を印刷します。

960
00:47:33,960 --> 00:47:34,640
>> [OK]をクリックします。

961
00:47:34,640 --> 00:47:40,300
だから我々は、我々のコードの行80にある
リストに等しいノード*のCURRを設定。

962
00:47:40,300 --> 00:47:42,500
私たちがゴロゴロをプリントアウトしてみましょう。

963
00:47:42,500 --> 00:47:45,260

964
00:47:45,260 --> 00:47:46,840
これは、リストに相当します。

965
00:47:46,840 --> 00:47:48,850
甘い。

966
00:47:48,850 --> 00:47:49,340
待つ。

967
00:47:49,340 --> 00:47:50,590
それは何かと等しい。

968
00:47:50,590 --> 00:47:53,680

969
00:47:53,680 --> 00:47:56,190
それは正しいていないようです。

970
00:47:56,190 --> 00:47:56,840
そこに私達は行く。

971
00:47:56,840 --> 00:47:59,470
GDBで、右のであれば、だ
それはあなたがそれにしているラインです

972
00:47:59,470 --> 00:48:00,330
まだ実行されていません。

973
00:48:00,330 --> 00:48:03,100
だから、実際に入力する必要が
行を実行するために、次の

974
00:48:03,100 --> 00:48:05,230
その結果を見てください。

975
00:48:05,230 --> 00:48:06,680
そこでここでは、ある。

976
00:48:06,680 --> 00:48:09,490
私達はちょうどこの行を実行する、
以前はNULLに等しくなります。

977
00:48:09,490 --> 00:48:13,590
だからもう一度、私たちは前の印刷した場合
私たちは奇妙な何も表示されません。

978
00:48:13,590 --> 00:48:18,680
しかし、我々は実際にそれを実行した場合
ライン、そして我々が表示されます

979
00:48:18,680 --> 00:48:20,380
その行が働いたことを。

980
00:48:20,380 --> 00:48:21,060
>> だから我々はゴロゴロしています。

981
00:48:21,060 --> 00:48:23,180
それらは両方の良いです。

982
00:48:23,180 --> 00:48:24,010
右？

983
00:48:24,010 --> 00:48:28,130
今、私たちはここ、この行にしている。

984
00:48:28,130 --> 00:48:29,310
ゴロゴロが同じヌルをしていませんが。

985
00:48:29,310 --> 00:48:31,110
さて、ゴロゴロ等しい何でしょうか？

986
00:48:31,110 --> 00:48:32,450
我々はちょうどそれがnullで等しかった。

987
00:48:32,450 --> 00:48:33,210
我々はそれをプリントアウト。

988
00:48:33,210 --> 00:48:35,110
私は再びそれをプリントアウトします。

989
00:48:35,110 --> 00:48:36,720
そうです、そのwhileループ
実行しよう？

990
00:48:36,720 --> 00:48:37,270
>> 観客：いいえ。

991
00:48:37,270 --> 00:48:39,790
>> JASONハーシュホーン：だから私は、その入力された
行すると、我々はすべての方法をジャンプ参照してください。

992
00:48:39,790 --> 00:48:41,390
一番下まで、falseを返します。

993
00:48:41,390 --> 00:48:44,520
そして、我々は、falseを返すつもりだ
私たちのプログラムに戻って、

994
00:48:44,520 --> 00:48:48,020
我々が見たように、最終的には、プリントアウトし、
インサートは成功しませんでした。

995
00:48:48,020 --> 00:48:51,010
だから、誰が何の上の任意のアイデアを持っている
我々はこれを修正するために必要？

996
00:48:51,010 --> 00:48:54,200

997
00:48:54,200 --> 00:48:57,570
私が表示されるまで待つつもりだ
手のカップルは上がる。

998
00:48:57,570 --> 00:48:58,830
我々はこれを実行されませんでした。

999
00:48:58,830 --> 00:49:01,660
覚えておいて、これが最初だった
私たちはやっていた事。

1000
00:49:01,660 --> 00:49:02,430
私はカップルをやるつもりはない。

1001
00:49:02,430 --> 00:49:03,670
私はいくつかをするつもりです。

1002
00:49:03,670 --> 00:49:04,830
カップルが2を意味するので。

1003
00:49:04,830 --> 00:49:07,620
私は以上の2のために待っています。

1004
00:49:07,620 --> 00:49:10,690
>> 第一の挿入、ゴロゴロ、
デフォルトではNULLに等しくなります。

1005
00:49:10,690 --> 00:49:14,050
このループは実行され
ゴロゴロがnullでない場合。

1006
00:49:14,050 --> 00:49:18,740
だから、どうやってこの問題を回避することができますか？

1007
00:49:18,740 --> 00:49:19,990
私は3の手を参照してください。

1008
00:49:19,990 --> 00:49:28,490

1009
00:49:28,490 --> 00:49:29,780
私は以上の3のために待っています。

1010
00:49:29,780 --> 00:49:33,460

1011
00:49:33,460 --> 00:49:35,940
マーカス、あなたはどう思いますか？

1012
00:49:35,940 --> 00:49:37,730
>> 観客：さて、あなたはそれを必要とする場合に
複数回実行するだけで

1013
00:49:37,730 --> 00:49:39,948
DO-whil​​eループに変更します。

1014
00:49:39,948 --> 00:49:41,250
>> JASONハーシュホーン：わかりました。

1015
00:49:41,250 --> 00:49:44,240
それはしかし、我々の問題を解決するのだろうか？

1016
00:49:44,240 --> 00:49:47,750
>> 読者：この場合、何のためにしない
リストが空であるという事実。

1017
00:49:47,750 --> 00:49:52,150
だから、あなたはおそらくだけ追加する必要があります
if文ループが終了すること

1018
00:49:52,150 --> 00:49:55,312
その後、終了時にする必要が
あなたを、その時点でリスト、

1019
00:49:55,312 --> 00:49:56,562
ちょうどそれを挿入することができます。

1020
00:49:56,562 --> 00:49:58,920

1021
00:49:58,920 --> 00:49:59,680
>> JASONハーシュホーン：私はそれが好きです。

1022
00:49:59,680 --> 00:50:00,500
それは理にかなっています。

1023
00:50:00,500 --> 00:50:03,390
ループが終了した場合 - 

1024
00:50:03,390 --> 00:50:04,800
それがここにfalseを返すだろうから。

1025
00:50:04,800 --> 00:50:08,220
だから、ループが終了した場合、我々はにいる
多分リストの最後、または

1026
00:50:08,220 --> 00:50:10,690
中の何もない場合は、リストの先頭
終わりにすることと同じであり、。

1027
00:50:10,690 --> 00:50:12,770
だから今我々は、挿入したい
ここで何か。

1028
00:50:12,770 --> 00:50:17,380
それでは、どのそのコードは、マーカスが見えますか？

1029
00:50:17,380 --> 00:50:21,600
>> 読者：あなたはすでにノードを持っている場合
mallocさ、あなただけの言うことができる

1030
00:50:21,600 --> 00:50:25,400
ここで、new_node->次のため、ヌルに等しい
それが最後である必要があります。

1031
00:50:25,400 --> 00:50:27,510
あるいはここで、new_node->次のヌルに等しい。

1032
00:50:27,510 --> 00:50:27,765
>> JASONハーシュホーン：わかりました。

1033
00:50:27,765 --> 00:50:28,190
申し訳ありません。

1034
00:50:28,190 --> 00:50:35,760
ここで、new_node->次のヌルに等しい
我々は最後にだから。

1035
00:50:35,760 --> 00:50:36,460
つまり、それをインチ入れていません

1036
00:50:36,460 --> 00:50:37,710
どのように我々は、リストに入れていますか？

1037
00:50:37,710 --> 00:50:46,130

1038
00:50:46,130 --> 00:50:46,460
右。

1039
00:50:46,460 --> 00:50:47,750
それはちょうど等しく、それを設定することです。

1040
00:50:47,750 --> 00:50:50,940
実際にどのように我々はありません
リストに入れて？

1041
00:50:50,940 --> 00:50:54,170
を指しているのか
リストの最後に？

1042
00:50:54,170 --> 00:50:56,090
>> 観客：ヘッド。

1043
00:50:56,090 --> 00:50:57,566
>> JASONハーシュホーン：申し訳ありませんが？

1044
00:50:57,566 --> 00:50:59,440
>> 観客：頭を指している
リストの最後に。

1045
00:50:59,440 --> 00:51:01,480
>> JASONハーシュホーン：何もでがない場合
リスト、ヘッドはを指している

1046
00:51:01,480 --> 00:51:04,170
リストの最後。

1047
00:51:04,170 --> 00:51:06,920
だからために働くよ
第一の挿入。

1048
00:51:06,920 --> 00:51:09,810
いくつかありますかについてあれば
リストにあるもの？

1049
00:51:09,810 --> 00:51:12,470
我々は設定しないよりも、
ここで、new_nodeに等しい頭。

1050
00:51:12,470 --> 00:51:13,790
我々はそこに何をすべきかをしたいですか？

1051
00:51:13,790 --> 00:51:15,610
うん？

1052
00:51:15,610 --> 00:51:16,860
おそらく以前の。

1053
00:51:16,860 --> 00:51:23,560

1054
00:51:23,560 --> 00:51:24,810
それは動作しますか？

1055
00:51:24,810 --> 00:51:28,950

1056
00:51:28,950 --> 00:51:33,050
以前はただであることを思い出してください
ノードへのポインタ。

1057
00:51:33,050 --> 00:51:34,770
そして以前はローカル変数です。

1058
00:51:34,770 --> 00:51:38,080
したがって、この行は、ローカル変数を設定します、
、前回と同じか、

1059
00:51:38,080 --> 00:51:39,380
この新しいノードを指す。

1060
00:51:39,380 --> 00:51:41,500
つまり、実際にそれを置くことはありません
私たちのリストにある、しかし。

1061
00:51:41,500 --> 00:51:44,330
どのように我々は私たちのリストに入れていますか？

1062
00:51:44,330 --> 00:51:45,620
Akchar？

1063
00:51:45,620 --> 00:51:46,870
>> 読者：私はあなたを思う
次の電流 - >を行います。

1064
00:51:46,870 --> 00:51:50,186

1065
00:51:50,186 --> 00:51:52,550
>> JASONハーシュホーン：わかりました。

1066
00:51:52,550 --> 00:51:54,010
ゴロゴロ - >次。

1067
00:51:54,010 --> 00:51:58,768
だからもう一度、私たちがダウンしている唯一の理由
ここに等しい電流が何です？

1068
00:51:58,768 --> 00:51:59,760
>> 観客：ヌル等しい。

1069
00:51:59,760 --> 00:52:01,790
>> JASONハーシュホーン：だから何
我々は次のヌル->を行う場合はどうなりますか？

1070
00:52:01,790 --> 00:52:02,810
我々は、取得するつもりですか？

1071
00:52:02,810 --> 00:52:04,060
私たちは、セグメンテーションフォールトを取得します。

1072
00:52:04,060 --> 00:52:06,600

1073
00:52:06,600 --> 00:52:08,880
>> 読者：飲酒CURRがnullに等しい。

1074
00:52:08,880 --> 00:52:10,760
>> JASONハーシュホーン：それは同じことだ
前のように、しかし、そこだから

1075
00:52:10,760 --> 00:52:12,820
我々は設定しているローカル変数
この新しいノードに等しい。

1076
00:52:12,820 --> 00:52:16,680

1077
00:52:16,680 --> 00:52:20,920
私たちの絵に戻りましょう
何かを挿入する。

1078
00:52:20,920 --> 00:52:25,500
我々は最後に挿入していると言う
リストのため、まさにここ。

1079
00:52:25,500 --> 00:52:30,010
私たちは、の現在のポインタを持っている
nullにポイントして、前のポイント

1080
00:52:30,010 --> 00:52:32,800
つまり、8を指しています。

1081
00:52:32,800 --> 00:52:35,330
それでは我々は、AVIを更新する必要がありますか？

1082
00:52:35,330 --> 00:52:36,680
>> 観客：前 - >次は？

1083
00:52:36,680 --> 00:52:41,980
>> JASONハーシュホーン：前 - >次は何がある
我々はそのため更新する

1084
00:52:41,980 --> 00:52:44,960
実際にそれを挿入します
リストの最後。

1085
00:52:44,960 --> 00:52:47,220
我々はまだ、しかし、1バグを持っている
我々はに実行するつもりという。

1086
00:52:47,220 --> 00:52:50,090
そのバグは何ですか？

1087
00:52:50,090 --> 00:52:50,790
うん？

1088
00:52:50,790 --> 00:52:53,860
>> 観客：それは返すために起こっている
この場合、偽？

1089
00:52:53,860 --> 00:52:56,380
>> JASONハーシュホーン：ああ、あるさ
falseを返しに行く。

1090
00:52:56,380 --> 00:52:57,430
しかし、別のバグがあります。

1091
00:52:57,430 --> 00:52:58,930
だから我々は真のお返しに配置する必要があります。

1092
00:52:58,930 --> 00:53:01,370
>> 観客：か前のまだ等しい
リストの一番上にはnull？

1093
00:53:01,370 --> 00:53:03,645
>> JASONハーシュホーン：だから前の、まだ
先頭にヌルに等しい。

1094
00:53:03,645 --> 00:53:07,480

1095
00:53:07,480 --> 00:53:10,440
では、どのようにそれを乗り越えることができますか？

1096
00:53:10,440 --> 00:53:10,950
うん？

1097
00:53:10,950 --> 00:53:15,280
>> 読者：私はあなたがチェックを行うことができると思います
それはだ場合は、whileループを確認します前に、

1098
00:53:15,280 --> 00:53:16,610
空のリスト。

1099
00:53:16,610 --> 00:53:17,000
>> JASONハーシュホーン：わかりました。

1100
00:53:17,000 --> 00:53:17,710
それでは、ここに行きましょう。

1101
00:53:17,710 --> 00:53:18,530
チェックを行う。

1102
00:53:18,530 --> 00:53:19,380
もし - 

1103
00:53:19,380 --> 00:53:20,770
>> 観客：そうであればヘッド
ヌルに等しい等しい。

1104
00:53:20,770 --> 00:53:24,300

1105
00:53:24,300 --> 00:53:26,320
>> JASONハーシュホーン：もし頭
ヌルに等しい等しい - 

1106
00:53:26,320 --> 00:53:27,790
それは、空のリストだ場合には、私たちに教えてあげましょう。

1107
00:53:27,790 --> 00:53:31,090
>> 観客：それから、あなた
何頭が新たに等しい。

1108
00:53:31,090 --> 00:53:34,740
>> JASONハーシュホーン：ヘッド
ここで、new_nodeに等しい？

1109
00:53:34,740 --> 00:53:35,730
そして他に何私たちは何をする必要があります？

1110
00:53:35,730 --> 00:53:37,020
>> 観客：それから、あなたはtrueを返します。

1111
00:53:37,020 --> 00:53:37,535
>> JASONハーシュホーン：非常にされていません。

1112
00:53:37,535 --> 00:53:38,785
私たちは、一歩を逃している。

1113
00:53:38,785 --> 00:53:41,590

1114
00:53:41,590 --> 00:53:43,710
>> 読者：ここで、new_node次の
NULLを指しています。

1115
00:53:43,710 --> 00:53:44,570
>> JASONハーシュホーン：その通り、オールデン。

1116
00:53:44,570 --> 00:53:46,600
そして、我々は真を返すことができます。

1117
00:53:46,600 --> 00:53:47,560
[OK]をクリックします。

1118
00:53:47,560 --> 00:53:51,630
しかし、それはまだ物事を行うことをお勧めします
リストの最後に、右か？

1119
00:53:51,630 --> 00:53:51,950
わかりました。

1120
00:53:51,950 --> 00:53:54,450
我々はまだ実際に得るかもしれない
リストの最後に。

1121
00:53:54,450 --> 00:53:57,870
我々がしているのであれば、このコードの罰金です
リストの最後といくつかあります

1122
00:53:57,870 --> 00:53:59,120
リストにあるもの？

1123
00:53:59,120 --> 00:54:01,830

1124
00:54:01,830 --> 00:54:02,040
右？

1125
00:54:02,040 --> 00:54:03,540
我々はまだマーカスのアイデアを持っているので。

1126
00:54:03,540 --> 00:54:06,870
我々は、理由このループを終了することがあり
私たちは、リストの最後にいる。

1127
00:54:06,870 --> 00:54:09,308
だから我々はまだこれをしたいですか
ここでダウンしてコーディングする？

1128
00:54:09,308 --> 00:54:10,520
>> 観客：はい。

1129
00:54:10,520 --> 00:54:11,000
>> JASONハーシュホーン：うん。

1130
00:54:11,000 --> 00:54:14,190
そして、我々は、これを変更するには何が必要ですか？

1131
00:54:14,190 --> 00:54:15,440
真。

1132
00:54:15,440 --> 00:54:19,580

1133
00:54:19,580 --> 00:54:21,640
ないことを、音の良い
誰もがこれまでのところ？

1134
00:54:21,640 --> 00:54:22,420
誰もがいずれかを持っている - 

1135
00:54:22,420 --> 00:54:23,480
aviファイルは、あなたが追加したいアイテムがありますか？

1136
00:54:23,480 --> 00:54:23,920
>> 観客：いいえ。

1137
00:54:23,920 --> 00:54:25,276
>> JASONハーシュホーン：わかりました。

1138
00:54:25,276 --> 00:54:27,010
だから我々はいくつかの変更を加えました。

1139
00:54:27,010 --> 00:54:29,540
我々は、我々の前に、このチェックを作りました
空のリストについては、中行ってきました。

1140
00:54:29,540 --> 00:54:31,790
だから我々は空のリストの世話をしてきました。

1141
00:54:31,790 --> 00:54:35,500
そしてここでは、挿入の世話をした
リストの最後に何か。

1142
00:54:35,500 --> 00:54:38,930
だから、このwhileループの撮影のように思える
間にあるものの世話、

1143
00:54:38,930 --> 00:54:41,920
リスト内のどこかにある場合があり
リスト中のものがあります。

1144
00:54:41,920 --> 00:54:42,280
>> [OK]をクリックします。

1145
00:54:42,280 --> 00:54:44,310
私たちはもう一度、このプログラムを実行してみましょう。

1146
00:54:44,310 --> 00:54:50,170

1147
00:54:50,170 --> 00:54:50,755
成功していない。

1148
00:54:50,755 --> 00:54:52,190
>> 読者：あなたはそれをしなかった。

1149
00:54:52,190 --> 00:54:53,940
>> JASONハーシュホーン：ああ、
私はそれをしなかった。

1150
00:54:53,940 --> 00:54:56,250
良い点、マイケル。

1151
00:54:56,250 --> 00:54:57,500
の、リンクされたメイクを追加してみましょう。

1152
00:54:57,500 --> 00:55:01,590

1153
00:55:01,590 --> 00:55:04,830
ライン87にエラーがあります。

1154
00:55:04,830 --> 00:55:05,420
ライン87。

1155
00:55:05,420 --> 00:55:06,600
オールデン、これはあなたが私を与えたラインだった。

1156
00:55:06,600 --> 00:55:08,962
何が気に入らないのだ。

1157
00:55:08,962 --> 00:55:10,710
>> 観客：それはnullにしなければならない。

1158
00:55:10,710 --> 00:55:11,000
>> JASONハーシュホーン：優秀。

1159
00:55:11,000 --> 00:55:11,630
まったく正しい。

1160
00:55:11,630 --> 00:55:13,290
それはNULLでなければなりません。

1161
00:55:13,290 --> 00:55:15,210
それでは、もう一度作ってみましょう。

1162
00:55:15,210 --> 00:55:17,220
コンパイルします。

1163
00:55:17,220 --> 00:55:17,890
[OK]をクリックします。

1164
00:55:17,890 --> 00:55:19,400
それでは3を挿入してみましょう。

1165
00:55:19,400 --> 00:55:20,570
挿入に成功しました。

1166
00:55:20,570 --> 00:55:21,660
のは、それをプリントアウトしてみましょう。

1167
00:55:21,660 --> 00:55:23,590
ああ、我々は確認できた場合に限ります。

1168
00:55:23,590 --> 00:55:25,500
しかし、我々は行っていない
まだ印刷機能。

1169
00:55:25,500 --> 00:55:27,840
それでは何か他のものを入力してみましょう。

1170
00:55:27,840 --> 00:55:29,090
私たちは何を入力するべきか？

1171
00:55:29,090 --> 00:55:31,120

1172
00:55:31,120 --> 00:55:31,940
>> 観客：セブン。

1173
00:55:31,940 --> 00:55:33,340
>> JASONハーシュホーンセブン？

1174
00:55:33,340 --> 00:55:34,590
>> 観客：はい。

1175
00:55:34,590 --> 00:55:38,680

1176
00:55:38,680 --> 00:55:39,780
>> JASONハーシュホーン：私たちはワンセグ障害を持っている。

1177
00:55:39,780 --> 00:55:43,760
だから我々は1つを得たが、我々を明確に
2を取得することはできません。

1178
00:55:43,760 --> 00:55:45,690
それが午前5時07分です。

1179
00:55:45,690 --> 00:55:48,370
だから我々はこれをデバッグすることができ
3分間。

1180
00:55:48,370 --> 00:55:51,240
しかし、私はここで私たちを残しするつもりだ
とハッシュテーブルに移動します。

1181
00:55:51,240 --> 00:55:54,290
しかし、再び、このコードのための答え
私は少しであなたにそれをメールでお知らせいたします。

1182
00:55:54,290 --> 00:55:55,440
我々はそれに非常に近い。

1183
00:55:55,440 --> 00:55:58,300
私は非常に把握することをお勧めします
何がここで起こって、それを修正だ。

1184
00:55:58,300 --> 00:56:02,400
だから、私はあなたにこのコードをメールでお知らせいたします
よくプラスソリューション - 

1185
00:56:02,400 --> 00:56:03,670
おそらく後でソリューション。

1186
00:56:03,670 --> 00:56:05,110
最初にこのコード。

1187
00:56:05,110 --> 00:56:08,290
>> 私は、私たちの前にやってみたい他の事
仕上げは、我々は何も解放されていないです。

1188
00:56:08,290 --> 00:56:10,370
だから私はあなたに何を表示したい
Valgrindのは次のようになります。

1189
00:56:10,370 --> 00:56:14,310
私たちは、Valgrindの境界を実行すると
私たちのプログラムで、。/リンク。

1190
00:56:14,310 --> 00:56:22,540
繰り返しますが、このスライドによると、我々
いくつかのタイプのValgrindのを実行する必要があります

1191
00:56:22,540 --> 00:56:26,410
この場合はオプション、
 -  =フル漏れをチェックします。

1192
00:56:26,410 --> 00:56:27,660
それでは、Valgrindのを書いてみましょう
 -  =フル漏れをチェックします。

1193
00:56:27,660 --> 00:56:31,910

1194
00:56:31,910 --> 00:56:35,080
だから、これはValgrindのを実行します
私たちのプログラムに。

1195
00:56:35,080 --> 00:56:37,000
そして今、プログラムが実際に実行されます。

1196
00:56:37,000 --> 00:56:40,190
だから我々は同じようにそれを実行しようとしている
前、インチ何かを置く

1197
00:56:40,190 --> 00:56:40,830
私は3に置くつもりです。

1198
00:56:40,830 --> 00:56:41,790
それが動作します。

1199
00:56:41,790 --> 00:56:43,202
私は何かに配置しようとするつもりはない
他に、我々はするつもりだので、

1200
00:56:43,202 --> 00:56:44,710
その場合、ワンセグ偽を得る。

1201
00:56:44,710 --> 00:56:46,700
だから、僕はやめるつもりです。

1202
00:56:46,700 --> 00:56:50,160
>> そして今、あなたはここでダウンして参照してください。
リークとヒープの要約。

1203
00:56:50,160 --> 00:56:52,310
これらは良いものであることを
あなたがチェックアウトしたい。

1204
00:56:52,310 --> 00:56:56,780
だから、ヒープの要約 - それが言う、使用中
出口で -  1ブロックの8バイト。

1205
00:56:56,780 --> 00:56:58,370
その1ブロックです
ノード我々はmallocさ。

1206
00:56:58,370 --> 00:57:02,230
ノードが8である前に言ったマイケル、
それは、整数を持っているので刺さ

1207
00:57:02,230 --> 00:57:02,680
ポインタ。

1208
00:57:02,680 --> 00:57:04,550
だから、私たちのノードの。

1209
00:57:04,550 --> 00:57:08,170
そして、それは我々がmalloc関数を使っ言う
我々は解放された7回

1210
00:57:08,170 --> 00:57:08,940
何か6回。

1211
00:57:08,940 --> 00:57:13,680
しかし、我々は自由と呼ばれたことがないので、私は持っていない
これが何について話しているのか考え。

1212
00:57:13,680 --> 00:57:18,490
>> しかし、そのときに言えば十分
プログラムが実行され、malloc関数が呼び出されている

1213
00:57:18,490 --> 00:57:20,330
その我々いくつかの他の場所で
心配する必要はありません。

1214
00:57:20,330 --> 00:57:22,460
だから、malloc関数は、おそらくと呼ばれていた
いくつかの場所で。

1215
00:57:22,460 --> 00:57:24,480
我々はどこに心配する必要はありません。

1216
00:57:24,480 --> 00:57:26,240
しかし、これは本当に私たちである。

1217
00:57:26,240 --> 00:57:27,380
この最初の行は私たちです。

1218
00:57:27,380 --> 00:57:28,320
私たちは、そのブロックを残しました。

1219
00:57:28,320 --> 00:57:30,330
そして、あなたはそのここで見ることができます
リーク要約する。

1220
00:57:30,330 --> 00:57:31,950
まだ到達 - 

1221
00:57:31,950 --> 00:57:32,930
1ブロックの8バイト。

1222
00:57:32,930 --> 00:57:34,100
つまり、そのメモリを意味します - 

1223
00:57:34,100 --> 00:57:35,730
私たちは、そのメモリをリークしています。

1224
00:57:35,730 --> 00:57:37,570
確かに失われた - 

1225
00:57:37,570 --> 00:57:38,770
何かは永久に失われます。

1226
00:57:38,770 --> 00:57:40,590
一般的には、あなたではないでしょう
そこには何も表示されます。

1227
00:57:40,590 --> 00:57:44,780
まだ到達は一般的です
あなたが欲しいよなものを、表示されます

1228
00:57:44,780 --> 00:57:48,900
どのようなコードを使用するとすべき見ることに目を向ける
解放されていますが、解放するのを忘れています。

1229
00:57:48,900 --> 00:57:53,170
>> そして、これは、そうではありませんでした場合は、
我々は自由なすべてをした場合には、

1230
00:57:53,170 --> 00:57:54,360
我々はそれを確認することができます。

1231
00:57:54,360 --> 00:57:57,330
ちょうどプログラムを実行してみましょう
何を入れていない。

1232
00:57:57,330 --> 00:57:59,800
あなたが出口で、ここで使用されているダウン表示されます - 

1233
00:57:59,800 --> 00:58:01,310
ゼロブロック内のゼロバイト。

1234
00:58:01,310 --> 00:58:06,310
それは我々が何も残っていなかったことを意味
このプログラムは終了したとき。

1235
00:58:06,310 --> 00:58:12,090
そうpset6に電源を入れる前に、valgrindのを実行する
そしてあなたが持っていないことを確認してください

1236
00:58:12,090 --> 00:58:15,310
任意のメモリは、プログラム内でリークが発生します。

1237
00:58:15,310 --> 00:58:17,910
あなたはValgrindので不明な点がございましたら、
手を差し伸べるお気軽に。

1238
00:58:17,910 --> 00:58:18,700
しかし、これはあなたがそれを使用する方法である。

1239
00:58:18,700 --> 00:58:20,890
非常に単純な - あなたかどうかを確認
出口で使用されている - 

1240
00:58:20,890 --> 00:58:22,270
任意のブロック内の任意のバイト。

1241
00:58:22,270 --> 00:58:27,890

1242
00:58:27,890 --> 00:58:29,580
>> だから我々は、挿入ノード上で作業していた。

1243
00:58:29,580 --> 00:58:33,840
私はここ2他の機能を持っていた - 
ノードと自由なノードを印刷します。

1244
00:58:33,840 --> 00:58:37,780
再度、これらは関数である
あなたが練習するために良いことになるだろう

1245
00:58:37,780 --> 00:58:40,990
彼らはだけでなく、あなたを助けるとなるため、
これらのサンプルの練習だけでなく、

1246
00:58:40,990 --> 00:58:42,180
問題に設定してください。

1247
00:58:42,180 --> 00:58:44,230
彼らは物事にかなり密接に地図
あなたがで行う必要があるとしている

1248
00:58:44,230 --> 00:58:45,010
問題は、設定してください。

1249
00:58:45,010 --> 00:58:47,640
しかし、私は確認したいです
我々はすべてのものに触れる。

1250
00:58:47,640 --> 00:58:50,400
ハッシュテーブルも非常に重要である
我々はここでこれを何をやっている

1251
00:58:50,400 --> 00:58:51,980
週 - または問題セット中。

1252
00:58:51,980 --> 00:58:55,200
>> だから我々は、セクションを終了しようとしている
ハッシュテーブルの話。

1253
00:58:55,200 --> 00:58:58,140
あなたが気づけば私が作​​ら
小さなハッシュテーブル。

1254
00:58:58,140 --> 00:59:00,020
それは我々が話しているものではありません
しかしながら、約。

1255
00:59:00,020 --> 00:59:03,540
我々は、さまざまな話をしている
ハッシュテーブルのタイプ。

1256
00:59:03,540 --> 00:59:07,300
そして、そのコア、ハッシュテーブルで
以外の何ものでもありません

1257
00:59:07,300 --> 00:59:08,860
配列プラスハッシュ関数。

1258
00:59:08,860 --> 00:59:11,150
我々だけに少しのために話をするつもりだ
誰もが何Aを理解し確認してください

1259
00:59:11,150 --> 00:59:12,110
ハッシュ関数である。

1260
00:59:12,110 --> 00:59:15,420
そして私はそれがあることを今、あなたの言っている
二つのこと以外の何物でもない - 

1261
00:59:15,420 --> 00:59:18,590
配列とハッシュ関数。

1262
00:59:18,590 --> 00:59:20,716
そして、ここでの手順は、通っている
これはどのように動作する。

1263
00:59:20,716 --> 00:59:31,560

1264
00:59:31,560 --> 00:59:32,810
>> 私たちの配列があります。

1265
00:59:32,810 --> 00:59:38,460

1266
00:59:38,460 --> 00:59:39,460
私達の機能があります。

1267
00:59:39,460 --> 00:59:43,180
具体的には、ハッシュ関数を実行する必要があり
これで物事のカップルを行う。

1268
00:59:43,180 --> 00:59:45,040
私は、特に話をするつもりだ
については、この問題は、設定してください。

1269
00:59:45,040 --> 00:59:46,450
それはおそらくだろう
文字列になります。

1270
00:59:46,450 --> 00:59:50,570

1271
00:59:50,570 --> 00:59:51,770
そして、何それは返すために起こっているの？

1272
00:59:51,770 --> 00:59:52,640
どのようなデータ型？

1273
00:59:52,640 --> 00:59:54,260
オールデン？

1274
00:59:54,260 --> 00:59:55,760
あなたのハッシュ関数の戻り？

1275
00:59:55,760 --> 00:59:58,760
整数。

1276
00:59:58,760 --> 01:00:01,700
だから、これはどのようなハッシュです
表には、で構成されています - 

1277
01:00:01,700 --> 01:00:05,430
配列の形式で表
ハッシュ関数。

1278
01:00:05,430 --> 01:00:06,010
それはどのように動作します？

1279
01:00:06,010 --> 01:00:07,300
これは、3段階で動作します。

1280
01:00:07,300 --> 01:00:08,740
我々はそれにキーを付けます。

1281
01:00:08,740 --> 01:00:11,470
この場合、我々はそれを文字列を与えるでしょう。

1282
01:00:11,470 --> 01:00:18,140
我々はステップ1あたりのハッシュ関数を呼び出す
キーに、我々は値を取得します。

1283
01:00:18,140 --> 01:00:20,310
>> 具体的には言うよ
我々は、整数を取得します。

1284
01:00:20,310 --> 01:00:25,630
その整数は、非常に特殊な存在
その整数ができるものに制限されます。

1285
01:00:25,630 --> 01:00:28,880
この例では、我々のアレイ
サイズ3のものである。

1286
01:00:28,880 --> 01:00:32,330
だから、その整数は何の数字をすることができます。

1287
01:00:32,330 --> 01:00:35,970
の有効な値の範囲は何ですか
その整数は、このコマンドの戻り値の型

1288
01:00:35,970 --> 01:00:37,220
関数をハッシュ？

1289
01:00:37,220 --> 01:00:40,440

1290
01:00:40,440 --> 01:00:42,110
ゼロ、1および2。

1291
01:00:42,110 --> 01:00:46,060
ハッシュ関数のポイントがある
配列内の場所を把握

1292
01:00:46,060 --> 01:00:47,790
ここで私たちのキーが起こっている。

1293
01:00:47,790 --> 01:00:51,290
唯一の3つの可能性があります。
ここの場所 - 

1294
01:00:51,290 --> 01:00:52,130
ゼロ、1、または2。

1295
01:00:52,130 --> 01:00:55,360
そのため、この機能は、より良いリターン
ゼロ、1、または2。

1296
01:00:55,360 --> 01:00:58,740
この配列内のいくつかの有効なindice。

1297
01:00:58,740 --> 01:01:02,770
>> そして、それが返す場所に応じて、
あなたが開いて、配列を確認することができます

1298
01:01:02,770 --> 01:01:03,730
値を一括。

1299
01:01:03,730 --> 01:01:05,800
我々は、キーを置く場所です。

1300
01:01:05,800 --> 01:01:11,280
だから我々は、カボチャを投げる、
我々はゼロを出す。

1301
01:01:11,280 --> 01:01:15,540
アレイ·ブラケット0で、我々はカボチャを置く。

1302
01:01:15,540 --> 01:01:21,070
我々は1を出す、猫を投げる。

1303
01:01:21,070 --> 01:01:24,110
我々は1で猫を置く。

1304
01:01:24,110 --> 01:01:25,480
私たちは、クモに置く。

1305
01:01:25,480 --> 01:01:26,710
我々は2つ​​を出す。

1306
01:01:26,710 --> 01:01:30,200
我々は、アレイブラケット2でクモを置く。

1307
01:01:30,200 --> 01:01:32,300
それは、もしそうであればいいだろう
それはそのように働いた。

1308
01:01:32,300 --> 01:01:35,570
残念ながら、我々は、表示されますように
それは少し複雑です。

1309
01:01:35,570 --> 01:01:37,570
>> 我々は、そこにどんな質問を受ける前に、
この基本について

1310
01:01:37,570 --> 01:01:38,820
ハッシュテーブルのセットアップ？

1311
01:01:38,820 --> 01:01:49,050

1312
01:01:49,050 --> 01:01:51,940
これはまさにのイメージです
我々は、ボード上で描いたものを。

1313
01:01:51,940 --> 01:01:55,420
しかし、我々は、ボード上のIそれを描いたので、
さらにそこに行くつもりはありません。

1314
01:01:55,420 --> 01:02:00,430
基本的にキー、魔法のブラックボックス - 
あるいはこの場合は、ティールボックス - の

1315
01:02:00,430 --> 01:02:02,410
ハッシュ関数は、バケットに格納します。

1316
01:02:02,410 --> 01:02:04,690
そしてこの例では、ね
ネーム入れはできません。

1317
01:02:04,690 --> 01:02:07,880
私たちは、関連付けられている携帯電話を入れている
バケット内の名前の数。

1318
01:02:07,880 --> 01:02:10,430
しかし、あなたは非常によくできただけで
バケツに名前を入れ。

1319
01:02:10,430 --> 01:02:12,950
>> これは何のちょうど写真です
我々は、ボード上で描きました。

1320
01:02:12,950 --> 01:02:14,460
我々は、しかし、潜在的な落とし穴があります。

1321
01:02:14,460 --> 01:02:17,470
そして二人は特にあり
私は上の行きたいことをスライドさせる。

1322
01:02:17,470 --> 01:02:20,230
最初の1程度である
ハッシュ関数。

1323
01:02:20,230 --> 01:02:22,620
だから私は、質問を何
良いハッシュ関数を作る？

1324
01:02:22,620 --> 01:02:24,220
私は2つの答えを与える。

1325
01:02:24,220 --> 01:02:26,630
最初は、それが決定論的であるということです。

1326
01:02:26,630 --> 01:02:29,660
ハッシュ関数の文脈において、
これは何を意味するのでしょうか？

1327
01:02:29,660 --> 01:02:37,840

1328
01:02:37,840 --> 01:02:39,282
はい？

1329
01:02:39,282 --> 01:02:42,850
>> 観客：それは見つけることができます
一定の時間内のインデックス？

1330
01:02:42,850 --> 01:02:43,810
>> JASONハーシュホーン：それ
それが何を意味するのかではありません。

1331
01:02:43,810 --> 01:02:44,725
しかし、それは良いの推測だ。

1332
01:02:44,725 --> 01:02:46,100
誰が推測してい
これが何を意味する？

1333
01:02:46,100 --> 01:02:47,780
その優れたハッシュ関数
決定論的である？

1334
01:02:47,780 --> 01:02:48,280
アニー？

1335
01:02:48,280 --> 01:02:51,680
>> 観客：キーのみをマッピングすることが可能であること。
ハッシュテーブル内の1位に。

1336
01:02:51,680 --> 01:02:53,070
>> JASONハーシュホーン：それです。
まったく正しい。

1337
01:02:53,070 --> 01:02:57,430
あなたは、カボチャを入れたびに、
それは常にゼロを返します。

1338
01:02:57,430 --> 01:03:01,660
あなたは、カボチャとあなたのハッシュに入れた場合
関数はゼロを返しますが、持って

1339
01:03:01,660 --> 01:03:06,060
何かを返す確率
ゼロより誰より - 

1340
01:03:06,060 --> 01:03:09,280
ので、多分それは時々1を返すことができます
または2他の回 - 

1341
01:03:09,280 --> 01:03:11,100
それは良いハッシュ関数ではありません。

1342
01:03:11,100 --> 01:03:11,800
あなたは正確に正しい。

1343
01:03:11,800 --> 01:03:15,680
あなたのハッシュ関数は、返す必要があります
この場合は、同じ正確な整数、用

1344
01:03:15,680 --> 01:03:17,780
まったく同じ文字列。

1345
01:03:17,780 --> 01:03:22,210
>> 多分それは、同じ正確な整数を返します。
まったく同じ文字列の

1346
01:03:22,210 --> 01:03:24,430
にかかわらず、時価総額の。

1347
01:03:24,430 --> 01:03:27,980
しかし、その場合、それはまだだ
確定的なので、複数の事

1348
01:03:27,980 --> 01:03:29,350
同じ値にマッピングされます。

1349
01:03:29,350 --> 01:03:30,170
それはいい。

1350
01:03:30,170 --> 01:03:32,615
限りつだけが存在するように
与えられた入力に対する出力。

1351
01:03:32,615 --> 01:03:35,630

1352
01:03:35,630 --> 01:03:36,350
>> [OK]をクリックします。

1353
01:03:36,350 --> 01:03:38,340
2つ目は、それ
有効なインデックスを返します。

1354
01:03:38,340 --> 01:03:40,220
我々は、以前育てた。

1355
01:03:40,220 --> 01:03:41,860
このハッシュ関数 - 

1356
01:03:41,860 --> 01:03:43,710
ああ - 

1357
01:03:43,710 --> 01:03:46,840
ハッシュ機能するはず
有効なインデックスを返す。

1358
01:03:46,840 --> 01:03:47,740
そう言う - 

1359
01:03:47,740 --> 01:03:48,990
のは、この例に戻りましょう。

1360
01:03:48,990 --> 01:03:52,580

1361
01:03:52,580 --> 01:03:57,540
私のハッシュ関数は、カウントアップ
単語の文字。

1362
01:03:57,540 --> 01:03:58,380
つまり、ハッシュ関数です。

1363
01:03:58,380 --> 01:03:59,740
そして、その整数を返します。

1364
01:03:59,740 --> 01:04:04,280
私は言葉のAを持っているのであれば、それはだ
1を返すつもり。

1365
01:04:04,280 --> 01:04:06,900
そしてそれは、ここで権利を置くために起こっている。

1366
01:04:06,900 --> 01:04:09,430
私は単語のバットに入れたら？

1367
01:04:09,430 --> 01:04:11,310
それは3を返すために起こっている。

1368
01:04:11,310 --> 01:04:12,560
バットはどこに行くのでしょうか？

1369
01:04:12,560 --> 01:04:18,730

1370
01:04:18,730 --> 01:04:19,750
>> それは適合しません。

1371
01:04:19,750 --> 01:04:21,000
しかし、それはどこかに行く必要がある。

1372
01:04:21,000 --> 01:04:23,340
これは結局、私のハッシュテーブルであり、
すべてがどこかに行く必要がある。

1373
01:04:23,340 --> 01:04:24,590
だからここでバットを行くべき？

1374
01:04:24,590 --> 01:04:28,020

1375
01:04:28,020 --> 01:04:28,710
任意の考え？

1376
01:04:28,710 --> 01:04:29,450
推測？

1377
01:04:29,450 --> 01:04:30,280
良い推測？

1378
01:04:30,280 --> 01:04:31,220
>> 観客：ゼロ。

1379
01:04:31,220 --> 01:04:32,120
>> JASONハーシュホーン：なぜゼロ？

1380
01:04:32,120 --> 01:04:35,990
>> 観客：3ので、
モジュロ3はゼロです？

1381
01:04:35,990 --> 01:04:38,620
>> JASONハーシュホーン：スリー
モジュロ3はゼロです。

1382
01:04:38,620 --> 01:04:40,810
それは素晴らしいの推測ですが、
それは正しいです。

1383
01:04:40,810 --> 01:04:43,870
したがって、このケースでは、べき
おそらくゼロに行く。

1384
01:04:43,870 --> 01:04:51,080
、このハッシュを確実にするので、良い方法
関数は、有効なインデックスを返している

1385
01:04:51,080 --> 01:04:54,580
テーブルのサイズによって、それを法である。

1386
01:04:54,580 --> 01:04:57,360
あなたはどのようなことで、この戻り値を法場合
3、あなたは常に取得するつもりだ

1387
01:04:57,360 --> 01:05:00,930
ゼロ、1、および2の間に何か。

1388
01:05:00,930 --> 01:05:05,160
そして、これは常に7を返し、あれば
あなたはいつもあなたがしている、3でモジュロ

1389
01:05:05,160 --> 01:05:06,030
いつも同じものを手に入れるつもり。

1390
01:05:06,030 --> 01:05:09,270
>> だから、まだ確定的だ
あなたは法とする場合。

1391
01:05:09,270 --> 01:05:11,420
しかし、それは、あなたことを保証します
何かを得ることはありません - 

1392
01:05:11,420 --> 01:05:12,940
無効な業界。

1393
01:05:12,940 --> 01:05:16,840
一般的に、モジュロが起こるべきであること
あなたのハッシュ関数の内部。

1394
01:05:16,840 --> 01:05:18,240
だから、このことを心配する必要はありません。

1395
01:05:18,240 --> 01:05:20,555
あなただけのことを確認することができます
これは有効なindiceです。

1396
01:05:20,555 --> 01:05:23,700

1397
01:05:23,700 --> 01:05:26,700
この上の任意の質問
潜在的な落とし穴？

1398
01:05:26,700 --> 01:05:36,590

1399
01:05:36,590 --> 01:05:39,060
>> [OK]をクリックします。

1400
01:05:39,060 --> 01:05:40,290
そしてそこに私達は行く。

1401
01:05:40,290 --> 01:05:42,890
次の潜在的な落とし穴、および
これは大きなものです。

1402
01:05:42,890 --> 01:05:46,880
どのような場合、2つのキーマップ
同じ値に？

1403
01:05:46,880 --> 01:05:49,350
だから、これを処理する2つの方法があります。

1404
01:05:49,350 --> 01:05:53,140

1405
01:05:53,140 --> 01:05:56,020
最初の1は、リニアと呼ばれている
私はこれ、プロービング

1406
01:05:56,020 --> 01:05:57,300
以上行くつもりはない。

1407
01:05:57,300 --> 01:06:01,120
しかし、あなたはどのように精通している必要があります
それが動作し、どのようなものがある。

1408
01:06:01,120 --> 01:06:05,610
>> 私は以上行くつもり秒1
それは多くの1であるため、

1409
01:06:05,610 --> 01:06:08,290
人々は、おそらく決定することになります
彼らの問題のセットで使用する。

1410
01:06:08,290 --> 01:06:09,820
もちろん、あなたがする必要はありません。

1411
01:06:09,820 --> 01:06:15,280
しかし、問題のセット、多くの人々のため
ハッシュテーブルを作成することを選択する傾向がある

1412
01:06:15,280 --> 01:06:17,950
実装するために別々の連鎖で
彼らの辞書。

1413
01:06:17,950 --> 01:06:21,390
だから我々はそれが何を意味するのか上に行くつもりだ
と、ハッシュテーブルを作成する

1414
01:06:21,390 --> 01:06:23,890
別々の連鎖。

1415
01:06:23,890 --> 01:06:26,260
>> だから私は、カボチャを入れ。

1416
01:06:26,260 --> 01:06:29,560
これは、0を返します。

1417
01:06:29,560 --> 01:06:31,410
そして、私はここにカボチャを置く。

1418
01:06:31,410 --> 01:06:35,880

1419
01:06:35,880 --> 01:06:37,930
それから私は、中に入れ - 

1420
01:06:37,930 --> 01:06:39,922
別のハロウィーンをテーマにした事は何ですか？

1421
01:06:39,922 --> 01:06:42,200
>> 観客：キャンディ。

1422
01:06:42,200 --> 01:06:42,770
>> JASONハーシュホーン：キャンディ！

1423
01:06:42,770 --> 01:06:43,910
それは素晴らしい1です。

1424
01:06:43,910 --> 01:06:47,760
私はキャンディー、キャンディーを入れ
また、私にはゼロになります。

1425
01:06:47,760 --> 01:06:49,350
私は何をしますか？

1426
01:06:49,350 --> 01:06:51,940
任意のアイデア？

1427
01:06:51,940 --> 01:06:53,940
あなたはすべての種類の知っているので、
どのような別々の連鎖である。

1428
01:06:53,940 --> 01:06:55,190
そのためにはどのような任意のアイデア？

1429
01:06:55,190 --> 01:06:58,170

1430
01:06:58,170 --> 01:06:59,110
うん。

1431
01:06:59,110 --> 01:07:03,810
>> 観客：文字列を置く
実際にハッシュテーブルに。

1432
01:07:03,810 --> 01:07:08,910
>> JASONハーシュホーン：だから我々はするつもりだ
こっち良いアイデアを描く。

1433
01:07:08,910 --> 01:07:09,340
[OK]をクリックします。

1434
01:07:09,340 --> 01:07:12,290
>> 観客：ハッシュテーブルを持っている
[聞こえない]

1435
01:07:12,290 --> 01:07:16,640
を指すポインタ
リストの先頭。

1436
01:07:16,640 --> 01:07:20,930
した後、カボチャは最初の値である必要な
そのリンクリストやキャンディーであること

1437
01:07:20,930 --> 01:07:22,800
そのリンクリストの2番目の値。

1438
01:07:22,800 --> 01:07:23,420
>> JASONハーシュホーン：わかりました。

1439
01:07:23,420 --> 01:07:24,670
傑出していたマーカス、。

1440
01:07:24,670 --> 01:07:26,160
私はそれを打破するつもりです。

1441
01:07:26,160 --> 01:07:28,890
マーカスはしないでくださいと言っている
カボチャが上書きされます。

1442
01:07:28,890 --> 01:07:30,660
それは悪いでしょう。

1443
01:07:30,660 --> 01:07:33,640
どこか別のお菓子を入れないでください。

1444
01:07:33,640 --> 01:07:35,390
我々はゼロでそれらの両方を置くつもりです。

1445
01:07:35,390 --> 01:07:37,770
しかし、我々は対処するつもりだ
ゼロでそれらを置くこと

1446
01:07:37,770 --> 01:07:39,395
ゼロからリストを作成する。

1447
01:07:39,395 --> 01:07:42,430
そして、我々はリストを作成しましょう
ゼロにマップされたすべてのもの。

1448
01:07:42,430 --> 01:07:47,960
そして、我々は作ることを学んだ最良の方法
成長し、縮小することができ、リスト

1449
01:07:47,960 --> 01:07:49,840
動的内にない
別の配列。

1450
01:07:49,840 --> 01:07:51,510
そうではない多次元配列。

1451
01:07:51,510 --> 01:07:54,080
しかし、単にリンクされたリストを作成します。

1452
01:07:54,080 --> 01:07:55,330
>> それでは、彼が提案した - 

1453
01:07:55,330 --> 01:07:57,950

1454
01:07:57,950 --> 01:07:59,200
私は新しいを取得するつもりだ - 

1455
01:07:59,200 --> 01:08:15,380

1456
01:08:15,380 --> 01:08:19,689
ポインタを持つ配列を作成することです、
ポインタの配列。

1457
01:08:19,689 --> 01:08:20,580
[OK]をクリックします。

1458
01:08:20,580 --> 01:08:24,180
どのようなタイプの任意のアイデアやヒント
このポインタでなければならない？

1459
01:08:24,180 --> 01:08:26,290
マーカス？

1460
01:08:26,290 --> 01:08:27,250
>> 観客：へのポインタ - 

1461
01:08:27,250 --> 01:08:28,609
>> JASONハーシュホーン：あなたので、
リンクリストは言ったので - 

1462
01:08:28,609 --> 01:08:29,520
>> 読者：ノードポインタ？

1463
01:08:29,520 --> 01:08:30,670
>> JASONハーシュホーン：ノードポインタ。

1464
01:08:30,670 --> 01:08:32,830
もし私たちのリンクにあるもの
リストそれらのノードである

1465
01:08:32,830 --> 01:08:34,370
ノードポインタでなければなりません。

1466
01:08:34,370 --> 01:08:35,939
そして、彼らは、最初は何を等しくしますか？

1467
01:08:35,939 --> 01:08:36,990
>> 観客：ヌル。

1468
01:08:36,990 --> 01:08:38,240
>> JASONハーシュホーン：ヌル。

1469
01:08:38,240 --> 01:08:44,540

1470
01:08:44,540 --> 01:08:46,080
だから私たちの空の事があります。

1471
01:08:46,080 --> 01:08:47,170
カボチャは、ゼロが返されます。

1472
01:08:47,170 --> 01:08:48,569
私たちは何をしますか？

1473
01:08:48,569 --> 01:08:49,609
それを通して、私を歩く？

1474
01:08:49,609 --> 01:08:50,810
実際に、マーカスは既に私を与えた。

1475
01:08:50,810 --> 01:08:52,439
他の誰かがそれを介して、私を歩く。

1476
01:08:52,439 --> 01:08:54,760
我々は何をすべきかときに我々 - 

1477
01:08:54,760 --> 01:08:56,609
これは非常によく似ています
我々だけで何をしていた。

1478
01:08:56,609 --> 01:08:57,396
AVI。

1479
01:08:57,396 --> 01:08:59,090
>> 読者：私は推測を取るつもりです。

1480
01:08:59,090 --> 01:09:01,250
だから、お菓子を取得するとき。

1481
01:09:01,250 --> 01:09:01,640
>> JASONハーシュホーン：うん。

1482
01:09:01,640 --> 01:09:03,120
まあ、我々は、カボチャを得た。

1483
01:09:03,120 --> 01:09:03,870
私たちの最初のものを取得してみましょう。

1484
01:09:03,870 --> 01:09:04,324
私たちは、カボチャを得た。

1485
01:09:04,324 --> 01:09:04,779
>> 観客：[OK]をクリックします。

1486
01:09:04,779 --> 01:09:05,880
カボチャは、ゼロが返されます。

1487
01:09:05,880 --> 01:09:08,770
だから、それに入れて。

1488
01:09:08,770 --> 01:09:10,810
または実際に、あなたがそれを置く
リンクされたリストの中。

1489
01:09:10,810 --> 01:09:13,550
>> JASONハーシュホーン：どのように我々は何
リンクされたリストに入れて？

1490
01:09:13,550 --> 01:09:15,479
>> 観客：ああ、実際の構文？

1491
01:09:15,479 --> 01:09:16,240
>> JASONハーシュホーン：ただ歩く - 

1492
01:09:16,240 --> 01:09:16,740
より多くを語る。

1493
01:09:16,740 --> 01:09:19,310
私たちは何をしますか？

1494
01:09:19,310 --> 01:09:22,100
>> 読者：あなただけの挿入
最初のノードとして。

1495
01:09:22,100 --> 01:09:22,675
>> JASONハーシュホーン：わかりました。

1496
01:09:22,675 --> 01:09:29,069
だから我々は我々のノード、カボチャを持っている。

1497
01:09:29,069 --> 01:09:31,560
そして今、どのようにそれを挿入しますか？

1498
01:09:31,560 --> 01:09:34,590

1499
01:09:34,590 --> 01:09:37,090
>> 観客：割り当てる
ポインタへのそれ。

1500
01:09:37,090 --> 01:09:37,970
>> JASONハーシュホーン：ポインタ？

1501
01:09:37,970 --> 01:09:39,620
>> 観客：ゼロにポインタ。

1502
01:09:39,620 --> 01:09:41,420
>> JASONハーシュホーン：だからここで
この点はいますか？

1503
01:09:41,420 --> 01:09:42,810
>> 観客：今NULLに。

1504
01:09:42,810 --> 01:09:43,529
>> JASONハーシュホーン：まあ、
それがnullを指しています。

1505
01:09:43,529 --> 01:09:44,499
しかし、私はかぼちゃに入れている。

1506
01:09:44,499 --> 01:09:46,053
だからここでそれが指している必要があります？

1507
01:09:46,053 --> 01:09:46,880
>> 観客：カボチャへ。

1508
01:09:46,880 --> 01:09:47,399
>> JASONハーシュホーン：カボチャへ。

1509
01:09:47,399 --> 01:09:48,760
その通りです。

1510
01:09:48,760 --> 01:09:50,010
だから、これはカボチャを指しています。

1511
01:09:50,010 --> 01:09:52,500

1512
01:09:52,500 --> 01:09:54,250
どここのポインタはない
カボチャ点？

1513
01:09:54,250 --> 01:09:57,986

1514
01:09:57,986 --> 01:09:58,340
へ

1515
01:09:58,340 --> 01:09:58,590
>> 観客：ヌル。

1516
01:09:58,590 --> 01:09:59,210
>> JASONハーシュホーン：nullに。

1517
01:09:59,210 --> 01:10:00,460
その通りです。

1518
01:10:00,460 --> 01:10:03,570

1519
01:10:03,570 --> 01:10:05,140
だから我々は、単に何かを挿入
リンクされたリストに変換する。

1520
01:10:05,140 --> 01:10:07,210
我々だけでこれを行うには、このコードを書いた。

1521
01:10:07,210 --> 01:10:09,520
ほとんど我々はほとんどそれを得た
完全に割れた。

1522
01:10:09,520 --> 01:10:10,790
今、私たちはお菓子を挿入します。

1523
01:10:10,790 --> 01:10:13,480
私たちのキャンディーもゼロになる。

1524
01:10:13,480 --> 01:10:16,100
だから我々は、キャンディで何をしますか？

1525
01:10:16,100 --> 01:10:18,790
>> 観客：それはどうかに依存します
我々はそれを並べ替えしようとしていない。

1526
01:10:18,790 --> 01:10:19,640
>> JASONハーシュホーン：それです。
まったく正しい。

1527
01:10:19,640 --> 01:10:21,070
か否かに依存する
我々はそれを並べ替えしようとしている。

1528
01:10:21,070 --> 01:10:22,660
のは、我々はわからないとしましょう
それをソートするために行く。

1529
01:10:22,660 --> 01:10:24,880
>> 観客：それでは、私たちが説明したように
以前は、それだけでそれを置くのが最も簡単です

1530
01:10:24,880 --> 01:10:28,590
右ポインタので、先頭に
ゼロポイントからキャンディへ。

1531
01:10:28,590 --> 01:10:29,020
>> JASONハーシュホーン：わかりました。

1532
01:10:29,020 --> 01:10:29,380
少々お待ちください。

1533
01:10:29,380 --> 01:10:30,630
私はここお菓子を作ってみましょう。

1534
01:10:30,630 --> 01:10:34,030

1535
01:10:34,030 --> 01:10:35,150
そのため、このポインター - 

1536
01:10:35,150 --> 01:10:37,590
>> 観客：ええ、今すべき
キャンディーを指している。

1537
01:10:37,590 --> 01:10:40,580
その後のポインタを持っている
カボチャのお菓子のポイント。

1538
01:10:40,580 --> 01:10:43,140

1539
01:10:43,140 --> 01:10:44,560
>> JASONハーシュホーン：そのような？

1540
01:10:44,560 --> 01:10:47,380
そして、我々は別のものを得たと言う
ゼロにマップすることは？

1541
01:10:47,380 --> 01:10:48,660
>> 観客：さて、あなただけの
同じことをする？

1542
01:10:48,660 --> 01:10:50,290
>> JASONハーシュホーン：同じことを行う。

1543
01:10:50,290 --> 01:10:53,700
したがって、このケースでは、ない場合は
それは、それを並べ替えておきたい

1544
01:10:53,700 --> 01:10:55,270
むしろ簡単に聞こえる。

1545
01:10:55,270 --> 01:10:59,920
我々はindice内のポインタを取る
我々のハッシュ関数によって与えられる。

1546
01:10:59,920 --> 01:11:03,830
私たちは、新しいノードにそのポイントを持っている。

1547
01:11:03,830 --> 01:11:07,830
そして、それが指していたどのような
以前まで - 

1548
01:11:07,830 --> 01:11:10,620
この場合はNULLを、中
第二ケースカボチャ - 

1549
01:11:10,620 --> 01:11:15,310
それが指しているものは何でも、その
以前、我々は次のに追加

1550
01:11:15,310 --> 01:11:17,810
私たちの新しいノード。

1551
01:11:17,810 --> 01:11:19,650
私たちは、何かを挿入している
初めに。

1552
01:11:19,650 --> 01:11:22,900
実際にはこれよりもずっと簡単です。
ソートされたリストを維持しようとしています。

1553
01:11:22,900 --> 01:11:25,340
しかし、再び、検索はなり
もっとここに複雑。

1554
01:11:25,340 --> 01:11:28,300
我々は常に末尾に移動する必要があります。

1555
01:11:28,300 --> 01:11:29,650
>> [OK]をクリックします。

1556
01:11:29,650 --> 01:11:32,750
別々の連鎖についてのご質問？

1557
01:11:32,750 --> 01:11:34,690
どのようにそれが動作します？

1558
01:11:34,690 --> 01:11:35,820
ここでそれらを依頼してください。

1559
01:11:35,820 --> 01:11:39,260
私は実際に確認し、すべてのようにしたい
我々は出掛ける前にこれを理解しています。

1560
01:11:39,260 --> 01:11:48,410

1561
01:11:48,410 --> 01:11:52,060
>> 観客：なぜあなたは、カボチャを入れない
と同じにキャンディー

1562
01:11:52,060 --> 01:11:54,108
ハッシュテーブルの一部？

1563
01:11:54,108 --> 01:11:55,860
>> JASONハーシュホーン：良い質問。

1564
01:11:55,860 --> 01:11:59,140
なぜ我々は同じに入れない
ハッシュテーブルの一部？

1565
01:11:59,140 --> 01:12:03,200
さて、この場合の当社のハッシュ関数
リターンはそれらの両方のためのゼロ。

1566
01:12:03,200 --> 01:12:05,310
そこで、彼らはindiceゼロに行く必要がある
我々はするつもりだところですので、

1567
01:12:05,310 --> 01:12:07,420
彼らのために見てみると、我々今までに
それらを見てみたい。

1568
01:12:07,420 --> 01:12:11,750
再び、リニアプロービング手法に
我々はゼロからそれらの両方を入れないでしょう。

1569
01:12:11,750 --> 01:12:13,900
しかし、別々の連鎖アプローチでは、
我々はゼロでそれらの両方を置くつもりだ

1570
01:12:13,900 --> 01:12:16,620
そして、ゼロのオフリストを作成します。

1571
01:12:16,620 --> 01:12:20,140
>> そして、我々はカボチャを上書きしたくない
単にそのため、我々はだろうから

1572
01:12:20,140 --> 01:12:21,860
カボチャであったことを前提とし
挿入されたことはありません。

1573
01:12:21,860 --> 01:12:25,230
私達はちょうどで一つのことを続けると
悪いことする場所。

1574
01:12:25,230 --> 01:12:28,590
[いいえがあるだろう
今まで私たちの可能性 - 

1575
01:12:28,590 --> 01:12:31,660
私たちが今まで重複していたなら、私たち
ちょうど私たちの初期値を消すだろう。

1576
01:12:31,660 --> 01:12:34,090
我々はこのアプローチをなぜだからです。

1577
01:12:34,090 --> 01:12:36,580
またはそれは我々が選んだ理由だ - しかし、繰り返しますが、私たち
別々の連鎖的なアプローチを選択しました、

1578
01:12:36,580 --> 01:12:39,670
これは多くの他のアプローチがあります
1が選択できます。

1579
01:12:39,670 --> 01:12:41,185
それがあなたの質問に答えるのでしょうか？

1580
01:12:41,185 --> 01:12:41,660
>> [OK]をクリックします。

1581
01:12:41,660 --> 01:12:42,910
カルロス。

1582
01:12:42,910 --> 01:12:46,130

1583
01:12:46,130 --> 01:12:47,720
リニアプロービングが伴うだろう - 

1584
01:12:47,720 --> 01:12:51,913
我々はゼロからの衝突を発見した場合、我々は
かどうかを確認するために次のスポットになります

1585
01:12:51,913 --> 01:12:54,310
それが開いていたし、そこにそれを置く。

1586
01:12:54,310 --> 01:12:57,320
そして、我々は次のスポーツで見て、
それが開いていたかどうかを確認し、そこにそれを置く。

1587
01:12:57,320 --> 01:12:59,780
だから我々は、次の利用可能なを見つける。
オープンスポットとそこに置く。

1588
01:12:59,780 --> 01:13:02,580

1589
01:13:02,580 --> 01:13:03,890
その他のご質問は？

1590
01:13:03,890 --> 01:13:05,370
AVI、うん。

1591
01:13:05,370 --> 01:13:07,490
>> 観客：それのフォローアップとして、
あなたは次のスポットとはどういう意味ですか？

1592
01:13:07,490 --> 01:13:10,250
ハッシュテーブル内またはリンクされたリストにある。

1593
01:13:10,250 --> 01:13:12,100
>> JASONハーシュホーン：リニア
プログラミングなしリンクされたリスト。

1594
01:13:12,100 --> 01:13:13,400
ハッシュテーブルの上に次のスポット。

1595
01:13:13,400 --> 01:13:13,820
>> 観客：[OK]をクリックします。

1596
01:13:13,820 --> 01:13:17,570
だから、ハッシュテーブルは次のようになります。
サイズに初期化 - 

1597
01:13:17,570 --> 01:13:19,560
文字列の数のように
あなたが挿入されたこと？

1598
01:13:19,560 --> 01:13:22,170
>> JASONハーシュホーン：あなたでしょう
それは本当に大きなことをしたい。

1599
01:13:22,170 --> 01:13:23,910
はい。

1600
01:13:23,910 --> 01:13:27,900
ここに私たちの写真です
ただボードに描きました。

1601
01:13:27,900 --> 01:13:29,470
繰り返しますが、私たちはここの衝突を持っている。

1602
01:13:29,470 --> 01:13:30,710
152で。

1603
01:13:30,710 --> 01:13:33,570
そして、あなたは私たちが作成した表示されます
それをオフにリンクされたリスト。

1604
01:13:33,570 --> 01:13:38,200

1605
01:13:38,200 --> 01:13:41,850
ここでも、ハッシュテーブルの別々の連鎖
アプローチは、1あなたではありません

1606
01:13:41,850 --> 01:13:45,590
設定の問題のために取らなければならない
6しかし、一つであることが多く

1607
01:13:45,590 --> 01:13:47,100
学生が取る傾向があります。

1608
01:13:47,100 --> 01:13:51,140
だから、そのノートに、私たちは簡単に説明しましょう
私たちは、問題6について出掛ける前に、

1609
01:13:51,140 --> 01:13:52,160
そして私はあなたと話を共有します。

1610
01:13:52,160 --> 01:13:55,120
私たちは、3分している。

1611
01:13:55,120 --> 01:13:55,750
>> 問題は、6を設定します。

1612
01:13:55,750 --> 01:13:57,790
あなたは、4つの機能を持っている - 

1613
01:13:57,790 --> 01:14:02,430
負荷、サイズを確認し、アンロードします。

1614
01:14:02,430 --> 01:14:03,380
負荷 - 

1615
01:14:03,380 --> 01:14:07,120
さて、私たちは続けられてきた
過負荷ちょうど今。

1616
01:14:07,120 --> 01:14:09,330
我々は、ボード上の負荷を描きました。

1617
01:14:09,330 --> 01:14:13,230
そして私たちも、多くのコーディング開始
リンクされたリストに挿入。

1618
01:14:13,230 --> 01:14:18,020
だから、負荷がよりもはるかに多くはありません
我々だけで何をしてきた。

1619
01:14:18,020 --> 01:14:21,070
>> あなたがしたらチェックがある
何かがロードされた。

1620
01:14:21,070 --> 01:14:22,580
それは、これと同じプロセスです。

1621
01:14:22,580 --> 01:14:26,845
あなたが投げる同じ第2の部分
ハッシュ関数に何か

1622
01:14:26,845 --> 01:14:29,190
し、その値を取得します。

1623
01:14:29,190 --> 01:14:30,700
しかし、今我々はそれを挿入していない。

1624
01:14:30,700 --> 01:14:33,350
今、我々はそれを探しています。

1625
01:14:33,350 --> 01:14:37,130
私は見つけることのために書かれたサンプルコードを持っている
リンクされたリストの中で何か。

1626
01:14:37,130 --> 01:14:38,250
私はそれを実践することをお勧めします。

1627
01:14:38,250 --> 01:14:43,000
しかし、直感的に何かをされている発見
何かを挿入するにはかなり似ています。

1628
01:14:43,000 --> 01:14:46,540
確かに、我々は見つけることの絵を描いた
リンクされたリストの中で何か、移動

1629
01:14:46,540 --> 01:14:48,910
あなたが最後に到着するまでを通して。

1630
01:14:48,910 --> 01:14:52,430
そして、あなたが最後になったし、できなかった場合
それを見つける、それはそこではありません。

1631
01:14:52,430 --> 01:14:55,400
だから、基本的には、チェックだ。

1632
01:14:55,400 --> 01:14:57,030
>> 次のサイズです。

1633
01:14:57,030 --> 01:14:57,910
のサイズを飛ばしてみましょう。

1634
01:14:57,910 --> 01:15:00,040
最後に、アンロードしています。

1635
01:15:00,040 --> 01:15:02,890
アンは、我々が描かれていないものです
ボード上のか、まだコード化された。

1636
01:15:02,890 --> 01:15:05,990
しかし、私はそれをコーディングしようとすることをお勧めします
このサンプルリンクリストの例では。

1637
01:15:05,990 --> 01:15:11,440
しかし、直感的にアンロードする
自由に似ています - 

1638
01:15:11,440 --> 01:15:14,010
または私は意味チェックすることと似ています。

1639
01:15:14,010 --> 01:15:17,350
あなたが行っている現在、その都度除い
を通して、あなたは単にチェックしていない

1640
01:15:17,350 --> 01:15:19,090
あなたがそこにあなたの価値を持っているかどうかを確認します。

1641
01:15:19,090 --> 01:15:22,490
しかし、あなたは、そのノードを取っているし、
基本的に、それを解放する。

1642
01:15:22,490 --> 01:15:23,610
それはあなたが何を要求し、アンロードものだ。

1643
01:15:23,610 --> 01:15:24,670
あなたはmallocさだ無料すべて。

1644
01:15:24,670 --> 01:15:27,480
だから、全体のリストを行っている
もう一度、全体のハッシュを経由

1645
01:15:27,480 --> 01:15:27,760
テーブルを再び。

1646
01:15:27,760 --> 01:15:29,240
今回はチェックしません。
そこにあるものを確認します。

1647
01:15:29,240 --> 01:15:31,080
ただそこにあるものを解放。

1648
01:15:31,080 --> 01:15:33,260
>> そして最後にサイズ。

1649
01:15:33,260 --> 01:15:34,350
サイズは、実装する必要があります。

1650
01:15:34,350 --> 01:15:35,590
あなたのサイズを実装しない場合 - 

1651
01:15:35,590 --> 01:15:36,250
私はこのようにそれを言うよ。

1652
01:15:36,250 --> 01:15:39,740
あなたは正確にサイズを実装しない場合
を含む1行のコード

1653
01:15:39,740 --> 01:15:43,760
文を返し、あなたは
間違ってサイズをしている。

1654
01:15:43,760 --> 01:15:47,170
だから、完全な設計のために、必ずサイズを確認
ポイントは、あなたが正確に1でそれをやっている

1655
01:15:47,170 --> 01:15:49,970
を含むコード行、
return文。

1656
01:15:49,970 --> 01:15:52,450
>> そして、まだAkcharを荷造りしないでください。

1657
01:15:52,450 --> 01:15:53,700
イーガービーバー。

1658
01:15:53,700 --> 01:15:55,820

1659
01:15:55,820 --> 01:16:01,300
私はあなたたちに感謝言いたかった
セクションに来るため。

1660
01:16:01,300 --> 01:16:02,550
ハッピーハロウィンを持っています。

1661
01:16:02,550 --> 01:16:05,300

1662
01:16:05,300 --> 01:16:05,960
これは私の衣装です。

1663
01:16:05,960 --> 01:16:08,850
私は木曜日に、これを身に着けていることでしょう
私が営業時間でお会いします。

1664
01:16:08,850 --> 01:16:14,640
そして、あなたはいくつかの詳細について興味があれば
この衣装、感触などのバックグラウンド

1665
01:16:14,640 --> 01:16:19,135
2011セクションをチェックアウトして自由
私は理由の物語のための

1666
01:16:19,135 --> 01:16:20,900
カボチャの衣装を身に着けている。

1667
01:16:20,900 --> 01:16:23,680
そして、それは悲しい物語です。

1668
01:16:23,680 --> 01:16:27,050
ですから、持っていることを確認してください
近くのいくつかの組織。

1669
01:16:27,050 --> 01:16:28,680
しかし、それでは、いずれかを持っている場合
私は固執よ質問

1670
01:16:28,680 --> 01:16:29,960
外側のセクションの後。

1671
01:16:29,960 --> 01:16:31,510
幸運は、問題に6を設定します。

1672
01:16:31,510 --> 01:16:33,540
そしていつものように、あなたがいずれかを持っている場合
質問、私に知らせてください。

1673
01:16:33,540 --> 01:16:35,584