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
>> Hello, ყველას, და მივესალმები რომ Walkthrough 6: Huff'n Puff.

5
00:00:12,180 --> 00:00:17,440
In Huff'n Puff რას ვაკეთებთ იქნება საქმე Huffman შეკუმშული ფაილი

6
00:00:17,440 --> 00:00:20,740
და შემდეგ puffing უკან up, ასე decompressing ის,

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 და 5 pset და სახის აერთიანებს მათთვის 1 საკმაოდ აკურატული კონცეფცია

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 დო,

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
>> მოძრავი ამისთვის Huff'n Puff, ჩვენი ყუთისთვის ამ pset ვაპირებთ იყოს Huffman ხეები,

17
00:01:09,760 --> 00:01:14,700
ასე გაგება არა მარტო როგორ ბინარული ხეები მუშაობა არამედ კონკრეტულად Huffman ხეები,

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
>> პირველი მოდით შევხედოთ Huffman ხეები.

35
00:02:13,720 --> 00:02:19,600
Huffman ხეები არიან ბინარული ხეები, რაც იმას ნიშნავს, რომ თითოეული კვანძის მხოლოდ 2 შვილი.

36
00:02:19,600 --> 00:02:24,870
In Huffman ხეები დამახასიათებელი ის არის, რომ ყველაზე ხშირი ღირებულებები

37
00:02:24,870 --> 00:02:27,140
წარმოდგენილია fewest ბიტი.

38
00:02:27,140 --> 00:02:32,690
ჩვენ ვნახეთ ლექციების მაგალითები Morse კოდი, რომელიც სახის კონსოლიდირებული გარკვეული ასოებით.

39
00:02:32,690 --> 00:02:38,030
თუ თქვენ ცდილობთ თარგმნოს ან 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
ჩვენ გვყავს იგივე იდეა აქ Huffman ხეები

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
ვაპირებთ იყოს წარმოდგენილი fewest ბიტი.

48
00:03:17,940 --> 00:03:22,020
>> ისე, რომ თქვენ მშენებლობას Huffman ხე

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
და ასე თუ რას აკეთებთ არის კიდევ თქვენ ყველა იმ mapped out,

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
და შემდეგ rightmost კვანძში არის 1 ფილიალში.

59
00:04:08,140 --> 00:04:16,040
როგორც ვნახეთ Morse კოდი, ერთი GOTCHA იყო, რომ თითქოს მხოლოდ beep და beep

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
და მერე რა 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
თვალსაზრისით, რომელიც წერილში თქვენ ცდილობთ encode ერთად სერია ბიტი

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
ნაცვლად us მხოლოდ გეუბნებოდით, რომ მართალია.

70
00:05:02,120 --> 00:05:06,390
>> მოდით შევხედოთ მარტივ მაგალითს Huffman ხე.

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
რამდენჯერ ამჯამად გამოჩნდება? როგორც ჩანს 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
ამიტომ მინდა წარმოადგენენ B ერთად fewest რაოდენობის ბიტი, fewest ხმების 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
ჩვენ ვხედავთ, რომ 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
თანხა ხდება 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
ასე რომ ახლა გვაქვს 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
ასე რომ აქ ჩვენ გვაქვს ჩვენი Huffman ხე

92
00:06:36,300 --> 00:06:40,020
აქ მოხვედრა B, რომ მხოლოდ bit 1

93
00:06:40,020 --> 00:06:45,430
და მაშინ მისაღებად გვექნებოდა 01 და შემდეგ C მქონე 00.

94
00:06:45,430 --> 00:06:51,300
ასე რომ აქ ჩვენ ვხედავთ, რომ ძირითადად ჩვენ წარმოადგენს ამ chars არც 1 ან 2 ბიტი

95
00:06:51,300 --> 00:06:55,160
სადაც B, როგორც იწინასწარმეტყველა, აქვს მაინც.

96
00:06:55,160 --> 00:07:01,730
და შემდეგ ჩვენ ელოდა C ჰქონდეს საუკეთესო, მაგრამ რადგან ასეთი მცირე Huffman ხე,

97
00:07:01,730 --> 00:07:06,020
მაშინ ასევე წარმოდგენილია 2 ბიტი ნაცვლად სადღაც შუა.

98
00:07:07,820 --> 00:07:11,070
>> უბრალოდ წასვლა მეორეზე მარტივი მაგალითი Huffman ხე,

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
[სტუდენტი] ლ. >> ლ. Yeah. ლ არის სწორი.

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, რომელიც ვებ და შემდეგ 1, რომელიც o -

109
00:08:15,580 --> 00:08:23,410
ახლავე მე აყენებს მათ მიზნით - და შემდეგ 2, რომელიც ლ.

110
00:08:23,410 --> 00:08:32,799
მაშინ მე ვიტყვი, ისე, რომ მე აშენება Huffman ხე უნდა ვიპოვოთ 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
ვთქვათ მე აირჩიოს 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
ახლა ჩვენ შევხედოთ შემდეგი 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
და მაშინ საბოლოოდ, მე მხოლოდ 2 მარცხენა, ასეა, მაშინ რომ ხდება 5.

121
00:09:26,410 --> 00:09:32,010
მაშინ აქ, როგორც მოსალოდნელია, თუ შეავსოთ კოდირების რომ,

122
00:09:32,010 --> 00:09:37,480
1s ყოველთვის სწორი ფილიალი და 0S are მარცხენაში.

123
00:09:37,480 --> 00:09:45,880
მაშინ ჩვენ გვაქვს ლ წარმოდგენილია მხოლოდ 1 ბიტიანი და შემდეგ o მიერ 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 და o პირველი იქნებ.

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
რომ მიმღებს შეუძლია სრულად წაიკითხოთ თქვენი გაგზავნა უფლება off bat

133
00:10:27,090 --> 00:10:30,490
იმიტომ, რომ ისინი შეიძლება არ იცის, რომელი გადაწყვეტილება თქვენ გააკეთა.

134
00:10:30,490 --> 00:10:34,920
ასე რომ, როდესაც ჩვენ საქმე Huffman შეკუმშვა,

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 ყველაზე დაბალი, მთლიანობაში მათ, მომდევნო 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
ეს ნიშნავს, რომ ჩვენ გამყოფი რამ და საქმე decimals ან საკმაოდ floats

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
[სტუდენტი] Imprecise არითმეტიკული. >> Yeah. ორაზროვნება.

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
ასე რომ, თუ თქვენ ფიქრი Huffman კვანძში, თუ ვიხსენებთ, რათა სტრუქტურა აქ,

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
ფოთლები, რომლებიც ზუსტად იმ ბოლოში, ასევე აქვს node პოინტერები

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
თ აღნიშნული, 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
ეს ის ორი 1s, და შემდეგ იმ გახდეს 2 ასევე.

186
00:14:26,100 --> 00:14:31,570
ახლა მე ვიცი, რომ ჩემი შემდეგი ნაბიჯი იქნება გაწევრიანების ყველაზე დაბალი ნომერი,

187
00:14:31,570 --> 00:14:41,380
რაც T, 1 და შემდეგ ვირჩევთ ერთ კვანძების, რომელსაც აქვს 2 როგორც სიხშირე.

188
00:14:41,380 --> 00:14:44,560
ასე რომ აქ გვაქვს 3 ვარიანტი.

189
00:14:44,560 --> 00:14:47,980
რა მე გაკეთებას აპირებს slide მხოლოდ ვიზუალურად rearrange მათ თქვენთვის

190
00:14:47,980 --> 00:14:51,790
ასე რომ თქვენ ხედავთ, როგორ მე მშენებლობის it up.

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
ყველას შემდეგ აქამდე? Okay.

196
00:15:12,560 --> 00:15:16,410
შემდეგ რომ გვაქვს 3 და 3 რომ უნდა დაემატოს up,

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
ჩვენ მთლიანობაში იმ მიიღოს root ჩვენი ხე, რომელიც 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
თუ გადავხედავთ up, როგორ გვინდა რეალურად encode ის,

204
00:15:52,320 --> 00:15:56,580
როგორც მოსალოდნელი იყო, მე და s, რომელიც გამოჩნდება ყველაზე ხშირად

205
00:15:56,580 --> 00:16:01,350
წარმოდგენილია fewest რაოდენობის ბიტი.

206
00:16:03,660 --> 00:16:05,660
>> ფრთხილად აქ.

207
00:16:05,660 --> 00:16:09,780
In Huffman ხეები შემთხვევაში რეალურად საკითხები.

208
00:16:09,780 --> 00:16:13,670
ზედა S განსხვავებულია, ვიდრე ამას s.

209
00:16:13,670 --> 00:16:21,260
თუ ჩვენ გვქონდა "ეს არის CS50" ერთად ასოებით, მაშინ ამას s მხოლოდ ორჯერ გამოჩნდება,

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
>> ახლა, ჩვენ დაფარული Huffman ხეები, ჩვენ შეგვიძლია ჩაყვინთვის შევიდა Huff'n Puff, 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 struct ამისთვის კვანძში,

219
00:17:03,230 --> 00:17:07,230
და ხედავს, თუ როგორ შეიძლება ჩადეთ შევიდა ორობითი ხე, ერთი რომ დახარისხებული,

220
00:17:07,230 --> 00:17:09,050
traversing, და რამ, როგორიცაა, რომ.

221
00:17:09,050 --> 00:17:14,560
რომ ცოდნა ნამდვილად აპირებს დაგეხმაროთ როცა თქვენ ჩაყვინთვის შევიდა Huff'n Puff ნაწილი

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
და Hacker ვერსია თქვენი ამოცანაა განახორციელოს დათუნა დათო დავით მგელაძე.

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
შემდეგ Puff ჩვენ მოცემულია ორობითი ფაილის 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
ამიტომ ჩვენ decompressing რომ.

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
და შემდეგ გამოიყენოთ, რომ გამომავალი როგორც თქვენი შეყვანის to Puff.

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
მაგრამ ნამდვილად ცდილობენ მიიღონ look რადგან ეს შესაძლოა გარკვეული მინიშნებები

249
00:19:23,600 --> 00:19:29,220
და ეს სასარგებლო მისაღებად გამოიყენება კითხულობს სხვა ადამიანების კოდი.

250
00:19:38,940 --> 00:19:48,270
>> ეძებს huffile.h, in კომენტარები იგი აცხადებს ფენა აბსტრაქცია ამისთვის 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
მაშინ აქ გვაქვს ჯადოსნური ხმების იდენტიფიცირება Huffman კოდირებული ფაილის.

255
00:20:11,930 --> 00:20:15,890
ფარგლებში Huffman კოდი ისინი აპირებენ აქვს გარკვეული Magic ნომერი

256
00:20:15,890 --> 00:20:18,560
ასოცირდება header.

257
00:20:18,560 --> 00:20:21,110
ეს შეიძლება გამოიყურებოდეს მხოლოდ შემთხვევითი Magic ნომერი,

258
00:20:21,110 --> 00:20:27,160
მაგრამ თუ თქვენ ნამდვილად თარგმნოს იგი ASCII, მაშინ იგი რეალურად შელოცვების გარეთ დათუნა დათო დავით მგელაძე.

259
00:20:27,160 --> 00:20:34,290
აქ struct ამისთვის Huffman-კოდირებით ფაილი.

260
00:20:34,290 --> 00:20:39,670
აქ ყველა ამ მახასიათებლით ასოცირდება დათუნა დათო დავით მგელაძე ფაილი.

261
00:20:39,670 --> 00:20:47,080
მაშინ ქვემოთ აქ გვაქვს header for დათუნა დათო დავით მგელაძე ფაილი, ასე რომ ჩვენ მას Huffeader

262
00:20:47,080 --> 00:20:50,810
ნაცვლად დასძინა ზედმეტი თ, რადგან ეს ხმები იმავე მაინც.

263
00:20:50,810 --> 00:20:52,720
Cute.

264
00:20:52,720 --> 00:20:57,790
ჩვენ გვყავს Magic ხმების ასოცირდება იგი.

265
00:20:57,790 --> 00:21:09,040
თუ ეს ფაქტობრივი დათუნა დათო დავით მგელაძე ფაილი, ის იქნება ნომერი up ზემოთ, ამ ჯადოსნური ერთი.

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
მაშინ აქ ვკითხულობთ header და შემდეგ წერენ header.

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 სლაიდები განვაცხადეთ ველოდოთ Huffman კვანძში

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
თავში Speller, როდესაც მიღების ახალი კვანძში

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
სადაც თქვენ კორიდორი მომცეთ, რომ ხე და შემდეგ 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
initializes ყველა ფასეულობები NULL ღირებულება, ასე 0S ან NULLs,

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
მშობელი ასევე ურთიერთშემცვლელნი ის root.

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
ამიტომ traverse ბოლოში, უფასო იმ და შემდეგ დავბრუნდებით up, უფასო იმ ა.შ.

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
ტყე, სადაც თქვენ მიიტანეთ ყველა თქვენი Huffman ხეები.

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
ამოიღონ ტყის will უფასო ყველაფერი შეიცავს, რომ ტყეში.

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
და მაშინ საბოლოოდ, ჩვენ გვაქვს 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
მაგრამ რეალურად გაგება შიგნით ეს არ არის საკმაოდ საჭირო იმიტომ რომ ჩვენ გვაქვს იმ. თ files.

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
ნაგავსაყრელი თავისი კომენტარი აქ იღებს Huffman-შეკუმშული ფაილი

371
00:30:47,230 --> 00:30:55,580
და შემდეგ ითარგმნება და dumps ყველა მისი შინაარსი out.

372
00:31:01,010 --> 00:31:04,260
აქ ჩვენ ვხედავთ, რომ ის მოუწოდებდა hfopen.

373
00:31:04,260 --> 00:31:10,770
ეს არის სახის რეზერვირება შეიტანოს * input = 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
აქ ვკითხულობთ header პირველი, რაც სახის მსგავსი, თუ როგორ ვკითხულობთ header

378
00:31:29,280 --> 00:31:33,580
ამისთვის Bitmap ფაილი.

379
00:31:33,580 --> 00:31:38,000
იმას თუ რას ვაკეთებთ აქ ამოწმებს, რომ ნახოთ თუ არა თავსართი ინფორმაცია

380
00:31:38,000 --> 00:31:44,330
შეიცავს უფლება Magic ნომერი, რომელიც მიუთითებს, რომ ეს ფაქტობრივი დათუნა დათო დავით მგელაძე ფაილი,

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
ასე რომ მე რომ მოვუწოდო ნაგავსაყრელი on hth.bin, რომელიც არის შედეგი huffing ფაილი

387
00:32:35,430 --> 00:32:39,490
გამოყენებით პერსონალის გადაწყვეტა, მე ამ.

388
00:32:39,490 --> 00:32:46,000
ეს outputting ყველა ამ სიმბოლოებს და შემდეგ აყენებს სიხშირე, რომლის დროსაც ისინი გამოჩნდება.

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
და მერე აქ გვაქვს ფაქტობრივი გაგზავნა in 0S და 1s.

392
00:33:07,860 --> 00:33:15,450
თუ დავაკვირდებით hth.txt, რომელიც სავარაუდოდ ორიგინალური გაგზავნა, რომელიც huffed,

393
00:33:15,450 --> 00:33:22,490
ჩვენ ველით, რომ რამდენიმე HS და ც იქ.

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
და მაშინ ჩვენ გვაქვს სტრიქონების გადატანით მიერ მითითებულ ორ 0S.

402
00:34:22,420 --> 00:34:24,280
ზემოთ.

403
00:34:26,530 --> 00:34:31,600
>> და მაშინ საბოლოოდ, რადგან ჩვენ საქმე გვაქვს მრავალი. C და. თ ფაილი

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
ასევე აპირებს off ამ ერთი, რომ ნახოთ, თუ როგორ შეიძლება იყოს შეუძლია თქვენი 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
, როგორ ვაპირებთ იყოს საქმე Huffman კვანძების.

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 root მრავალი შვილი.

425
00:36:12,420 --> 00:36:20,840
მანამდე, როცა ჩვენ უბრალოდ ჩვენი Huffman ხეები,

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
და დასრულდება up ერთად 1? Okay. ზემოთ.

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 მეტი: ფაილი რომ ჩვენ გვინდა decompress და გამოშვებულ დეკომპრესია ფაილი.

444
00:37:53,440 --> 00:38:00,410
მაგრამ ერთხელ ჩვენ დავრწმუნდეთ, რომ ისინი გაივლიან us სწორი ოდენობით ღირებულებების,

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
ჩვენ მიიღოს შეყვანის, რომელიც იქნება სახელით ფაილი Puff,

456
00:38:51,980 --> 00:38:56,010
და მაშინ ჩვენ დააკონკრეტა გამომუშავება,

457
00:38:56,010 --> 00:39:01,580
ასე სახელით ფაილი puffed გამომუშავება, რომელიც იქნება ტექსტური ფაილი.

458
00:39:03,680 --> 00:39:08,820
სწორედ გამოყენება. და ახლა გვსურს დავრწმუნდეთ, რომ შეყვანის არის huffed თუ არა.

459
00:39:08,820 --> 00:39:16,420
ფიქრი თავში, იქ იყო არაფერი განაწილების კოდი, რომელიც შესაძლოა დაგვეხმაროს

460
00:39:16,420 --> 00:39:21,570
გაგებით თუ არა ფაილი huffed თუ არა?

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
ჩვენ ვიცით, რომ, მაგრამ ჩვენ ასევე მონაწილეობა peek at dump.c,

466
00:39:43,180 --> 00:39:49,120
რომელშიც იგი კითხულობს შევიდა დათუნა დათო დავით მგელაძე ფაილი.

467
00:39:49,120 --> 00:39:53,990
და ასე გავაკეთოთ, რომ მას მოუწია შეამოწმოს თუ არა ეს მართლაც huffed თუ არა.

468
00:39:53,990 --> 00:40:03,380
ასე რომ ალბათ ჩვენ შეგვიძლია გამოვიყენოთ dump.c როგორც სტრუქტურა ჩვენი puff.c.

469
00:40:03,380 --> 00:40:12,680
თავში pset 4 როდესაც გვქონდა ფაილი copy.c რომ გადაწერილი წელს RGB საწოლიანი

470
00:40:12,680 --> 00:40:14,860
და ჩვენ განმარტა, რომ ამისთვის Whodunit და შემცირება,

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
თუმცა, ეს არ იქნება, როგორც პირდაპირი of პროცესი

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
თუ როგორ უნდა უზრუნველყოს, რომ შეყვანის ფაქტობრივად huffed ან არ

477
00:40:40,540 --> 00:40:43,240
ასევე რამდენიმე სხვა რამ.

478
00:40:45,930 --> 00:40:50,250
ჩვენ უზრუნველყო სათანადო გამოყენება და დარწმუნდა, რომ შეყვანის არის huffed.

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
სწრაფი შეკითხვა: რამდენი ტყეების იქნება თქვენ გაქვთ როდესაც თქვენ აშენებთ Huffman ხე?

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 იმ კვანძების და შემდეგ შეცვალა იგი მეორე.

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
აშენება Huffman ნაძვის ხე, თქვენ ამ სიმბოლიკა და სიხშირეების მიზნით

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'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
და სპეც ნათქვამია გაუმკლავდეს მათ gracefully,

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
In რეზიუმე შემთხვევაში, თუ გვაქვს ლოგიკური ფუნქცია მოუწოდა 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
ჭეშმარიტია თუ წარმატებული, ცრუ თუ არა.

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 დააბრუნებს 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
Say foo იღებს in x.

550
00:46:39,320 --> 00:46:43,390
ჩვენ შეგვიძლია აქვს როგორც პირობით, თუ (foo (x)).

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
ასე რომ მაშინ ასე შეგიძლიათ გააკეთოთ რაიმე, თუ ფუნქცია დააბრუნებს true და წარმატებული.

555
00:47:06,500 --> 00:47:11,800
მაგრამ როდესაც თქვენ შეცდომა შემოწმება, თქვენ მხოლოდ გსურთ გასვლა, თუ თქვენი ფუნქცია დააბრუნებს false.

556
00:47:11,800 --> 00:47:16,090
რა შეიძლება გავაკეთოთ მხოლოდ დაამატოთ == ყალბი ან უბრალოდ დაამატოთ bang თვალწინ იგი

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 დაბრუნდა ცრუ -

561
00:47:43,340 --> 00:47:46,980
Say foo ბრუნდება ნამდვილი.

562
00:47:46,980 --> 00:47:51,060
მერე შენ არ უნდა მოვუწოდებთ foo ერთხელ. სწორედ საერთო misconception.

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
ერთხელ ჩვენ ავაშენებთ Huffman ხე, მაშინ წერილობით შეტყობინება ფაილი საკმაოდ მარტივია.

572
00:48:33,070 --> 00:48:39,260
ეს საკმაოდ მარტივია ახლა უბრალოდ მიჰყევით 0S და 1s.

573
00:48:39,260 --> 00:48:45,480
და ა.შ. მიერ კონვენციის ჩვენ ვიცით, რომ Huffman ხე 0S მიუთითებს დაუტოვებიათ

574
00:48:45,480 --> 00:48:48,360
და 1s მიუთითოს უფლება.

575
00:48:48,360 --> 00:48:53,540
ასე რომ თუ თქვენ წაიკითხონ ნელ bit, ყოველ ჯერზე, რომ თქვენ გაქვთ 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. >> Yeah.

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
ჩვენ ვიცით, რომ ჩვენ გვინდა, წაიკითხონ ნელ bit ჩვენს დათუნა დათო დავით მგელაძე ფაილი.

586
00:49:43,870 --> 00:49:51,220
როგორც დავინახეთ, მანამდე dump.c, რაც გააკეთეს არის მათ წაიკითხონ ნელ bit შევიდა დათუნა დათო დავით მგელაძე ფაილი

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
მაგრამ რა შეგვიძლია გავაკეთოთ არის შეგვიძლია ცოტა კოდი რომ წერია, რათა bit.

590
00:50:03,620 --> 00:50:10,250
აქ მთელი bit წარმოადგენს მიმდინარე ცოტა რომ ჩვენ შესახებ.

591
00:50:10,250 --> 00:50:15,520
ეს ზრუნავს iterating ყველა ბიტი ფაილში სანამ არ მოხვდა ფაილის ბოლოში.

592
00:50:15,520 --> 00:50:21,270
დაყრდნობით, რომ, მაშინ თქვენ აპირებს სურთ გარკვეული სახის iterator

593
00:50:21,270 --> 00:50:26,760
to traverse თქვენი ხე.

594
00:50:26,760 --> 00:50:31,460
და შემდეგ ეფუძნება თუ არა ცოტა არის 0 ან 1,

595
00:50:31,460 --> 00:50:36,920
თქვენ აპირებს გვინდა ან გადაადგილება რომ iterator მარცხნივ ან გადაიტანთ უფლება

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
რატომ ვერ ვაკეთებთ ამას Huffman ფაილის მაგრამ არა Morse კოდი?

599
00:50:54,300 --> 00:50:56,610
რადგან Morse კოდი იქ ცოტა გაურკვევლობა.

600
00:50:56,610 --> 00:51:04,440
ჩვენ შეიძლება იყოს, როგორიცაა, OH დაველოდოთ, ჩვენ მოხვდა წერილში გზაზე, იქნებ ეს ჩვენი წერილი,

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 ამისთვის malloc,

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
ეს არ არის მხოლოდ იქნება ზუსტად იმ დასასრულს მთავარი ფუნქცია, რომ თავი დაანებონ თქვენი კოდი.

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 on Puff და შემდეგ თქვენ უნდა ასევე მსგავ

638
00:54:09,460 --> 00:54:14,020
უფლება ხმების ბრძანება ხაზი არგუმენტები Valgrind.

639
00:54:14,020 --> 00:54:18,100
თქვენ შეგიძლიათ აწარმოებს, მაგრამ გამომავალი ოდნავ cryptic.

640
00:54:18,100 --> 00:54:21,630
ჩვენ მიღებული bit გამოიყენება იგი Speller, მაგრამ ჩვენ ჯერ კიდევ უფრო მეტი დახმარება,

641
00:54:21,630 --> 00:54:26,450
ასე შემდეგ გაშვებული იგი კიდევ რამდენიმე დროშები მოსწონს გაჟონვის-შეამოწმოთ = სრული,

642
00:54:26,450 --> 00:54:32,040
რომ სავარაუდოდ მოგვცემს უფრო გამოსადეგი გამომავალი on Valgrind.

643
00:54:32,040 --> 00:54:39,040
>> შემდეგ კიდევ ერთი სასარგებლო tip როცა თქვენ გამართვის არის 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
მაშინ, თუ თქვენ აწარმოებს თქვენი საკუთარი puff რომ ორობითი ფაილი,

647
00:54:59,440 --> 00:55:03,950
მაშინ იდეალურად, თქვენი outputted ტექსტური ფაილი იქნება იდენტური

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
>> თქვენ შეგიძლიათ კიდევ მიიღოს ესროლეს იქნებ compressing და შემდეგ decompressing

654
00:55:38,110 --> 00:55:41,600
ზოგიერთი ფაილი, რომელიც თქვენ გამოიყენება Speller მოსწონს ომისა და მშვიდობის

655
00:55:41,600 --> 00:55:46,710
ან Jane Austen ან რამე მაგდაგვარს - იქნებოდა სახის cool - ან Austin Powers,

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
გადადის დროშა-მ რეალურად აჩვენებს ზომა იმ ფაილი.

660
00:56:07,860 --> 00:56:12,690
თუ თქვენ გავლა pset Spec, ის რეალურად დადის თქვენ მეშვეობით შექმნით ორობითი ფაილი,

661
00:56:12,690 --> 00:56:16,590
საქართველოს huffing, და ხედავთ, რომ ძალიან მცირე ფაილები

662
00:56:16,590 --> 00:56:23,910
სივრცეში ღირებულება compressing და თარგმნა ყველა ამ ინფორმაციის

663
00:56:23,910 --> 00:56:26,980
ყველა სიხშირეებს და რამ, როგორიცაა, რომ outweighs ფაქტობრივი სარგებელი

664
00:56:26,980 --> 00:56:30,000
საქართველოს compressing ფაილის პირველი ადგილი.

665
00:56:30,000 --> 00:56:37,450
მაგრამ თუ თქვენ გაუშვით ზოგიერთ აღარ ტექსტური ფაილები, მაშინ თქვენ ალბათ ხედავთ, რომ თქვენ დაიწყოს მიიღოს გარკვეული სარგებელი

666
00:56:37,450 --> 00:56:40,930
წელს compressing იმ ფაილებს.

667
00:56:40,930 --> 00:56:46,210
>> და მაშინ საბოლოოდ, ჩვენ გვაქვს ჩვენი ძველი PAL GDB, რომელიც აუცილებლად აპირებს მოდის მოსახერხებელი ძალიან.

668
00:56:48,360 --> 00:56:55,320
>> გვაქვს რაიმე შეკითხვა დათუნა დათო დავით მგელაძე ხეები ან პროცესის ალბათ მიღების ხეები

669
00:56:55,320 --> 00:56:58,590
ან ნებისმიერ სხვა შეკითხვებს Huff'n Puff?

670
00:57:00,680 --> 00:57:02,570
Okay. მე დარჩენა გარშემო ამისთვის bit.

671
00:57:02,570 --> 00:57:06,570
>> ყველას დიდი მადლობა. ეს იყო Walkthrough 6. და კარგი იღბალი.

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