1
00:00:00,000 --> 00:00:02,210
[Powered by Google Translate] [Walkthrough - Проблем Set 6]

2
00:00:02,210 --> 00:00:04,810
[Zamyla Chan - Харвардския университет]

3
00:00:04,810 --> 00:00:07,240
[Това е CS50. - CS50.TV]

4
00:00:07,240 --> 00:00:12,180
>> Здравейте на всички, и добре дошли Walkthrough 6: Huff'n Puff.

5
00:00:12,180 --> 00:00:17,440
В Puff Huff'n това, което правим, ще се занимава с Huffman компресиран файл

6
00:00:17,440 --> 00:00:20,740
и след това пухтене назад, така че декомпресиране,

7
00:00:20,740 --> 00:00:25,810
така че можем да преведем от 0s и 1s, че потребителят ни изпраща

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 и вид на обединяването им в един доста чист концепция

11
00:00:41,730 --> 00:00:43,830
когато дойдеш да мисля за това.

12
00:00:43,830 --> 00:00:50,110
>> Също така, може би, pset 4 и 5 са ​​най-голямото предизвикателство psets, че ние трябва да предлагат.

13
00:00:50,110 --> 00:00:53,950
Така че от сега, имаме още 1 pset в C,

14
00:00:53,950 --> 00:00:56,480
и тогава, след това сме на уеб програмирането.

15
00:00:56,480 --> 00:01:02,310
Така че сами поздравя за преодоляването на най-тежката гърбица в CS50.

16
00:01:03,630 --> 00:01:09,760
>> Преминавайки за Puff 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
и така тези, които ще бъдат в файлове, но след това придружаващите ги з файлове

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
Huffman дървета са двоични дървета, което означава, че всеки възел има само две деца.

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
Ако се опитвате да превежда А или Е, например,

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
или може би един процент от всички герои колко се появява всеки един.

53
00:03:40,270 --> 00:03:44,270
И така, това, което правите, е след като имате всички, че начертан,

54
00:03:44,270 --> 00:03:49,060
търсите две ниските честоти и след това да се присъедини към тях като братя и сестри

55
00:03:49,060 --> 00:03:55,660
където майка възел има честота, което е сумата от нейните две деца.

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
Тя може да бъде или една буква или тя може да бъде поредица от две букви.

62
00:04:22,430 --> 00:04:27,790
И така, какво Huffman дървета е така, защото по природа на героите

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
Имам 4 като 6 BS, и 2 Cs.

73
00:05:14,010 --> 00:05:17,270
Първата ми стъпка ще бъде да се брои.

74
00:05:17,270 --> 00:05:20,760
Колко пъти се появи? Той се появява четири пъти в низа.

75
00:05:20,760 --> 00:05:25,060
B се появява шест пъти, а C се появява два пъти.

76
00:05:25,060 --> 00:05:28,970
Естествено, аз ще да кажа, че съм с Б, най-често,

77
00:05:28,970 --> 00:05:35,970
така че аз искам да представляват Б с най-малък брой битове, най-малък брой на 0s и 1s.

78
00:05:35,970 --> 00:05:42,600
И тогава аз ще да се очаква, C, както и да изисква най-голямо количество на 0s и 1s.

79
00:05:42,600 --> 00:05:48,550
Първо това, което направих тук Аз ги поставя във възходящ ред по отношение на честотата.

80
00:05:48,550 --> 00:05:52,710
Виждаме, че С и А, това са нашите два най-ниските честоти.

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
Сумата става 2 + 4, което е с 6.

84
00:06:08,780 --> 00:06:10,800
След това ние следваме по лявото отклонение.

85
00:06:10,800 --> 00:06:14,970
Ако бяхме в този възел 6, а след това ще последва 0, за да стигнем до C

86
00:06:14,970 --> 00:06:17,450
и след това 1 да стигнем до А.

87
00:06:17,450 --> 00:06:20,300
Така че сега имаме два възли.

88
00:06:20,300 --> 00:06:23,920
Имаме стойност 6 и след това ние също имаме друг възел със стойност 6.

89
00:06:23,920 --> 00:06:28,550
И така, тези две са не само две най-ниската, но само две, които са оставени,

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
къде да стигнем до точка Б, че просто ще бъде малко 1

93
00:06:40,020 --> 00:06:45,430
и след това да стигнем до бихме има 01 и след това C като 00.

94
00:06:45,430 --> 00:06:51,300
Така че тук ние виждаме, че в общи линии ние представляваме тези символа или с един или два бита

95
00:06:51,300 --> 00:06:55,160
където B, като прогнозира, има най-малко.

96
00:06:55,160 --> 00:07:01,730
И тогава бяхме очаква да има най-много, но тъй като тя е толкова малка дърво Хъфман,

97
00:07:01,730 --> 00:07:06,020
А също е представена от два бита, за разлика от някъде по средата.

98
00:07:07,820 --> 00:07:11,070
>> Само да премине друг прост пример на дървото на Хъфман,

99
00:07:11,070 --> 00:07:19,570
кажем, че имате низ "Hello".

100
00:07:19,570 --> 00:07:25,360
Това, което трябва да направите, е първата бихте казали колко пъти H се появяват в този?

101
00:07:25,360 --> 00:07:34,200
H се появява веднъж и след това д се появява веднъж и след това имаме появява два пъти

102
00:07:34,200 --> 00:07:36,580
и о появява веднъж.

103
00:07:36,580 --> 00:07:44,310
И така, тогава ние очакваме коя буква да бъдат представлявани от най-малко броя на битовете?

104
00:07:44,310 --> 00:07:47,450
[Ученик] л. >> Л. Да. л е прав.

105
00:07:47,450 --> 00:07:50,730
Очакваме да бъдат представлявани от най-малко броя на битовете

106
00:07:50,730 --> 00:07:55,890
защото л се използва най-много в низа "Hello".

107
00:07:55,890 --> 00:08:04,280
Какво съм аз ще да направя сега е да се изведат тези възли.

108
00:08:04,280 --> 00:08:15,580
Имам 1, който е H, а след това още 1, която е електронна, а след това и едно, което е о -

109
00:08:15,580 --> 00:08:23,410
точно сега аз съм пускането им в ред - и след това 2, който е л.

110
00:08:23,410 --> 00:08:32,799
После казват, че начина, по който гради дърво Хъфман е да намерите два възли с най-малко честоти

111
00:08:32,799 --> 00:08:38,010
и да ги направят братя и сестри чрез създаване на майка възел.

112
00:08:38,010 --> 00:08:41,850
Тук имаме три възли с най-ниска честота. Всички те са 1.

113
00:08:41,850 --> 00:08:50,620
Така че тук ние избираме кой отива да се свържат първо.

114
00:08:50,620 --> 00:08:54,850
Да кажем, че изберете H и електронна.

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
Сега търсим в следващите две най-ниските честоти.

118
00:09:10,950 --> 00:09:15,590
Това е 2 и 1. Това може да е една от тези две, но аз отивам да се избере този,.

119
00:09:15,590 --> 00:09:18,800
Сумата е три.

120
00:09:18,800 --> 00:09:26,410
И накрая, аз само два ляво, така че това става 5.

121
00:09:26,410 --> 00:09:32,010
Тогава, както се очаква, ако попълнете кодиране за това,

122
00:09:32,010 --> 00:09:37,480
1s винаги клон и 0 лявата.

123
00:09:37,480 --> 00:09:45,880
Тогава имаме представени само с 1 малко и после о от 2

124
00:09:45,880 --> 00:09:52,360
и след това д от 2 и след това H пада до 3 бита.

125
00:09:52,360 --> 00:09:59,750
Така че може да предава това съобщение "Hello", вместо на реално използване на героите

126
00:09:59,750 --> 00:10:02,760
само с 0s и 1s.

127
00:10:02,760 --> 00:10:07,910
Все пак, не забравяйте, че в няколко случая имахме връзки с нашата честота.

128
00:10:07,910 --> 00:10:11,900
Би могъл да се присъедини към H и о първо може би.

129
00:10:11,900 --> 00:10:15,730
Или може би по-късно, когато имахме л, представлявано от 2

130
00:10:15,730 --> 00:10:19,410
както и се присъедини, представлявано от 2, бихме могли да са свързани нито една.

131
00:10:19,410 --> 00:10:23,630
>> И така, когато ви изпрати 0s и 1s, че всъщност не е гаранция

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
но понякога може да има дърво Huffman

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 най-ниската, да ги обобщим,

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
Ще намерите две ниските честоти, обобщават честоти

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
з споменах, аз, 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
Тогава какво щях да правя, е, че ще открие две най-ниската. Това е 0 и 5.

184
00:14:18,520 --> 00:14:22,390
Аз ще ги обобщим и това е 2. След това ще продължа да намерите следващия 2-ниската.

185
00:14:22,390 --> 00:14:26,100
Това са двете 1s, и след това стана 2, както и.

186
00:14:26,100 --> 00:14:31,570
Сега знам, че следващата ми стъпка ще се присъедини към най-малък брой,

187
00:14:31,570 --> 00:14:41,380
който е T 1, и след това изберете един от възлите, че има две, както и честотата.

188
00:14:41,380 --> 00:14:44,560
Така че тук имаме три възможности.

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, а след това нашата крайна стъпка сега е, че имаме само два възли

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
и след това имаме пет герои в нашия низ, така че има смисъл.

203
00:15:48,060 --> 00:15:52,320
Ако се вгледаме в начина, по който всъщност ще го кодират,

204
00:15:52,320 --> 00:15:56,580
както се очаква, аз и 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 е различен от малки и.

209
00:16:13,670 --> 00:16:21,260
Ако имахме "Това е CS50" с главни букви, а след това и с малки букви ще се появи само два пъти,

210
00:16:21,260 --> 00:16:27,120
ще бъде възел с две като стойността му, а след това главни букви 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
>> Сега, когато сме обхванати Хъфман дървета, може да се потопите в Puff 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
и виждам как може да вмъкнете в двоичен дърво, един, който е сортиран,

220
00:17:07,230 --> 00:17:09,050
пресичат, и такива неща.

221
00:17:09,050 --> 00:17:14,560
Това знание определено ще ви помогне, когато се потопите в Puff част Huff'n

222
00:17:14,560 --> 00:17:17,089
на pset.

223
00:17:19,150 --> 00:17:26,329
В стандартното издание на pset, вашата задача е да се приложи Puff,

224
00:17:26,329 --> 00:17:30,240
и в хакер версия вашата задача е да се приложи Хъф.

225
00:17:30,240 --> 00:17:38,490
Какво Хъф е, че отнема текст и след това тя се превръща в 0s и 1s,

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
След това с Пъф са дадени на двоичен файл на 0s и 1s

233
00:18:17,980 --> 00:18:21,740
и като се има предвид също така информация за честотите.

234
00:18:21,740 --> 00:18:26,740
Ние превеждаме всички тези 0s и 1s обратно в първоначалното съобщение, че е

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
>> Както споменах и преди, ние имаме много код на разпределение за това.

242
00:18:59,330 --> 00:19:01,810
Отивам да започне да минава през нея.

243
00:19:01,810 --> 00:19:04,400
Отивам да прекарват по-голямата част от времето на з файлове

244
00:19:04,400 --> 00:19:07,660
защото в файлове в, защото имаме. ч

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
Ако вие не разбирате какво се случва в файлове в, тогава не се притеснявайте твърде много,

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 в коментарите декларира слой на абстракция за Huffman кодирани файлове.

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
Тук имаме една структура за Huffman кодиран файл.

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
Ако това е действителния файл Хъф, той ще бъде броя на страните-горе, тази магия.

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
Преди това, ние се занимавахме с права само неуспешно,

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
>> Само с четене. З файл да се получи усещане от това, което може да бъде файл Хъф,

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
Преди в Walkthrough пързалки сме казали, че очакват Хъфман възел

291
00:23:30,210 --> 00:23:32,960
и ние направихме typedef възел структура.

292
00:23:32,960 --> 00:23:38,360
Очакваме тя да има символ, честота, а след това две звезди възли.

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
ти каза възел * нова дума = изчистване (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
премине в показалеца на това дърво и след това tree.c ще се погрижа за това за вас.

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 mallocs размера на едно дърво в показалеца

306
00:24:57,720 --> 00:25:03,190
инициализира всички стойности на нулева стойност, така че 0s или спадове,

307
00:25:03,190 --> 00:25:08,280
и връща указател към това дърво, че току-що сте malloc'd да ви.

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
Forest където можете да поставите на вашите дървета Хъфман.

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, ние ще очакваме да видим поне един 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
Ние изчистване неща.

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
И накрая, имаме rmforest и, както се очаква, ние имаме rmtree нарича там.

359
00:29:46,650 --> 00:29:55,440
>> Търсите разпределението код досега, huffile.c е може би най-трудната за разбиране,

360
00:29:55,440 --> 00:29:59,990
докато другите файлове са били сами по себе си доста просто да се следват.

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
Но всичко, което трябва наистина да сме сигурни, че напълно разбират е з файлове

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
Но всъщност разбиране вътре в него не е необходимо, тъй като имаме тези ч файлове.

368
00:30:35,170 --> 00:30:39,490
Имаме две повече файлове, останали в нашата дистрибуторска код.

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
тогава всички тези проверки, за да се уверите, че файла, който открито е действително вдишвали файл или не.

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, което е резултат от huffing файл

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
Ако погледнем, повечето от тях са 0s с изключение на това: H, който се появява два пъти,

390
00:32:51,180 --> 00:32:54,820
и след това T, който се появява веднъж.

391
00:32:54,820 --> 00:33:07,860
А пък тук имаме действителната съобщение 0s и 1s.

392
00:33:07,860 --> 00:33:15,450
Ако се вгледаме в hth.txt, която вероятно първоначалното съобщение, че е вдишвали

393
00:33:15,450 --> 00:33:22,490
ние очакваме да видим някои Hs и Ц. там.

394
00:33:22,490 --> 00:33:28,720
Конкретно, ние очакваме да видим само на 1 T и 2 ХС.

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 е представена само от един милиард

400
00:34:07,340 --> 00:34:17,120
и след това T вероятно е 01 и след това на следващия Н е 1, както и

401
00:34:17,120 --> 00:34:21,139
и тогава ще имаме нов ред, посочен от две 0s.

402
00:34:22,420 --> 00:34:24,280
Cool.

403
00:34:26,530 --> 00:34:31,600
>> И накрая, защото си имаме работа с множествена в з файлове,

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
Чувствайте се свободни да погледнете примерите на Makefile от миналото pset

411
00:35:10,760 --> 00:35:17,400
, както и на това да се види как може да сте в състояние да направите вашия файл Puff

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
къде отиваме да им символ с Чар,

418
00:35:39,260 --> 00:35:43,340
честотата им, броя на случаите, с цяло число.

419
00:35:43,340 --> 00:35:47,370
Ние използваме това, защото това е по-точен, отколкото с плаваща запетая.

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
В нашата гора, ако ние просто има три букви, това е гора от три дървета.

430
00:36:42,070 --> 00:36:45,150
И тогава, както и да отидем, когато сме добавили първия родител,

431
00:36:45,150 --> 00:36:48,080
ние направихме гората на две дървета.

432
00:36:48,080 --> 00:36:54,930
Премахнати две от тези деца от нашата гора и след това го заменя с един родител възел

433
00:36:54,930 --> 00:36:58,820
, които са имали тези две възли като деца.

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
и се свърши с една? Добре. Cool.

439
00:37:25,530 --> 00:37:28,110
>> Какво ни е нужно да се направи за Puff?

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
Тогава, след като строим дървото, тогава ние може да се справи с 0s и 1s, че премина в

449
00:38:25,840 --> 00:38:29,590
следват тези по нашето дърво, защото е идентичен,

450
00:38:29,590 --> 00:38:33,510
и след това напишете това съобщение, тълкуване на бита в символа.

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
Имаше информация в huffile.c за Huffeader.

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
Така че може би бихме могли да използвате dump.c като структура за нашия puff.c.

469
00:40:03,380 --> 00:40:12,680
Обратно към pset 4, когато имахме файла резервното, която да копира в тройки RGB

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
за превода dump.c в puff.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
Ако погледнем в гората, има две основни функции

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
Така че ние сме само ще има една гора, но отиваме да имат множество дървета.

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
мисля за него, както сте премахване на два от тези възли и след това да го заменя с друг.

498
00:42:40,630 --> 00:42:44,200
Да изрази, че по отношение на бране и посадъчен

499
00:42:44,200 --> 00:42:48,840
сте бране две дървета и засаждане на друго дърво

500
00:42:48,840 --> 00:42:54,060
, който има тези две дървета, които сте избрали като деца.

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
така че връщане назад към засаждане и бране, където да изберете две и след това растение 1,

514
00:44:01,130 --> 00:44:05,820
1, че растението е майка на две деца, които сте избрали.

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'd искахме да сме сигурни, че това не ни върне 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
и в спец. казва, че трябва да се справиш с тях грациозно,

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
Преди това, което сме свикнали да направите, е да се направи нов показалеца и изчистване го,

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
, тъй като това е булева функция, той се връща истина или лъжа -

541
00:45:57,210 --> 00:46:01,300
вярно, ако успешно, невярно, ако не.

542
00:46:01,300 --> 00:46:06,270
Така че ние искаме да се провери дали връщането стойност на Foo е вярно или невярно.

543
00:46:06,270 --> 00:46:10,400
Ако това е невярно, това означава, че ние ще искате да отпечатате някакъв вид послание

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 връща, тогава ние знаем, че сме срещнали някаква грешка

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 отвежда в х.

550
00:46:39,320 --> 00:46:43,390
Ние можем да имаме като условие, ако (Foo (х)).

551
00:46:43,390 --> 00:46:50,900
По принцип, това означава, че ако в края на изпълнението на Foo връща вярно,

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
Тогава как можете да направите нещо, ако функцията връща вярно и успешно.

555
00:47:06,500 --> 00:47:11,800
Но когато сте проверка за грешки, само искам да се откажат, ако си функция връща.

556
00:47:11,800 --> 00:47:16,090
Какво можете да направите, е просто добавете == невярна или просто добавете гръм и трясък в пред него

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
И тъй като "не може да се създаде това дърво" и след това се върнете един или нещо подобно.

560
00:47:36,940 --> 00:47:43,340
Това, обаче, е, че въпреки че Foo върнати фалшиви -

561
00:47:43,340 --> 00:47:46,980
Кажи Foo връща вярно.

562
00:47:46,980 --> 00:47:51,060
Тогава не трябва да се обадя на Foo отново. Това е често срещано погрешно схващане.

563
00:47:51,060 --> 00:47:54,730
Защото това беше в състоянието си, вече са били оценени,

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
>> Вторият ни към последната стъпка е писмено съобщение до файла.

571
00:48:27,330 --> 00:48:33,070
След строим дървото на Хъфман, след това писмено съобщение до файла е доста ясен.

572
00:48:33,070 --> 00:48:39,260
Това е доста ясен сега просто следвайте 0s и 1s.

573
00:48:39,260 --> 00:48:45,480
И така, по силата на споразумение, ние знаем, че в дърво Хъфман 0s показват оставяли

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
ще следват левия клон, а след това всеки път, когато прочетох в един

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
Perfect.

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
Но това няма да се случи в Huffman кодиране,

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
И така, ако вие отидете в, започнете, като дори и да е контрол, F'ing за изчистване,

613
00:52:04,330 --> 00:52:08,330
виждам, когато изчистване и като се уверите, че ви освободи всичко това

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
Това не е просто ще бъде в самия край на основната функция, която напусна своя код.

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
Да кажем, че бе нарекъл гората и да се върнат невярна.

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
>> Тогава друг полезен съвет, когато сте дебъгване е командата разл.

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
на оригинала, че сте издържали инча

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
някои от файловете, които сте използвали в Speller като Война и мир

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-л.

658
00:55:55,590 --> 00:56:01,150
Свикнали сме да ли, които основно се изброява цялото съдържание в сегашния ни директория.

659
00:56:01,150 --> 00:56:07,860
Минавайки в знаме-л всъщност показва размера на тези файлове.

660
00:56:07,860 --> 00:56:12,690
Ако отидете чрез спец. pset, всъщност ви води чрез създаването на двоичен файл,

661
00:56:12,690 --> 00:56:16,590
huffing тя, и ще видите, че за много малки файлове

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]