1
00:00:00,000 --> 00:00:02,210
[Powered by Google Translate] [チュートリアル - 問題セット6]

2
00:00:02,210 --> 00:00:04,810
[Zamylaチャン - ハーバード大学]

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

4
00:00:07,240 --> 00:00:12,180
>> みなさん、こんにちは、そしてチュートリアル6へようこそ：Huff'nパフを。

5
00:00:12,180 --> 00:00:17,440
Huff'nパフでは我々がやっていることは、ハフマン圧縮ファイルを扱うことになるだろう

6
00:00:17,440 --> 00:00:20,740
その後、バックアップしてそれを吹かしので、それを解凍する

7
00:00:20,740 --> 00:00:25,810
ので、我々は、ユーザーが問い合わせを送信することを、0と1から翻訳できること

8
00:00:25,810 --> 00:00:30,660
と元のテキストに戻すように変換。

9
00:00:30,660 --> 00:00:34,360
PSET 6では、ツールのいくつかを見ることになるので、かなりクールになるだろう

10
00:00:34,360 --> 00:00:41,730
あなたは、pset 4とPSET 5と1はかなりきちんとしたコンセプトにそれらを組み合わせるの種​​類で使用されている

11
00:00:41,730 --> 00:00:43,830
あなたがそれについて考えるようになったとき。

12
00:00:43,830 --> 00:00:50,110
>> また、間違いなく、psetの4と5は、我々が提供しなければならなかった最も困難なのpsetであった。

13
00:00:50,110 --> 00:00:53,950
だから今から、我々は、C言語では、この他に1 psetを持っている

14
00:00:53,950 --> 00:00:56,480
して、その後に我々は、Webプログラミングににしている。

15
00:00:56,480 --> 00:01:02,310
だからCS50の中で最も過酷なこぶを乗り越えるために自分自身を祝福します。

16
00:01:03,630 --> 00:01:09,760
>> Huff'nパフのために動いて、このpsetの私たちのツールボックスには、ハフマン木になるだろうしている

17
00:01:09,760 --> 00:01:14,700
そう理解するだけでなく、どのようにバイナリツリーの仕事だけでなく、具体的にハフマン木、

18
00:01:14,700 --> 00:01:16,240
どのように彼らが構築している。

19
00:01:16,240 --> 00:01:20,210
そして、我々は、このpset内分布のコードの多くを持っているつもりです

20
00:01:20,210 --> 00:01:22,480
そして我々はいくつかのコードを実際に見に来てよ

21
00:01:22,480 --> 00:01:24,670
我々は、まだ完全には理解できないかもしれません

22
00:01:24,670 --> 00:01:30,080
そしてそうそれらがcファイルが、その後、それに付随する。hファイルになります

23
00:01:30,080 --> 00:01:34,300
私たちは、我々はそれらの機能がどのように動作するかを知っているので、必要とする十分な理解を与える

24
00:01:34,300 --> 00:01:38,100
または少なくとも何彼らが行うことになっている - それらの入力と出力 - 

25
00:01:38,100 --> 00:01:40,760
我々はブラックボックスで何が起こっているかわからない場合でも

26
00:01:40,760 --> 00:01:44,090
またはブラックボックス内で何が起こっている理解していない。

27
00:01:44,090 --> 00:01:49,400
そして最後に、いつものように、我々は、新しいデータ構造を扱っている

28
00:01:49,400 --> 00:01:51,840
そのノードの特定の種類は、特定のものを指す

29
00:01:51,840 --> 00:01:56,080
ので、ここでは設計プロセスのためだけでなく、紙とペンを持って

30
00:01:56,080 --> 00:01:58,470
そして、あなたのpsetがどのように働くべきか把握しようとしているとき

31
00:01:58,470 --> 00:02:00,520
だけでなく、デバッグ中に。

32
00:02:00,520 --> 00:02:06,140
あなたは値が何であるかをテイクダウンしながら、あなたのペンと紙と並んでGDBを持つことができます

33
00:02:06,140 --> 00:02:09,320
どこにあなたの矢印が指している、とそのようなことされています。

34
00:02:09,320 --> 00:02:13,720
>> 最初のハフマン木を見てみましょう。

35
00:02:13,720 --> 00:02:19,600
ハフマン木は各ノードが唯一の2人の子供を持っていることを意味し、バイナリツリーです。

36
00:02:19,600 --> 00:02:24,870
ハフマン木に特徴は、最も頻度の高い値

37
00:02:24,870 --> 00:02:27,140
最少ビットで表されます。

38
00:02:27,140 --> 00:02:32,690
我々は、モールス信号の講義の例、連結の種類いくつかの文字を見ました。

39
00:02:32,690 --> 00:02:38,030
あなたは、例えば、AまたはEを翻訳しようとしている場合、

40
00:02:38,030 --> 00:02:43,940
あなたは、その頻繁に翻訳しているので、代わりにビットのフルセットを使用する必要が

41
00:02:43,940 --> 00:02:48,640
その通常のデータ型のために割り当てられた、あなたは、より少ないにそれを圧縮する

42
00:02:48,640 --> 00:02:53,730
その後あまり頻繁に表現されるそれらの手紙は長いビットで表現さ

43
00:02:53,730 --> 00:02:59,840
あなたはそれらの文字が表示されていることを周波数成分を量るときはそれを買う余裕ができるからです。

44
00:02:59,840 --> 00:03:03,020
我々は、ハフマン木にここに同じアイデアを持っている

45
00:03:03,020 --> 00:03:12,360
ここで我々は、チェーン、特定の文字を取得するパスの種類を作っている。

46
00:03:12,360 --> 00:03:14,470
そして、ほとんどの周波数を持つ文字

47
00:03:14,470 --> 00:03:17,940
少ないビットで表現しようとしている。

48
00:03:17,940 --> 00:03:22,020
>> あなたがハフマン木を構築する方法

49
00:03:22,020 --> 00:03:27,430
テキストで表示されたすべての文字を配置することです

50
00:03:27,430 --> 00:03:30,630
とその頻度を計算し、どのくらいの頻度でそれらが表示されます。

51
00:03:30,630 --> 00:03:33,880
これは、いずれかのこれらの文字が表示された回数をカウントすることができる

52
00:03:33,880 --> 00:03:40,270
または多分各1が表示されますどのように多くのすべての文字のうちの割合。

53
00:03:40,270 --> 00:03:44,270
それで、何をやっていることは、一度そのマップされたうちのすべてを持っていることです

54
00:03:44,270 --> 00:03:49,060
その後、あなたは2低い周波数を探して、その後に兄弟としてそれらを結合

55
00:03:49,060 --> 00:03:55,660
どこで、親ノードは、その2人の子供との和である周波数を持っています。

56
00:03:55,660 --> 00:04:00,870
そして、慣例によりあなたは、その左ノード言う

57
00:04:00,870 --> 00:04:03,770
あなたは、0枝に従うことによってそれをフォロー

58
00:04:03,770 --> 00:04:08,140
その後右端のノードが1ブランチです。

59
00:04:08,140 --> 00:04:16,040
我々はモールス信号で見たように、一つの落とし穴は、あなただけのビープ音とビープ音があったらということでした

60
00:04:16,040 --> 00:04:18,120
それがあいまいでした。

61
00:04:18,120 --> 00:04:22,430
これは、いずれかの1文字であるか、2文字のシーケンスである可能性があります。

62
00:04:22,430 --> 00:04:27,790
それで何ハフマン木が行うことは、文字の性質からです

63
00:04:27,790 --> 00:04:34,140
または私達の最終的な実際の文字のブランチの最後のノードである - 

64
00:04:34,140 --> 00:04:39,300
我々は葉としてそれらを参照してください - のおかげで、あいまいさがあるはずがありません

65
00:04:39,300 --> 00:04:45,160
あなたは一連のビットでエンコードしようとしている手紙の面で

66
00:04:45,160 --> 00:04:50,670
なぜなら1文字を表すビットに沿ってどこにも

67
00:04:50,670 --> 00:04:55,960
あなたは別の全体の文字に遭遇するでしょうし、そこに混乱がないでしょう。

68
00:04:55,960 --> 00:04:58,430
しかし、我々はあなたたちが実際にそれを見ることができることの例に行くよ

69
00:04:58,430 --> 00:05:02,120
代わりに我々は、ちょうどそれが本当だということを伝える。

70
00:05:02,120 --> 00:05:06,390
>> ハフマンツリーの簡単な例を見てみましょう。

71
00:05:06,390 --> 00:05:09,380
私は12文字の長さでここに文字列を持っている。

72
00:05:09,380 --> 00:05:14,010
私は6位、そして2 CSとして、4を持っています。

73
00:05:14,010 --> 00:05:17,270
私の最初のステップは、カウントすることであろう。

74
00:05:17,270 --> 00:05:20,760
何回表示されますか？これは、文字列に4回表示されます。

75
00:05:20,760 --> 00:05:25,060
Bは6回表示され、Cが2回表示されます。

76
00:05:25,060 --> 00:05:28,970
当然のことながら、私は私が最も頻繁にBを使用していると言うつもりです、

77
00:05:28,970 --> 00:05:35,970
ので、私はビット数が最も少ない、0と1の数が最も少ないBを表現したい。

78
00:05:35,970 --> 00:05:42,600
そして私はまた、Cも同様に0と1のほとんどの量を必要とすることを期待したいと思います。

79
00:05:42,600 --> 00:05:48,550
最初に私がここで何をしたか私は、周波数の面で昇順に配置されます。

80
00:05:48,550 --> 00:05:52,710
我々は、Cと見、それらは私たちの2最低の周波数である。

81
00:05:52,710 --> 00:06:00,290
我々は、親ノードを作成し、その親ノードは、それに関連付けられた手紙を持っていません

82
00:06:00,290 --> 00:06:05,070
それは和の周波数を、持っていません。

83
00:06:05,070 --> 00:06:08,780
和が6である2 + 4となります。

84
00:06:08,780 --> 00:06:10,800
その後、我々は左の枝に従ってください。

85
00:06:10,800 --> 00:06:14,970
我々は6ノードであった場合、我々は、Cに到達するために0に従うだろう

86
00:06:14,970 --> 00:06:17,450
Aに取得した後、1

87
00:06:17,450 --> 00:06:20,300
だから今我々は2つ​​のノードを持っています。

88
00:06:20,300 --> 00:06:23,920
我々は、値6を持っているし、我々はまた、値6を持つ別のノードを持っています。

89
00:06:23,920 --> 00:06:28,550
それで、それらの2が最低の2も残っているわずか2だけではなく、アール

90
00:06:28,550 --> 00:06:33,820
従って私達は合計が12であることと、別の親がそれらを結合します。

91
00:06:33,820 --> 00:06:36,300
そこでここでは、私たちのハフマンツリーを持っている

92
00:06:36,300 --> 00:06:40,020
Bに取得する場合には、それは少しだけ1になります

93
00:06:40,020 --> 00:06:45,430
それから私達は01を持っているし、00を有するCになるために。

94
00:06:45,430 --> 00:06:51,300
そこでここでは、基本的に我々は1または2ビットのいずれかで、これらの文字を表現していることがわかり

95
00:06:51,300 --> 00:06:55,160
ここで、Bは、予測したように、少なくともを持っています。

96
00:06:55,160 --> 00:07:01,730
その後、我々は、Cはほとんど持っていると予想していたが、それはそのような小さなハフマンツリーなので

97
00:07:01,730 --> 00:07:06,020
その後もどこか途中でするのではなく、2ビットで表される。

98
00:07:07,820 --> 00:07:11,070
>> ちょうどハフマンツリーの別の単純な例を越えるためには、

99
00:07:11,070 --> 00:07:19,570
あなたは文字列を持っていると言う "こんにちは。"

100
00:07:19,570 --> 00:07:25,360
あなたは何をすることで、Hはこれで何回表示されるんだと思います第一ですか？

101
00:07:25,360 --> 00:07:34,200
Hは一回とし、eが表示されたら、それから私達は2回表示されるlを持っている

102
00:07:34,200 --> 00:07:36,580
そしてoは一度現れる。

103
00:07:36,580 --> 00:07:44,310
それで、我々は少なくともビット数で表すことがどの文字期待？

104
00:07:44,310 --> 00:07:47,450
[学生]リットル。 >>のl。 Yeah。 lは右です。

105
00:07:47,450 --> 00:07:50,730
我々は、lがビットのうちの数で表されることを期待する

106
00:07:50,730 --> 00:07:55,890
lは "こんにちは"という文字列の中で最も使用されているため、

107
00:07:55,890 --> 00:08:04,280
私は今やろうとしているもの、これらのノードを引き出しています。

108
00:08:04,280 --> 00:08:15,580
私はHである、1を持っているし、oである別の電子が1であり、した後、1、 - 

109
00:08:15,580 --> 00:08:23,410
リットルであるし、2  - 右今私は順序でそれらを入れている。

110
00:08:23,410 --> 00:08:32,799
その後、私は、ハフマン木を構築する方法は、少なくとも周波数で2つのノードを見つけることであると言う

111
00:08:32,799 --> 00:08:38,010
と親ノードを作成することによって、それらの兄弟作る。

112
00:08:38,010 --> 00:08:41,850
ここでは、最も低い周波数を持つ3つのノードを持っています。彼らはすべての1だ。

113
00:08:41,850 --> 00:08:50,620
そこでここでは、我々が最初にリンクしようとしているのかを選択する。

114
00:08:50,620 --> 00:08:54,850
Let 'sは、私はHとeを選ぶと言う。

115
00:08:54,850 --> 00:09:01,150
1の合計+ 1は2ですが、このノードは、それに関連付けられた手紙を持っていません。

116
00:09:01,150 --> 00:09:04,440
それだけで値を保持します。

117
00:09:04,440 --> 00:09:10,950
今、私たちは、次の2最も低い周波数を見てみましょう。

118
00:09:10,950 --> 00:09:15,590
それは2と1です。それはどちらかそれらの2のかもしれないが、私はこのいずれかを選択するつもりです。

119
00:09:15,590 --> 00:09:18,800
和は3です。

120
00:09:18,800 --> 00:09:26,410
そして最後に、私は唯一の5になるようにしてから、左の2を持っています。

121
00:09:26,410 --> 00:09:32,010
その後、ここで、予想通り、私はそのための符号を記入した場合、

122
00:09:32,010 --> 00:09:37,480
1S常に右枝と0は左1アールアール。

123
00:09:37,480 --> 00:09:45,880
その後、我々は2でちょうど1ビットし、oで表さリットルを持っている

124
00:09:45,880 --> 00:09:52,360
その後2によるe、その後Hは3ビットに落ちる。

125
00:09:52,360 --> 00:09:59,750
だからあなたは、 "Hello"このメッセージを送信することができる代わりに、実際に文字を使用して

126
00:09:59,750 --> 00:10:02,760
ちょうど0と1によって。

127
00:10:02,760 --> 00:10:07,910
しかし、いくつかのケースで我々は周波数との関係を持っていたことを覚えています。

128
00:10:07,910 --> 00:10:11,900
我々は、いずれか多分最初のHとOに参加している可能性があります。

129
00:10:11,900 --> 00:10:15,730
またはその後、我々は2で表さリットルを持っていたときに

130
00:10:15,730 --> 00:10:19,410
同様に（2）で表される1に参加しました、我々は、いずれかリンクされている可能性があります。

131
00:10:19,410 --> 00:10:23,630
>> それで、あなたは、0と1を送るとき、それは実際に保証するものではありません

132
00:10:23,630 --> 00:10:27,090
受信者は、完全に右バットを離れてあなたのメッセージを読み取ることができることを

133
00:10:27,090 --> 00:10:30,490
彼らはあなたが作られた意思決定を知らないかもしれないので。

134
00:10:30,490 --> 00:10:34,920
だから我々はハフマン圧縮を扱っているときに、

135
00:10:34,920 --> 00:10:40,090
何とか我々は我々が決めたどのように我々のメッセージの受信者に指示する必要があります - 

136
00:10:40,090 --> 00:10:43,470
彼らは余分な情報のいくつかの種類を知っておく必要があります

137
00:10:43,470 --> 00:10:46,580
圧縮されたメッセージに加えて。

138
00:10:46,580 --> 00:10:51,490
彼らは、木が実際にどのように見えるかを理解する必要があります

139
00:10:51,490 --> 00:10:55,450
私たちは実際にそれらの決定をどのように作った。

140
00:10:55,450 --> 00:10:59,100
>> ここでは、単に実際のカウントに基づいた例をやっていた、

141
00:10:59,100 --> 00:11:01,550
時にはあなたもハフマンツリーを持つことができます

142
00:11:01,550 --> 00:11:05,760
文字が表示される頻度に基づいて、それはまったく同じプロセスだ。

143
00:11:05,760 --> 00:11:09,090
ここで私は、パーセンテージまたは分数の面でそれを表現しています

144
00:11:09,090 --> 00:11:11,290
ので、ここでは全く同じもの。

145
00:11:11,290 --> 00:11:15,300
私は、それらを合計して、最低2週間、それらを合計し、2最低を見つける

146
00:11:15,300 --> 00:11:19,390
私は完全なツリーを持つまで。

147
00:11:19,390 --> 00:11:23,610
我々はそれを我々が扱っている割合はどちらの方法でも、何ができるにもかかわらず、

148
00:11:23,610 --> 00:11:27,760
我々は物事を分割し、小数または浮動小数点数ではなく扱っていることを意味し

149
00:11:27,760 --> 00:11:30,900
私たちは頭のデータ構造を考えている場合。

150
00:11:30,900 --> 00:11:32,540
私たちは、山車について何を知っていますか？

151
00:11:32,540 --> 00:11:35,180
我々が山車を扱っている一般的な問題は何ですか？

152
00:11:35,180 --> 00:11:38,600
[学生]不正確な算術。 >>うん。不正確。

153
00:11:38,600 --> 00:11:43,760
このpsetの、浮動小数点の不正確さのため、我々は確認してくださいよう

154
00:11:43,760 --> 00:11:49,450
我々は任意の値が失われることはありませんし、我々は、実際に点数を扱うことになるだろう。

155
00:11:49,450 --> 00:11:54,880
あなたはここで構造体に戻って見れば、ハフマンノードを考えていたのであれば、

156
00:11:54,880 --> 00:12:01,740
あなたは緑色のものを見ればそれは、それに関連付けられた周波数を持ってい

157
00:12:01,740 --> 00:12:08,760
同様にそれはその左側にノードだけでなく、その右にあるノードを指しています。

158
00:12:08,760 --> 00:12:13,970
続いて赤のものがあり、またそれらに関連付けられている文字を持っています。

159
00:12:13,970 --> 00:12:18,900
私たちは、両親や、最終的なノードに別々のものを作るつもりはない

160
00:12:18,900 --> 00:12:23,680
その我々は、葉と呼ぶのではなく、それらは単にNULL値を持つことになります。

161
00:12:23,680 --> 00:12:31,050
我々が文字、そのノードが表すシンボルを持っていますが、ノードごとに

162
00:12:31,050 --> 00:12:40,490
その後、周波数だけでなく、その左の子だけでなく、その右の子へのポインタ。

163
00:12:40,490 --> 00:12:45,680
一番下にある葉も、ノードポインタを持っているでしょう

164
00:12:45,680 --> 00:12:49,550
その左とその右に、それらの値は、実際のノードを指していませんので、

165
00:12:49,550 --> 00:12:53,970
その価値は何でしょうか？ >> [学生]はNULL。 >>の場合はNULL。その通りです。

166
00:12:53,970 --> 00:12:58,430
ここでは、浮動小数点数で周波数を表すかもしれない方法の例を、だ

167
00:12:58,430 --> 00:13:02,130
しかし、我々は、整数とそれに対処することになるだろう

168
00:13:02,130 --> 00:13:06,780
ので、私がしたすべては、そこにデータ型を変更することです。

169
00:13:06,780 --> 00:13:09,700
>> のは、複雑な例をもう少し上に行ってみよう。

170
00:13:09,700 --> 00:13:13,360
しかし、今、我々は単純なものをやったことは、それだけで同じプロセスだ。

171
00:13:13,360 --> 00:13:20,290
あなたは2点の最も低い周波数を見つけ、周波数を合計

172
00:13:20,290 --> 00:13:22,450
そしてそれは、あなたの親ノードの新しい周波数だ

173
00:13:22,450 --> 00:13:29,310
次にその0枝と1枝と右とその左を指しています。

174
00:13:29,310 --> 00:13:34,200
我々は文字列 "これはCS50ですが、"持っているならば、我々は、Tの記載されて何回カウント

175
00:13:34,200 --> 00:13:38,420
hが述べたように、I、S、C、5、0。

176
00:13:38,420 --> 00:13:42,010
その後、私はここで何をしたかは、私はちょうど植え赤のノードを使用することです

177
00:13:42,010 --> 00:13:48,530
私はツリーの一番下に、最終的にこれらの文字を持っているつもりだと語った。

178
00:13:48,530 --> 00:13:51,740
それらは、葉の全てになるだろうしている。

179
00:13:51,740 --> 00:13:58,200
それから私が何をしたか私は、昇順に周波数別にソートされている

180
00:13:58,200 --> 00:14:02,950
そして、これは実際のpsetコードはそれをしないという方法です。

181
00:14:02,950 --> 00:14:07,550
それは周波数によってソートした後、アルファベット順です。

182
00:14:07,550 --> 00:14:13,870
だから、周波数のアルファベット順に最初にして数字を持っています。

183
00:14:13,870 --> 00:14:18,520
それから私は何であろうと、私は最低の2を見つけるだろうということです。つまり、0〜5です。

184
00:14:18,520 --> 00:14:22,390
私はそれらを合計するであろう、そしてそれは2です。それから私は、次の2最低のを見つけて、続けているでしょう。

185
00:14:22,390 --> 00:14:26,100
それらは2つの1ですし、それらは同様に2になる。

186
00:14:26,100 --> 00:14:31,570
さて、私の次のステップは、最小の番号を参加されようとしていることを知っている

187
00:14:31,570 --> 00:14:41,380
これは、1 Tであり、その後、周波数として2を持つノードのいずれかを選択します。

188
00:14:41,380 --> 00:14:44,560
そこでここでは、3つのオプションがあります。

189
00:14:44,560 --> 00:14:47,980
私はスライドのために何をしようとしているものだけで視覚的にあなたのためにそれらを再配置され

190
00:14:47,980 --> 00:14:51,790
そのように私はそれを作っているかを見ることができます。

191
00:14:51,790 --> 00:14:59,040
コー​​ドとしているディストリビューション·コードが何をするつもりなのかは、Tいずれかに参加されるであろう

192
00:14:59,040 --> 00:15:01,410
0と5ノードを持つ。

193
00:15:01,410 --> 00:15:05,060
それでは、次に3〜和、そして、我々はプロセスを続行すること。

194
00:15:05,060 --> 00:15:08,660
2と2は、ここでその後、4〜それらの合計が最も低い。

195
00:15:08,660 --> 00:15:12,560
誰もがこれまでに以下の？オーケー。

196
00:15:12,560 --> 00:15:16,410
その後、その後、我々は、3以上追加する必要がある3を持っている

197
00:15:16,410 --> 00:15:21,650
あなたはそれがあまりにも厄介にならないように視覚的に確認できるようので、もう一度私はちょうどそれを切り替えています。

198
00:15:21,650 --> 00:15:25,740
その後、我々は6を持って、私たちの最後のステップは、今我々は2つ​​のノードのみを持っているということです

199
00:15:25,740 --> 00:15:30,440
我々は10です私たちのツリーのルートを作るためにそれらを合計します。

200
00:15:30,440 --> 00:15:34,100
各ノードが表されるためと10番は、理にかなっている

201
00:15:34,100 --> 00:15:40,750
それらの値は、その周波数番号は、それらが文字列で登場何回あった

202
00:15:40,750 --> 00:15:46,350
その後我々は文字列内の5文字を​​持って、理にかなっているように。

203
00:15:48,060 --> 00:15:52,320
我々は我々が実際にそれをエンコードする方法を見上げる場合は、

204
00:15:52,320 --> 00:15:56,580
最も頻繁に現れる予想通り、iとs、

205
00:15:56,580 --> 00:16:01,350
ビット数が最も少ない数で表されます。

206
00:16:03,660 --> 00:16:05,660
>> ここで注意してください。

207
00:16:05,660 --> 00:16:09,780
ハフマン木でケースは、実際に問題になります。

208
00:16:09,780 --> 00:16:13,670
大文字のSは小文字のsとは異なります。

209
00:16:13,670 --> 00:16:21,260
我々が持っていた場合は、小文字のsは二回しか思わその後、大文字で "これはCS50です"

210
00:16:21,260 --> 00:16:27,120
その値として2を持つノードになるでしょうし、大文字のSは一度だけだろう。

211
00:16:27,120 --> 00:16:33,440
あなたが実際にここに余分な葉を持っているので、それでは、あなたのツリーは構造を変更することになります。

212
00:16:33,440 --> 00:16:36,900
しかし、合計はまだ10だろう。

213
00:16:36,900 --> 00:16:39,570
つまり、我々が実際にチェックサムを呼び出すことになるだろう何

214
00:16:39,570 --> 00:16:44,060
カウントのすべての追加。

215
00:16:46,010 --> 00:16:50,990
>> 今、私たちは、ハフマン木を紹介してきたことを、我々はHuff'nパフ、psetに飛び込むことができます。

216
00:16:50,990 --> 00:16:52,900
ここでは、質問のセクションで開始しようとしている、

217
00:16:52,900 --> 00:16:57,990
そしてこれはあなたがバイナリツリー方法と、その周りに操作方法に慣れて取得するつもりされています。

218
00:16:57,990 --> 00:17:03,230
描画のノードのノードのために、独自のtypedef構造体を作成し、

219
00:17:03,230 --> 00:17:07,230
そしてあなたがバイナリツリー、ソートされただ1つに挿入する方法を見て、

220
00:17:07,230 --> 00:17:09,050
それを通過すると、そのようなもの。

221
00:17:09,050 --> 00:17:14,560
その知識は間違いなく時Huff'nパフ部分にあなたがダイビングのお手伝いをしようとしている

222
00:17:14,560 --> 00:17:17,089
psetの。

223
00:17:19,150 --> 00:17:26,329
psetの標準版では、あなたのタスクは、パフを実装することです

224
00:17:26,329 --> 00:17:30,240
やハッカーのバージョンでは、あなたのタスクは、ハフを実装することです。

225
00:17:30,240 --> 00:17:38,490
ハフは何をするか、それはテキストを受け取り、それは0と1に変換します

226
00:17:38,490 --> 00:17:41,990
ので、我々は周波数をカウントどこさて、上記のことをプロセス

227
00:17:41,990 --> 00:17:50,970
し、ツリーを作って、次に言った、 "どのように私はTを得るのですか？"

228
00:17:50,970 --> 00:17:54,840
Tは100で表され、そのようなもの、

229
00:17:54,840 --> 00:17:58,860
その後ハフは、テキストとし、出力そのバイナリを取るだろう。

230
00:17:58,860 --> 00:18:04,920
しかし、また、私達は私達が私達のメッセージの受信者を許可することを知っているので、

231
00:18:04,920 --> 00:18:11,790
まったく同じツリーを再作成するために、それはまた、周波数カウントに関する情報が含まれています。

232
00:18:11,790 --> 00:18:17,980
その後、パフと私たちは、0と1のバイナリ·ファイルを与えられている

233
00:18:17,980 --> 00:18:21,740
また、周波数に関する情報を与えられた。

234
00:18:21,740 --> 00:18:26,740
我々は、であった元のメッセージにそれらの0と1の背中のすべてを翻訳

235
00:18:26,740 --> 00:18:29,350
ので、我々はそれを解凍している。

236
00:18:29,350 --> 00:18:36,450
あなたは、標準版をやっている場合、あなたは、ハフを実装する必要はありません

237
00:18:36,450 --> 00:18:39,290
そう、あなただけのハフのスタッフの実装を使用することができます。

238
00:18:39,290 --> 00:18:42,080
それを行う方法についての仕様の指示があります。

239
00:18:42,080 --> 00:18:48,780
あなたは、特定のテキストフ​​ァイルに基づいハフのスタッフの実装を実行することができます

240
00:18:48,780 --> 00:18:53,270
その後パフへの入力としてその出力を使用しています。

241
00:18:53,270 --> 00:18:59,330
>> 私は前に述べたように、我々はこの1つのディストリビューションのコードの多くを持っています。

242
00:18:59,330 --> 00:19:01,810
私はそれを通過開始するつもりだ。

243
00:19:01,810 --> 00:19:04,400
私はほとんどの時間を過ごすつもりです。hファイル

244
00:19:04,400 --> 00:19:07,660
cファイルであるため、我々は。hを持っているので、

245
00:19:07,660 --> 00:19:11,650
それは、関数のプロトタイプを提供してくれます

246
00:19:11,650 --> 00:19:15,520
我々は完全に正確に理解する必要はありません - 

247
00:19:15,520 --> 00:19:20,280
あなたは。cファイルで何が起こっているか理解していない場合、その後、あまり心配しないでください

248
00:19:20,280 --> 00:19:23,600
それはいくつかのヒントを与えるかもしれないので、間違いなく見てみるとしよう

249
00:19:23,600 --> 00:19:29,220
そしてそれは他の人のコードを読むことに慣れておくと便利です。

250
00:19:38,940 --> 00:19:48,270
>> huffile.hを見ると、コメント欄では、ハフマン符号化されたファイルのための抽象化層を宣言します。

251
00:19:48,270 --> 00:20:01,660
我々がダウンした場合、我々はのためのコードを必要とするかもしれない256シンボルの最大値が設定されていることがわかります。

252
00:20:01,660 --> 00:20:05,480
大文字と小文字の -   - これはアルファベットのすべての文字が含まれています

253
00:20:05,480 --> 00:20:08,250
その後記号と数字など

254
00:20:08,250 --> 00:20:11,930
その後、ここで我々は、ハフマン符号化されたファイルを識別するマジックナンバーを持っています。

255
00:20:11,930 --> 00:20:15,890
ハフマン·コード内で、彼らは特定のマジックナンバーを持っているつもりです

256
00:20:15,890 --> 00:20:18,560
ヘッダーに関連付けられている。

257
00:20:18,560 --> 00:20:21,110
これは、単にランダムなマジックナンバーのようになります。

258
00:20:21,110 --> 00:20:27,160
あなたが実際にASCIIにそれを翻訳した場合しかし、それは実際にハフを綴ります。

259
00:20:27,160 --> 00:20:34,290
ここでは、ハフマン符号化されたファイルのための構造体を持っています。

260
00:20:34,290 --> 00:20:39,670
ハフファイルに関連付けられた次の特性のすべてがあります。

261
00:20:39,670 --> 00:20:47,080
その後、ダウンここではハフファイルのヘッダを持っているので、我々はそれHuffeader呼び出す

262
00:20:47,080 --> 00:20:50,810
代わりに、それはとにかく同じに聞こえるので、余分な時間を追加する。

263
00:20:50,810 --> 00:20:52,720
かわいい。

264
00:20:52,720 --> 00:20:57,790
我々は、それに関連付けられたマジックナンバーを持っています。

265
00:20:57,790 --> 00:21:09,040
それは実際のハフファイルなら、それは上記の電話番号まで、この魔法の1になるだろう。

266
00:21:09,040 --> 00:21:14,720
そしてそれは、配列を持つことになります。

267
00:21:14,720 --> 00:21:18,750
だからシンボルごとに、そのうちの256は、ある

268
00:21:18,750 --> 00:21:24,760
それはそれらのシンボルの周波数はハフファイル内にあるものを記入して起こっている。

269
00:21:24,760 --> 00:21:28,090
そして最後に、我々は、周波数のチェックサムを持っている

270
00:21:28,090 --> 00:21:32,160
これは、これらの周波数の合計になります。

271
00:21:32,160 --> 00:21:36,520
だからのHuffeaderが何であるか。

272
00:21:36,520 --> 00:21:44,600
その後、我々はハフファイルに次のビットを返すいくつかの機能を持っている

273
00:21:44,600 --> 00:21:52,580
同様hfcloseは、ここでは、この機能次に、ハフファイルにビットを書き込み、

274
00:21:52,580 --> 00:21:54,650
それは実際にハフファイルを閉じます。

275
00:21:54,650 --> 00:21:57,290
前に、我々はストレートだけfcloseを扱っていた、

276
00:21:57,290 --> 00:22:01,190
しかし、あなたはハフファイルがある場合、代わりにそれをfclosingの

277
00:22:01,190 --> 00:22:06,080
何を実際にやろうとしていることは、それをhfcloseとhfopenです。

278
00:22:06,080 --> 00:22:13,220
それらは、我々が扱うことになるだろうことをハフファイルに固有の機能です。

279
00:22:13,220 --> 00:22:19,230
その後、ここで私たちは、ヘッダーを読み込んで、そのヘッダーを書き込みます。

280
00:22:19,230 --> 00:22:25,700
>> ちょうど私達が種類のハフファイルが何であるかの感覚を得ることができます。hファイルを読み取ることによって、

281
00:22:25,700 --> 00:22:32,480
それは、実際にhuffile.cに入ることなく、持っているものの特性

282
00:22:32,480 --> 00:22:36,750
れ、私たちが潜る場合は、もう少し複雑になるだろう。

283
00:22:36,750 --> 00:22:41,270
これは、I / Oはここにポインタを扱うファイルのすべてを持っています。

284
00:22:41,270 --> 00:22:48,010
ここで我々はhfreadを呼び出したときに、例えば、それはまだfread関数を扱っていることがわかります。

285
00:22:48,010 --> 00:22:53,050
我々は完全にこれらの機能を退治していないが、我々の世話をするためにそれらを送っている

286
00:22:53,050 --> 00:22:59,760
代わりに自分自身のすべてを行うのハフファイル内。

287
00:22:59,760 --> 00:23:02,300
あなたが興味を持っている場合は、この全体をスキャンして自由に感じることができます

288
00:23:02,300 --> 00:23:08,410
と行くとバック層少しはがします。

289
00:23:20,650 --> 00:23:24,060
>> 我々が見しようとしている次のファイルがtree.h.です

290
00:23:24,060 --> 00:23:30,210
チュートリアルでは、我々はハフマンノードを期待すると述べた滑り込む前

291
00:23:30,210 --> 00:23:32,960
そして我々は、typedef structのノードを作りました。

292
00:23:32,960 --> 00:23:38,360
我々は、それがその後のシンボル、周波数、2ノードの星を持っていることを期待しています。

293
00:23:38,360 --> 00:23:41,870
このケースでは、私たちがやっていることは、これは本質的に同じである

294
00:23:41,870 --> 00:23:46,880
代わりにノードを除いて、我々は彼らの木呼ぶつもりです。

295
00:23:48,790 --> 00:23:56,760
我々は、あなたが木を作る呼び出すときにそれはあなたの木へのポインタを返す関数を持っています。

296
00:23:56,760 --> 00:24:03,450
新しいノードを作っていたときに、スペルチェックに戻る

297
00:24:03,450 --> 00:24:11,410
あなたは、ノード*新しい単語=のmalloc（sizeof演算）とそのようなことを言った。

298
00:24:11,410 --> 00:24:17,510
基本的に、mktreeはあなたのためにそれに対処しようとしている。

299
00:24:17,510 --> 00:24:20,990
同様に、ツリーを削除するときに、

300
00:24:20,990 --> 00:24:24,810
そう、それは本質的に、あなたはそれで終わったツリーを解放だ

301
00:24:24,810 --> 00:24:33,790
代わりに、明示的にその上に無料通話するのではなく、実際にちょうどrmtree関数を使用するつもりだ

302
00:24:33,790 --> 00:24:40,360
あなたは、そのツリーにポインタを渡すと、どこ子ですがあなたのためにそれの世話をします。

303
00:24:40,360 --> 00:24:42,490
>> 我々はtree.c.のぞき込む

304
00:24:42,490 --> 00:24:47,240
我々としても実装を参照する以外に同じ機能を期待しています。

305
00:24:47,240 --> 00:24:57,720
我々が期待したように、あなたはmktree呼び出すときには、ポインタにツリーのサイズをmallocを

306
00:24:57,720 --> 00:25:03,190
ので、0またはNULL値は、NULL値にすべての値を初期化する

307
00:25:03,190 --> 00:25:08,280
その後、ちょうどあなたにmallocさきたことを、その木へのポインタを返します。

308
00:25:08,280 --> 00:25:13,340
ここでは、ツリーを削除呼び出すときには、まずあなたが二重解放していないことを確認します。

309
00:25:13,340 --> 00:25:18,320
それはあなたが実際に削除したいツリーを持っていることを確認します。

310
00:25:18,320 --> 00:25:23,330
ツリーには、その子を含み、ここにいるのは、

311
00:25:23,330 --> 00:25:29,560
これは何をするか、それは再帰的にツリーの左ノードにツリーを削除呼び出し

312
00:25:29,560 --> 00:25:31,650
同様に右側のノードとして。

313
00:25:31,650 --> 00:25:37,790
それは親を解放する前に、それは同様に子供たちを解放する必要があります。

314
00:25:37,790 --> 00:25:42,770
親はまた、ルートと交換可能である。

315
00:25:42,770 --> 00:25:46,500
とても素晴らしい、曾曾曾祖父のような史上初の親、

316
00:25:46,500 --> 00:25:52,130
や祖母の木は、まず第一のレベルをダウン解放する必要があります。

317
00:25:52,130 --> 00:25:58,490
ので、これらの無料の、一番下に横断し、それらなど、戻っフリー思い付く

318
00:26:00,400 --> 00:26:02,210
だからツリーです。

319
00:26:02,210 --> 00:26:04,240
>> 今、私たちは森を見てみましょう。

320
00:26:04,240 --> 00:26:09,860
あなたは、ハフマン木のすべてを配置する場所の森です。

321
00:26:09,860 --> 00:26:12,910
それは、我々はプロットと呼ばれるものを持っているつもりだと言っている

322
00:26:12,910 --> 00:26:22,320
それは木だけでなく、次に呼び出さプロットへのポインタへのポインタが含まれます。

323
00:26:22,320 --> 00:26:28,480
この種の構造はどのようなもののように見えるのでしょうか？

324
00:26:29,870 --> 00:26:32,490
それは一種の存在それを上に述べています。

325
00:26:34,640 --> 00:26:36,700
こっちに右。

326
00:26:37,340 --> 00:26:39,170
リンクリスト。

327
00:26:39,170 --> 00:26:44,590
我々はプロットを持っているとき、それがプロットのリンクリストのようなものだことがわかります。

328
00:26:44,590 --> 00:26:53,020
森は、プロットのリンクリストとして定義されている

329
00:26:53,020 --> 00:26:58,100
など森林の構造が私達はちょうど私達の最初のプロットへのポインタを持っているつもりさ

330
00:26:58,100 --> 00:27:02,740
そのプロットは、その中のツリーまたはツリーにかなりのポイントを持っている

331
00:27:02,740 --> 00:27:06,190
その後などなど、次のプロットを指しています。

332
00:27:06,190 --> 00:27:11,100
森を作るために、我々はmkforestを呼び出します。

333
00:27:11,100 --> 00:27:14,930
その後、我々はここでいくつかの非常に有用な機能を持っています。

334
00:27:14,930 --> 00:27:23,240
、我々は、あなたが森の中で渡す場所ピックアップしていると、戻り値はツリーです*

335
00:27:23,240 --> 00:27:25,210
ツリーへのポインタ。

336
00:27:25,210 --> 00:27:29,370
どんなピックを行いますと、それはあなたが指していることを森の中に入って行くということです

337
00:27:29,370 --> 00:27:35,240
その森から最低周波数でツリーを削除

338
00:27:35,240 --> 00:27:38,330
そして、そのツリーにあなたにポインタを与える。

339
00:27:38,330 --> 00:27:43,030
一度あなたが選ぶ呼び出し、ツリーは、もう森の中に存在しません

340
00:27:43,030 --> 00:27:48,550
しかし、戻り値はその木へのポインタです。

341
00:27:48,550 --> 00:27:50,730
その後、工場を持っています。

342
00:27:50,730 --> 00:27:57,420
あなたが非0の周波数を持つツリーへのポインタを渡すことを条件に、

343
00:27:57,420 --> 00:28:04,040
どんな植物が行​​いますが、それは森を取る木を取り、植える予定しているフォレストのツリー内部。

344
00:28:04,040 --> 00:28:06,370
ここでは、rmforestを持っています。

345
00:28:06,370 --> 00:28:11,480
基本的に私たちのために私達の木のすべてを解放したツリーを削除するための同様の

346
00:28:11,480 --> 00:28:16,600
森を削除するには、その森の中に含まれる遊離すべては意志。

347
00:28:16,600 --> 00:28:24,890
>> 我々はforest.cに見れば、我々は、そこには少なくとも1 rmtreeコマンドを見ることを期待します

348
00:28:24,890 --> 00:28:30,090
、森の木々はそれを持っている場合、フォレスト内のメモリを解放するために

349
00:28:30,090 --> 00:28:32,930
その後、最終的にはあなたはあまりにもそれらの木を除去する必要があるとしている。

350
00:28:32,930 --> 00:28:41,020
我々はforest.cに見れば、我々は我々が期待どおりである私たちのmkforestを持っています。

351
00:28:41,020 --> 00:28:42,890
我々は、mallocの事を。

352
00:28:42,890 --> 00:28:51,740
それが最初から空ですので、我々は、NULLとしては、フォレスト内の最初のプロットを初期化する

353
00:28:51,740 --> 00:29:05,940
次に我々は、最も低い重量でツリーを返しピック、、最低周波数を参照してください

354
00:29:05,940 --> 00:29:13,560
そして、その特定のノードを取り除くことがその木を指し、次のいずれか、

355
00:29:13,560 --> 00:29:16,760
ので、それは森のリンクされたリストのことを取り出す。

356
00:29:16,760 --> 00:29:24,510
そして、ここで我々は挿入するリンクリストにツリー工場を持っています。

357
00:29:24,510 --> 00:29:29,960
何森はそれはうまくそれが私たちのためにソートされ続けているん。

358
00:29:29,960 --> 00:29:37,910
そして最後に、我々は、予想通り、我々はそこrmtreeと呼ばれている、rmforestを持っていると。

359
00:29:46,650 --> 00:29:55,440
>> これまでの流通コードを見てみると、huffile.cは、理解することがはるかに困難なことでおそらくあった

360
00:29:55,440 --> 00:29:59,990
他のファイルwhereas自身が従うのは非常にシンプルでした。

361
00:29:59,990 --> 00:30:03,090
ポインタやリンクリストなどの我々の知識があれば、

362
00:30:03,090 --> 00:30:04,860
我々は、かなりよく従うことができました。

363
00:30:04,860 --> 00:30:10,500
しかし、我々は本当に私たちが完全に理解していることを確認する必要があるすべては、hファイルである

364
00:30:10,500 --> 00:30:15,840
あなたは、それらの戻り値を扱う、それらの関数を呼び出すする必要があるため、

365
00:30:15,840 --> 00:30:20,590
ので、完全にアクションが実行されることに何が起こっているか理解していることを確認してください

366
00:30:20,590 --> 00:30:24,290
あなたがそれらのいずれかの関数を呼び出すたびに。

367
00:30:24,290 --> 00:30:33,020
しかし、実際にその中に理解することは我々がそれらを持っているので、非常に必要ではありません。hファイル。

368
00:30:35,170 --> 00:30:39,490
私たちは、流通コードのままに2以上のファイルを持っています。

369
00:30:39,490 --> 00:30:41,640
>> ダンプを見てみましょう。

370
00:30:41,640 --> 00:30:47,230
そのコメントにあったダンプは、ここでハフマン圧縮ファイルを取り

371
00:30:47,230 --> 00:30:55,580
その後変換し、ダンプそのコンテンツのすべてのアウト。

372
00:31:01,010 --> 00:31:04,260
ここで我々はそれがhfopenを呼び出していることがわかります。

373
00:31:04,260 --> 00:31:10,770
これは、*入力= fopenを提出するミラーリングの一種である

374
00:31:10,770 --> 00:31:13,500
そして、あなたは情報を渡します。

375
00:31:13,500 --> 00:31:18,240
それは、代わりにあなたはHuffileで渡しているファイル*を除いてほとんど同じです;

376
00:31:18,240 --> 00:31:22,030
代わりにfopenのはhfopenに渡しています。

377
00:31:22,030 --> 00:31:29,280
ここで我々は、ヘッダーで読む方法と同様の一種である、最初のヘッダーで読む

378
00:31:29,280 --> 00:31:33,580
ビットマップファイルの。

379
00:31:33,580 --> 00:31:38,000
ここでやっているのはどうかを確認しているかどうかヘッダー情報

380
00:31:38,000 --> 00:31:44,330
それは実際のハフファイルだということを示し、右のマジック番号が含まれ、

381
00:31:44,330 --> 00:31:53,610
次に確認するためにこれらのチェックのすべての我々はオープンhuffed実際のファイルができていないか、またはファイルがその。

382
00:31:53,610 --> 00:32:05,330
これが何を行うのは、それは我々が見ることができるシンボルのすべての周波数を出力している

383
00:32:05,330 --> 00:32:09,790
グラフィカルなテーブルに端末内。

384
00:32:09,790 --> 00:32:15,240
この部分は便利になるだろう。

385
00:32:15,240 --> 00:32:24,680
それは少しを持っており、可変ビットにビットずつ読み込み、それをプリントアウトします。

386
00:32:28,220 --> 00:32:35,430
私は、ファイルを吸引した結果であるhth.bin、上でダンプを呼び出すようにしているとし

387
00:32:35,430 --> 00:32:39,490
スタッフソリューションを使用して、私はこれを取得することになります。

388
00:32:39,490 --> 00:32:46,000
それは、これらのすべての文字を出力してから、それらが現れる頻度を入れている。

389
00:32:46,000 --> 00:32:51,180
二回表示され、H、、：私たちが見ている場合は、それらのほとんどは、これ以外のことは、0である

390
00:32:51,180 --> 00:32:54,820
その後、一度表示されたT、。

391
00:32:54,820 --> 00:33:07,860
そして、ここでは0と1で実際のメッセージを持っています。

392
00:33:07,860 --> 00:33:15,450
我々は、おそらく怒るされた元のメッセージであるhth.txt、見れば

393
00:33:15,450 --> 00:33:22,490
我々は、そこにいくつかのHsとTsを期待しています。

394
00:33:22,490 --> 00:33:28,720
具体的には、わずか1 Tと2 HSを期待しています。

395
00:33:32,510 --> 00:33:37,440
ここでは、hth.txtにあります。それは確かHTH持っています。

396
00:33:37,440 --> 00:33:41,270
我々はそれを見ることはできませんが、そこに含まれて、改行文字です。

397
00:33:41,270 --> 00:33:53,190
ハフファイルhth.binも同様に改行文字をエンコードしている。

398
00:33:55,680 --> 00:34:01,330
ここでは、注文は、HTH、次に改行であることを知っているので、

399
00:34:01,330 --> 00:34:07,340
我々は、おそらくHはちょうど単一（1）で表されていることがわかります

400
00:34:07,340 --> 00:34:17,120
その後Tは恐らく01ですそして次のHは1であるだけでなく、

401
00:34:17,120 --> 00:34:21,139
その後我々は2つ​​の0で示される改行を持っています。

402
00:34:22,420 --> 00:34:24,280
クール。

403
00:34:26,530 --> 00:34:31,600
>> そして最後に、我々は複数の。cとhファイルを扱っているので、

404
00:34:31,600 --> 00:34:36,350
我々は、コンパイラにかなり複雑な引数を持っているつもりです

405
00:34:36,350 --> 00:34:40,460
ので、ここで私たちはあなたのためにダンプを行うMakefileを持っています。

406
00:34:40,460 --> 00:34:47,070
しかし、実際には、あなた自身のpuff.cファイルを作ることを行かなければならない。

407
00:34:47,070 --> 00:34:54,330
Makefileは実際にあなたのためのpuff.c作りに対処しません。

408
00:34:54,330 --> 00:34:59,310
我々は、Makefileを編集し、あなたにそれを任せている。

409
00:34:59,310 --> 00:35:05,930
あなたが作るすべてのようなコマンドを入力すると、例えば、それはあなたのためにそれらのすべてを行います。

410
00:35:05,930 --> 00:35:10,760
過去のpsetからMakefileの例を見て自由に感じる

411
00:35:10,760 --> 00:35:17,400
だけでなく、あなたのパフ·ファイルを作ることができるかもしれない方法を確認するには、このいずれかのオフに行く

412
00:35:17,400 --> 00:35:20,260
このMakefileを編集します。

413
00:35:20,260 --> 00:35:22,730
それが私たちの流通コードのところはこれでおしまい。

414
00:35:22,730 --> 00:35:28,380
>> かつて我々はそれを介して手に入れたし、ここだけ別のお知らせです

415
00:35:28,380 --> 00:35:30,980
どのように我々は、ハフマンノードを扱うことになるだろう。

416
00:35:30,980 --> 00:35:35,400
我々は、もはやそれらのノードを呼び出すことするつもりはない、我々は彼らに木を呼ぶことになるだろう

417
00:35:35,400 --> 00:35:39,260
我々は、charとのシンボルを表すことになるだろうここで、

418
00:35:39,260 --> 00:35:43,340
その頻度、出現数、整数を持つ。

419
00:35:43,340 --> 00:35:47,370
それはfloatよりも正確だから我々はそれを使用しています。

420
00:35:47,370 --> 00:35:52,980
そして、我々は左の子と右の子に別のポインタを持っています。

421
00:35:52,980 --> 00:35:59,630
森林は、私たちが見たように、ちょうど木のリンクリストです。

422
00:35:59,630 --> 00:36:04,670
結局のところ、我々はハフファイルを構築しているときに、

423
00:36:04,670 --> 00:36:07,580
私達は私達の森林はわずか1ツリーを入れたい - 

424
00:36:07,580 --> 00:36:12,420
1ツリー、複数の子を持つ1ルート。

425
00:36:12,420 --> 00:36:20,840
以前我々は、弊社のハフマン木を作っていたときに、

426
00:36:20,840 --> 00:36:25,360
我々は画面上のすべてのノードを配置することによって始まった

427
00:36:25,360 --> 00:36:27,790
そして、我々は、これらのノードを持っているつもりですと言って

428
00:36:27,790 --> 00:36:32,920
結局、彼らは葉であることを行っているが、これは彼らのシンボルであり、これは彼らの周波数です。

429
00:36:32,920 --> 00:36:42,070
我々はわずか3文字があれば、当社の森では、それは3木の森です。

430
00:36:42,070 --> 00:36:45,150
そして、我々は、我々が最初に親を追加したときに、上に行くと、

431
00:36:45,150 --> 00:36:48,080
我々は2つ​​のツリーの森を作った。

432
00:36:48,080 --> 00:36:54,930
私たちは、森林からそれらの子供の2を削除してから、親ノードに置き換え

433
00:36:54,930 --> 00:36:58,820
それは子供のように、それらの2つのノードを持っていた。

434
00:36:58,820 --> 00:37:05,600
そして最後に、私たちの最後のように、BSとの我々の例を作る際の手順、およびCs

435
00:37:05,600 --> 00:37:08,030
最後の親を作成することです、

436
00:37:08,030 --> 00:37:13,190
などを1に森の木々の私達の合計数をもたらすこと。

437
00:37:13,190 --> 00:37:18,140
誰もがあなたが森の中に複数のツリーから始める方法を見ていない

438
00:37:18,140 --> 00:37:22,520
と1で終わる？オーケー。クール。

439
00:37:25,530 --> 00:37:28,110
>> 我々は、パフのために行うためには何が必要ですか？

440
00:37:28,110 --> 00:37:37,110
私たちに何が必要なのは、いつものように、彼らは私たちに、入力の右のタイプを与える、次のことを確認している

441
00:37:37,110 --> 00:37:39,090
私たちは実際にプログラムを実行できるようにします。

442
00:37:39,090 --> 00:37:43,130
この場合、彼らは彼らの最初のコマンドライン引数の後で私達を与えることになるだろう

443
00:37:43,130 --> 00:37:53,440
さらに2：私たちは解凍し、解凍されたファイルの出力したいファイル。

444
00:37:53,440 --> 00:38:00,410
しかし、いったん我々は、彼らが値の右の量で私たちを渡すことを確認してください

445
00:38:00,410 --> 00:38:05,820
我々は、入力がハフファイルであるかどうか確認する。

446
00:38:05,820 --> 00:38:10,420
そして、かつて私たちは、その後、私たちは木を構築したい、それがハフファイルだという保証

447
00:38:10,420 --> 00:38:20,940
それはメッセージを送ってきた人が建てたツリーに一致するようにツリーを構築します。

448
00:38:20,940 --> 00:38:25,840
私たちは木を構築した後に続いて、次に我々は、彼らが渡されたことを、0と1を扱うことができ、

449
00:38:25,840 --> 00:38:29,590
それは同じだから、私たちの木に沿ってその指示に従ってください。

450
00:38:29,590 --> 00:38:33,510
その後、そのメッセージを書き出すcharsに戻ってビットを解釈。

451
00:38:33,510 --> 00:38:35,880
そして、終わりに私たちはここでポインタを扱っているので、

452
00:38:35,880 --> 00:38:38,110
我々は、任意のメモリリークを持っていないことを確認したい

453
00:38:38,110 --> 00:38:41,330
そして我々はすべて無料。

454
00:38:42,820 --> 00:38:46,430
>> 適切な使用を確保することは今では私たちのために古い帽子です。

455
00:38:46,430 --> 00:38:51,980
我々はパフするファイルの名前であることを行っている入力、見に行く

456
00:38:51,980 --> 00:38:56,010
それから私達は、出力を指定

457
00:38:56,010 --> 00:39:01,580
ので、テキストフ​​ァイルになります膨化出力のためのファイルの名前を指定します。

458
00:39:03,680 --> 00:39:08,820
それは使用です。そして今、我々は、入力が怒るか、されていないことを確認したいと思います。

459
00:39:08,820 --> 00:39:16,420
振り返って、そこに私たちを助けるかもしれない流通コードで何かあった

460
00:39:16,420 --> 00:39:21,570
ファイルは怒るされているかどうかを理解しますか？

461
00:39:21,570 --> 00:39:26,910
Huffeader約huffile.cの情報がありました。

462
00:39:26,910 --> 00:39:33,430
我々は、すべてのハフファイルはマジックナンバーとそれに関連付けられたHuffeaderを持っていることを知っている

463
00:39:33,430 --> 00:39:37,240
各シンボルの周波数だけでなく、配列

464
00:39:37,240 --> 00:39:39,570
同様にチェックサムなど。

465
00:39:39,570 --> 00:39:43,180
我々は知っているが、我々はまた、dump.cを覗いた

466
00:39:43,180 --> 00:39:49,120
その年にはハフファイルに読んでいた。

467
00:39:49,120 --> 00:39:53,990
それで、それを実行するために、それが本当に怒るされたかどうかを確認する必要がありました。

468
00:39:53,990 --> 00:40:03,380
だから、おそらく我々はpuff.c.ための構造体として使用することができますdump.c

469
00:40:03,380 --> 00:40:12,680
戻るPSET 4〜私たちはRGBの3でコピーしたファイルそれなのにを持っていたとき

470
00:40:12,680 --> 00:40:14,860
そして我々は、推理小説とResizeのためにそれを解釈

471
00:40:14,860 --> 00:40:20,390
同様に、何を行う可能性は、単にCP dump.c puff.cのようなコマンドを実行している

472
00:40:20,390 --> 00:40:23,600
とそこにコードの一部を使用します。

473
00:40:23,600 --> 00:40:28,210
しかし、それはプロセスのように簡単ではないだろう

474
00:40:28,210 --> 00:40:33,010
puff.cにあなたdump.cを翻訳するための、

475
00:40:33,010 --> 00:40:36,160
少なくともそれが起動するためにどこかにあなたを与える

476
00:40:36,160 --> 00:40:40,540
入力が実際に怒るか、されていないことを確認する方法について

477
00:40:40,540 --> 00:40:43,240
同様にいくつか他のもののように。

478
00:40:45,930 --> 00:40:50,250
我々は、適切な使用を確保し、入力が怒るされていることを確保している。

479
00:40:50,250 --> 00:40:53,570
我々は我々の適切なエラーチェックを行っていることをやったことを毎回、

480
00:40:53,570 --> 00:41:01,520
ので、問題があったら、戻っていくつかの障害が発生した場合、関数を終了する。

481
00:41:01,520 --> 00:41:07,170
>> 今、私たちが何をしたいのか、実際のツリーを構築しています。

482
00:41:08,840 --> 00:41:12,640
私たちは森を見てみると、2つの主要機能があります

483
00:41:12,640 --> 00:41:15,800
我々は非常に精通しになりたいと思ってしようとしている。

484
00:41:15,800 --> 00:41:23,870
その植物私たちの森の中の非0の周波数ツリーをブール関数工場があります。

485
00:41:23,870 --> 00:41:29,250
それでそこには森や木へのポインタへのポインタを渡します。

486
00:41:32,530 --> 00:41:40,340
簡単な質問：あなたは、ハフマン木を構築しているときにどのように多くの森林あなたが持っているのだろうか？

487
00:41:44,210 --> 00:41:46,650
私たちの森が右、私たちのキャンバスのようなものです？

488
00:41:46,650 --> 00:41:50,800
だから我々は1つだけの森を持っているつもりですが、我々は複数のツリーを持っているつもりです。

489
00:41:50,800 --> 00:41:57,590
あなたが植物を呼び出すので、前に、あなたは、おそらくあなたの森を作りたいとしている。

490
00:41:57,590 --> 00:42:04,430
あなたが森を作ることができる方法でforest.hのぞき込むと、このコマンドはそのためにあります。

491
00:42:04,430 --> 00:42:09,270
あなたは木を植えることができます。我々はそれを行う方法を知っている。

492
00:42:09,270 --> 00:42:11,590
そして、あなたはまた、森から木を選ぶことができます

493
00:42:11,590 --> 00:42:17,540
最低重量とツリーを削除し、それにあなたにポインタを与える。

494
00:42:17,540 --> 00:42:23,090
私達は私達自身の例をやっていた時に戻って考えると、

495
00:42:23,090 --> 00:42:27,980
我々はそれを引き出したときに、我々は、単に単にリンクを追加しました。

496
00:42:27,980 --> 00:42:31,680
しかし、ここだけではなく、リンクを追加する、

497
00:42:31,680 --> 00:42:40,630
あなたはそれらのノードの2を削除し、別の1でそれを交換しているようにもっと考えることもできます。

498
00:42:40,630 --> 00:42:44,200
、ピッキングや植栽の面でそれを表現する

499
00:42:44,200 --> 00:42:48,840
あなたは2本の木をピッキングして、別の木を植えています

500
00:42:48,840 --> 00:42:54,060
それは、あなたが子供として選んだこれらの2本の木を持っています。

501
00:42:57,950 --> 00:43:05,280
ハフマンのツリーを構築するには、順序で記号と周波数で読むことができます

502
00:43:05,280 --> 00:43:10,790
Huffeaderはあなたにそれを与えるので、

503
00:43:10,790 --> 00:43:14,250
あなたに周波数の配列を与える。

504
00:43:14,250 --> 00:43:19,660
だから先に行くと、ちょうどそれに0を使って何かを無視することができます

505
00:43:19,660 --> 00:43:23,760
我々はそれの終わりに256葉をしたくないので。

506
00:43:23,760 --> 00:43:27,960
我々は唯一の文字である葉の数が欲しい

507
00:43:27,960 --> 00:43:31,600
それは実際にはファイルで使用されています。

508
00:43:31,600 --> 00:43:37,590
あなたは、これらのシンボルを読み込み、0以外の周波数を持っているそれらのシンボルの各々ができる

509
00:43:37,590 --> 00:43:40,440
それらは木になるだろうしている。

510
00:43:40,440 --> 00:43:45,990
何を行うことができますことは、あなたが非0の周波数シンボルで読むたびにです

511
00:43:45,990 --> 00:43:50,660
あなたは森の中にその木を植えることができます。

512
00:43:50,660 --> 00:43:56,620
いったん森の中に木を植え、あなたは、兄弟のようにそれらの木に参加することができます

513
00:43:56,620 --> 00:44:01,130
そう植えて、2を選択してから、どこで拾っプラント1に戻って、

514
00:44:01,130 --> 00:44:05,820
その1あなたの植物は、あなたが選んだ2人の子供の親であること。

515
00:44:05,820 --> 00:44:11,160
それでは、あなたの最終的な結果は、フォレスト内の単一のツリーになるだろう。

516
00:44:16,180 --> 00:44:18,170
それは、あなたのツリーを構築する方法です。

517
00:44:18,170 --> 00:44:21,850
>> ここで間違って行くことができることがいくつかあります

518
00:44:21,850 --> 00:44:26,580
ので、我々は新しい木を作り、そのようなポインタや物事に対処を扱っている。

519
00:44:26,580 --> 00:44:30,450
我々はポインタを扱う前にしたとき、

520
00:44:30,450 --> 00:44:36,580
我々はmallocされるたびに、我々はそれが私たちにNULLポインタ値を返さなかったことを確認したかった。

521
00:44:36,580 --> 00:44:42,770
したがって、このプロセス内のいくつかの段階でいくつかの例があるように行く

522
00:44:42,770 --> 00:44:45,920
どこにあなたのプログラムが失敗する可能性があります。

523
00:44:45,920 --> 00:44:51,310
あなたは何をしたいのは、あなたがこれらのエラーを処理することを確認したいです

524
00:44:51,310 --> 00:44:54,580
とspecには、優雅にそれらを処理すると言う

525
00:44:54,580 --> 00:45:00,280
ので、プログラムが終了しなければならない理由、それらを伝えるユーザーにメッセージをプリントアウトしたい

526
00:45:00,280 --> 00:45:03,050
その後速やかにそれを終了します。

527
00:45:03,050 --> 00:45:09,490
このエラー処理を行うには、あなたがそれをチェックすることを忘れないでください

528
00:45:09,490 --> 00:45:12,160
障害があるかもしれないことを毎回。

529
00:45:12,160 --> 00:45:14,660
あなたは新しいポインタを作っている一つ一つの時間

530
00:45:14,660 --> 00:45:17,040
あなたはそれが成功したということを確認する必要があります。

531
00:45:17,040 --> 00:45:20,320
我々は新しいポインタとmallocそれを作るされているものを行うために使用する前に、

532
00:45:20,320 --> 00:45:22,380
それから私達はそのポインタがNULLであるかどうかをチェックします。

533
00:45:22,380 --> 00:45:25,670
だから、あなたがちょうどそれを行うことができるいくつかの事例があるように起こっており、

534
00:45:25,670 --> 00:45:28,610
しかし、時にはあなたは、実際に関数を呼び出しています

535
00:45:28,610 --> 00:45:33,100
そして、その関数内では、それはmallocingをやっている一つだ。

536
00:45:33,100 --> 00:45:39,110
その場合、我々はコード内の機能の一部に戻って見れば、

537
00:45:39,110 --> 00:45:42,260
そのうちのいくつかは、ブール関数です。

538
00:45:42,260 --> 00:45:48,480
抽象的なケースでは、fooというブール関数を持っている場合、

539
00:45:48,480 --> 00:45:54,580
基本的に、我々は、ほかにfooがないものは何でもやっていると仮定することができます

540
00:45:54,580 --> 00:45:57,210
それはブール関数なので、それがtrueまたはfalseを返します - 

541
00:45:57,210 --> 00:46:01,300
成功した場合はtrue、そうでない場合はfalseです。

542
00:46:01,300 --> 00:46:06,270
だから我々は、fooの戻り値がtrueであるかfalseであるかどうかを確認する。

543
00:46:06,270 --> 00:46:10,400
もしfalseであれば、それは我々がメッセージのいくつかの種類を印刷したいとしていることを意味します

544
00:46:10,400 --> 00:46:14,390
その後、プログラムを終了します。

545
00:46:14,390 --> 00:46:18,530
私たちがやりたいことは、fooの戻り値をチェックすることです。

546
00:46:18,530 --> 00:46:23,310
fooがfalseを返した場合、我々は何らかのエラーが発生したことを知っている

547
00:46:23,310 --> 00:46:25,110
そして私達は私達のプログラムを終了する必要があります。

548
00:46:25,110 --> 00:46:35,600
これを行うための方法は、実際の関数自体があなたの条件である条件を持っていることです。

549
00:46:35,600 --> 00:46:39,320
fooはxにかかると言う。

550
00:46:39,320 --> 00:46:43,390
我々は、if条件として持つことができます（この例ではfoo（x））を。

551
00:46:43,390 --> 00:46:50,900
fooを実行の終わりにそれがtrueを返した場合、基本的に、それは、意味

552
00:46:50,900 --> 00:46:57,390
関数はfooを評価する必要があるため、我々はこれを行うことができます

553
00:46:57,390 --> 00:47:00,500
全体の状態を評価するために。

554
00:47:00,500 --> 00:47:06,500
それでは、それは関数がtrueを返し、成功した場合、あなたが何かをすることができる方法です。

555
00:47:06,500 --> 00:47:11,800
しかし、あなたは、エラーチェックしているときに、あなただけの関数がfalseを返した場合、辞めたい。

556
00:47:11,800 --> 00:47:16,090
あなたは何を行う可能性は、単に追加するだけです== falseまたはちょうどそれの前に強打を追加

557
00:47:16,090 --> 00:47:21,010
そして、あなたは（！foo）があれば持っています。

558
00:47:21,010 --> 00:47:29,540
その条件とは身体の中では、エラー処理のすべてを持っているでしょう

559
00:47:29,540 --> 00:47:36,940
ので、 "このツリーを作成できませんでした"とし、1またはそのような何かを返すこと、好きです。

560
00:47:36,940 --> 00:47:43,340
それが何をするかは、しかし、fooはfalseが返された場合でも、それは - 

561
00:47:43,340 --> 00:47:46,980
fooがtrueを返したと言う。

562
00:47:46,980 --> 00:47:51,060
その後、再度fooを呼び出す必要はありません。それはよくある誤解です。

563
00:47:51,060 --> 00:47:54,730
それはあなたの条件にあったので、すでに評価'S、

564
00:47:54,730 --> 00:47:59,430
ので、すでにあなたがそのような木か何かを作る使用している場合は、その結果を持っている

565
00:47:59,430 --> 00:48:01,840
または植物またはピックか何か。

566
00:48:01,840 --> 00:48:07,460
それは、すでにその値を持っています。それはすでに実行だ。

567
00:48:07,460 --> 00:48:10,730
だから、条件としてブール関数を使用すると便利です

568
00:48:10,730 --> 00:48:13,890
あなたが実際にループ本体を実行するかどうかので、

569
00:48:13,890 --> 00:48:18,030
それはとにかく関数を実行します。

570
00:48:22,070 --> 00:48:27,330
>> 最後のステップへの我々の2番目はファイルにメッセージを書き込んでいます。

571
00:48:27,330 --> 00:48:33,070
かつて我々は、ハフマン木を作成してから、そのファイルにメッセージを書くことが非常に簡単です。

572
00:48:33,070 --> 00:48:39,260
それはちょうど、0と1に従うようになりましたかなり簡単です。

573
00:48:39,260 --> 00:48:45,480
それで、慣例により、我々はハフマンツリーで0が残って示していることを知っている

574
00:48:45,480 --> 00:48:48,360
と1sは右を示す。

575
00:48:48,360 --> 00:48:53,540
それでは、あなたは、少しずつでは0（ゼロ）を取得するたびに読めば

576
00:48:53,540 --> 00:48:59,100
あなたは1で読み取るたびに、次に左の分岐に従っており、よ

577
00:48:59,100 --> 00:49:02,100
あなたは右の枝に従うつもりだ。

578
00:49:02,100 --> 00:49:07,570
あなたが葉を打つまで、その後、続けていくつもりです

579
00:49:07,570 --> 00:49:11,550
葉は枝の端にあることを行っているためです。

580
00:49:11,550 --> 00:49:16,870
どのように我々は我々が葉を打ったかどうかを見分けることができるか？

581
00:49:19,800 --> 00:49:21,690
我々は前にそれを言った。

582
00:49:21,690 --> 00:49:24,040
[学生]のポインタがNULLである場合。 >>うん。

583
00:49:24,040 --> 00:49:32,220
左と右の両方のツリーへのポインタがNULLである場合、我々は葉を襲った場合、我々は知ることができます。

584
00:49:32,220 --> 00:49:34,110
パーフェクト。

585
00:49:34,110 --> 00:49:40,320
我々は、我々はハフファイルにビットごとに読みたいと思うことを知っています。

586
00:49:43,870 --> 00:49:51,220
我々は、彼らが何をしたか、dump.cで前に見た彼らは、ハフファイルにビットごとに読み取られているように

587
00:49:51,220 --> 00:49:54,560
そしてちょうどそれらのビットが何であったかプリントアウト。

588
00:49:54,560 --> 00:49:58,430
我々はそれをやっているつもりはない。我々は、もう少し複雑な何かをやっているつもりです。

589
00:49:58,430 --> 00:50:03,620
しかし、私たちが出来ることは、我々は少しに読み取るコードのそのビットを取ることができますです。

590
00:50:03,620 --> 00:50:10,250
ここで我々は上にいることを、現在のビットを表す整数ビットを持っています。

591
00:50:10,250 --> 00:50:15,520
あなたがファイルの終わりに到達するまでこれは、ファイルのすべてのビットを反復するの面倒を見る。

592
00:50:15,520 --> 00:50:21,270
それに基づいて、その後、イテレータのいくつかの種類を持ってするつもりだ

593
00:50:21,270 --> 00:50:26,760
あなたのツリーをトラバースする。

594
00:50:26,760 --> 00:50:31,460
そして、ビットは、0か1であるか否かに基づいて、

595
00:50:31,460 --> 00:50:36,920
あなたはどちらを左にその反復子を移動したり、右に移動するつもりだ

596
00:50:36,920 --> 00:50:44,080
ずっとあなたが葉に到達するまでの間なので、ずっとあなたがいることを、そのノードまで

597
00:50:44,080 --> 00:50:48,260
任意の複数のノードを指していません。

598
00:50:48,260 --> 00:50:54,300
なぜ我々はハフマンファイルではなく、モールス信号でこれを行うことができますか？

599
00:50:54,300 --> 00:50:56,610
モールス信号で、あいまいさのビットが存在だからです。

600
00:50:56,610 --> 00:51:04,440
ああ待って、同じように我々は可能性があり、我々は、これは私たちの文字ですので、多分、道に沿って文字を打ちました

601
00:51:04,440 --> 00:51:08,150
我々は少しだけ長く続けた場合のに対し、我々は、別の文字を打っていただろう。

602
00:51:08,150 --> 00:51:13,110
しかし、それは、ハフマン符号化で起こることはないだろう

603
00:51:13,110 --> 00:51:17,540
ので、我々が行っていることが唯一の方法は、文字を打つために安心することができ

604
00:51:17,540 --> 00:51:23,480
そのノードの左右の子供がNULLである場合です。

605
00:51:28,280 --> 00:51:32,350
>> 最後に、我々はすべてのメモリを解放したい。

606
00:51:32,350 --> 00:51:37,420
我々は両方の我々が扱ってきたことハフファイルを閉じたい

607
00:51:37,420 --> 00:51:41,940
だけでなく、私たちの森の木々のすべてを削除します。

608
00:51:41,940 --> 00:51:46,470
あなたの実装に基づいて、あなたはおそらく森を削除呼び出すするつもりだ

609
00:51:46,470 --> 00:51:49,780
代わりに、実際に木を自分のすべてを通過する。

610
00:51:49,780 --> 00:51:53,430
あなたは、任意の一時的な木を作った場合しかし、あなたはそれを解放したいと思う。

611
00:51:53,430 --> 00:51:59,060
あなたは最高のあなたのコードを知っているので、メモリを割り当てている場所あなたが知っている。

612
00:51:59,060 --> 00:52:04,330
あなたが行くそうだとすれば、mallocのF'ingさえコントロールすることから始め、

613
00:52:04,330 --> 00:52:08,330
たびにmallocを見て、あなたはそれのすべてを解放することを確認すること

614
00:52:08,330 --> 00:52:10,190
しかしその後、ちょうどあなたのコードを経由する場合は、

615
00:52:10,190 --> 00:52:14,260
あなたがメモリを割り当てている可能性のある場所を理解。

616
00:52:14,260 --> 00:52:21,340
通常は単に "ファイルの終わりに私はちょうど私の森で森林を削除するつもりです"、と言うかもしれない

617
00:52:21,340 --> 00:52:23,850
ので、基本的に、その自由は、そのメモリをクリア

618
00:52:23,850 --> 00:52:28,310
"そして私はまた、ファイルを閉じ、その後、私のプログラムが終了しようとしているつもりです。"

619
00:52:28,310 --> 00:52:33,810
しかし、あなたのプログラムが終了したことをそのときだけです？

620
00:52:33,810 --> 00:52:37,880
いや、時にはために起きたエラーがあったかもしれない。

621
00:52:37,880 --> 00:52:42,080
多分、我々はファイルを開けませんでしたか、我々は別のツリーを作ることができなかった

622
00:52:42,080 --> 00:52:49,340
または何らかのエラーはメモリ割り当てプロセスで起こったので、それはNULLを返していました。

623
00:52:49,340 --> 00:52:56,710
エラーが起こった後、私達は戻されて終了します。

624
00:52:56,710 --> 00:53:02,040
それでは、あなたは、あなたのプログラムが終了することができ、すべての可能な時間ということを確認したい、

625
00:53:02,040 --> 00:53:06,980
あなたはそこにあなたのすべてのメモリを解放したい。

626
00:53:06,980 --> 00:53:13,370
それはちょうどあなたがあなたのコードを終了することをmain関数の一番最後にするつもりはない。

627
00:53:13,370 --> 00:53:20,780
あなたのコードは、潜在的に時期尚早に返すかもしれないが、すべてのインスタンスに戻って見てみたい

628
00:53:20,780 --> 00:53:25,070
その後フリーどんなメモリが理にかなっています。

629
00:53:25,070 --> 00:53:30,830
あなたが森を作ると呼んでいたと言う、それはfalseが返された場合。

630
00:53:30,830 --> 00:53:34,230
あなたはおそらくあなたの森を削除する必要はありません

631
00:53:34,230 --> 00:53:37,080
あなたはまだ森を持っていないので。

632
00:53:37,080 --> 00:53:42,130
しかし、あなたが途中で返される可能性があり、コード内のあらゆるポイントで

633
00:53:42,130 --> 00:53:46,160
あなたはすべての可能なメモリを解放することを確認したい。

634
00:53:46,160 --> 00:53:50,020
>> だから我々はメモリを解放し、潜在的なリークを持つ扱っているときに、

635
00:53:50,020 --> 00:53:55,440
我々は我々の判断と私たちのロジックを使用しないようにだけしたい

636
00:53:55,440 --> 00:54:01,850
だけでなく、我々は適切かどうか私たちのすべてのメモリを解放したかどうかを判断するためにValgrindを使用しています。

637
00:54:01,850 --> 00:54:09,460
どちらかパフでValgrindは実行することができ、その後、また、それを渡す必要があります

638
00:54:09,460 --> 00:54:14,020
コマンドライン引数の数は右のvalgrind。

639
00:54:14,020 --> 00:54:18,100
あなたはそれを実行することができますが、出力は少し不可解です。

640
00:54:18,100 --> 00:54:21,630
我々は、スペルチェックでそれに使用されるビットを得ているが、我々はまだもう少し助けが必要

641
00:54:21,630 --> 00:54:26,450
さて、漏れのチェック=フルのようないくつかの複数のフラグを付けて実行

642
00:54:26,450 --> 00:54:32,040
それはおそらく私たちにValgrindの上のいくつかのより有用な出力が得られます。

643
00:54:32,040 --> 00:54:39,040
>> 次に、デバッグしているもう一つの有用な先端は、diffコマンドです。

644
00:54:39,040 --> 00:54:48,520
あなたは、テキストフ​​ァイルであることを実行ハフのスタッフの実装にアクセスすることができます

645
00:54:48,520 --> 00:54:55,400
その後具体的には、バイナリファイル、バイナリ·ハフファイルに出力する。

646
00:54:55,400 --> 00:54:59,440
次に、そのバイナリファイルで独自のパフを実行する場合、

647
00:54:59,440 --> 00:55:03,950
次に、理想的には、実行すると、出力するテキストフ​​ァイルは同一であることを行っている

648
00:55:03,950 --> 00:55:08,200
あなたが渡された元の1に

649
00:55:08,200 --> 00:55:15,150
ここでは、例としてhth.txtを使用している、そしてそれはあなたのスペックでの話一つだ。

650
00:55:15,150 --> 00:55:21,040
それは文字通り、HTH、次に改行です。

651
00:55:21,040 --> 00:55:30,970
しかし、間違いなくお気軽に、あなたは間違いなく長い例を使用するよう奨励されます

652
00:55:30,970 --> 00:55:32,620
テキストフ​​ァイルの。

653
00:55:32,620 --> 00:55:38,110
>> あなたも、もしかしたら圧縮し、その後解凍でショットを取ることができます

654
00:55:38,110 --> 00:55:41,600
戦争と平和のようにあなたはスペルチェックで使用したファイルの一部

655
00:55:41,600 --> 00:55:46,710
ジェーン·オースティンなど何か - クールの一種だろう - またはオースティン·パワーズ、

656
00:55:46,710 --> 00:55:51,880
我々はそれにダウンして来ようとしないため、大きいファイルを扱う一種の

657
00:55:51,880 --> 00:55:55,590
我々はここで次のツールは、ls-lを使用した場合。

658
00:55:55,590 --> 00:56:01,150
我々は基本的には私たちの現在のディレクトリにあるすべての内容をリストするls、に慣れている。

659
00:56:01,150 --> 00:56:07,860
-lオプションを渡すと、実際にそれらのファイルのサイズが表示されます。

660
00:56:07,860 --> 00:56:12,690
あなたのpsetスペックを通過する場合、それは実際には、バイナリファイルを作成する方法について説明し

661
00:56:12,690 --> 00:56:16,590
のそれを吸引し、あなたは非常に小さなファイルに対してそれを参照してください。

662
00:56:16,590 --> 00:56:23,910
それを圧縮し、その情報のすべてを翻訳するスペースのコスト

663
00:56:23,910 --> 00:56:26,980
実際の利点を上回るそのようなすべての周波数や物事の

664
00:56:26,980 --> 00:56:30,000
最初の場所でファイルを圧縮する。

665
00:56:30,000 --> 00:56:37,450
しかし、あなたには、いくつかの長いテキストフ​​ァイルにそれを実行した場合、その後、あなたはいくつかの利点を得るために始めることがわかるかもしれません

666
00:56:37,450 --> 00:56:40,930
これらのファイルを圧縮インチ

667
00:56:40,930 --> 00:56:46,210
>> そして最後に、我々は間違いなくあまりにも便利になるだろうとしている私たちの古い友人のGDBを持っています。

668
00:56:48,360 --> 00:56:55,320
>> 私たちは木を作るのは多分ハフツリーやプロセス上の任意の質問がありますか

669
00:56:55,320 --> 00:56:58,590
またはHuff'nパフ上の他の質問？

670
00:57:00,680 --> 00:57:02,570
オーケー。私は少しのために周りにいるよ。

671
00:57:02,570 --> 00:57:06,570
>> おかげで、みんな。これはチュートリアル6であった。そして幸運。

672
00:57:08,660 --> 00:57:10,000
>> [CS50.TV]