1
00:00:00,000 --> 00:00:02,210
[Powered by Google Translate] [Walkthrough - પ્રોબ્લેમ 6 સેટ]

2
00:00:02,210 --> 00:00:04,810
[Zamyla ચાન - હાર્વર્ડ યુનિવર્સિટી]

3
00:00:04,810 --> 00:00:07,240
[આ CS50 છે. - CS50.TV]

4
00:00:07,240 --> 00:00:12,180
>> હેલો, દરેકને, અને 6 Walkthrough સ્વાગત છે: Huff'n દોડ્યા પછી એકદમ હાંફવું.

5
00:00:12,180 --> 00:00:17,440
Huff'n દોડ્યા પછી એકદમ હાંફવું શું આપણે કરી રહ્યા છે એક હફમેનના કોમ્પ્રેસ્ડ ફાઇલ સાથે વ્યવહાર કરવામાં રહ્યું છે

6
00:00:17,440 --> 00:00:20,740
અને તે પછી તેને ફરીથી અપ puffing છે, તેથી તેને decompressing,

7
00:00:20,740 --> 00:00:25,810
જેથી અમે 0s અને 1 સે કે વપરાશકર્તા અમને મોકલે માંથી અનુવાદ કરી શકો છો

8
00:00:25,810 --> 00:00:30,660
અને તે મૂળ લખાણ પાછું ફેરવી શકાય છે.

9
00:00:30,660 --> 00:00:34,360
Pset માટે 6 સરસ પ્રયત્ન રહ્યું છે કારણ કે તમે સાધનો કેટલાક જોવા જઈ રહ્યાં છો

10
00:00:34,360 --> 00:00:41,730
કે તમે તેમને 1 સુંદર સુઘડ ખ્યાલ માં સંયોજિત 4 pset અને 5 pset અને પ્રકારનો ઉપયોગ

11
00:00:41,730 --> 00:00:43,830
જ્યારે તમે એના વિશે વિચારો આવે છે.

12
00:00:43,830 --> 00:00:50,110
>> પણ, દાવાપૂર્વક, 4 અને 5 pset સૌથી પડકારરૂપ 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 દોડ્યા પછી એકદમ હાંફવું માટે ખસેડવું, આ 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
હફમેનના વૃક્ષો દ્વિસંગી વૃક્ષો છે, જેનો અર્થ છે કે દરેક નોડ માત્ર 2 સંતાનો છે.

36
00:02:19,600 --> 00:02:24,870
હફમેનના વૃક્ષો માં લાક્ષણિકતા એ છે કે મોટા ભાગના વારંવાર કિંમતો

37
00:02:24,870 --> 00:02:27,140
આવે છે સૌથી ઓછા બિટ્સ દ્વારા રજૂ કરે છે.

38
00:02:27,140 --> 00:02:32,690
અમે મોર્સ કોડ વ્યાખ્યાન ઉદાહરણો માટે, એકત્રિત પ્રકારની છે કે જે અમુક પત્રો જોવા મળી હતી.

39
00:02:32,690 --> 00:02:38,030
જો તમે એક અથવા ઉદાહરણ તરીકે ઇ, અનુવાદ કરવાનો પ્રયાસ કરી રહ્યાં છો,

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
પછી તમે 2 નીચા આવર્તનના જોવા માટે અને પછી તેમને ભાઈ તરીકે જોડાવા

55
00:03:49,060 --> 00:03:55,660
પછી જ્યાં પિતૃ ગાંઠ આવૃત્તિ કે જેની તેની 2 બાળકોના રકમ છે.

56
00:03:55,660 --> 00:04:00,870
અને તમે સંમેલન દ્વારા પછી કહે છે કે ડાબી નોડ,

57
00:04:00,870 --> 00:04:03,770
તમે 0 શાખા અનુસરીને કે અનુસરો,

58
00:04:03,770 --> 00:04:08,140
અને પછી જમણીબાજુનીસ્થિતિ ગાંઠની 1 શાખા છે.

59
00:04:08,140 --> 00:04:16,040
આપણે મોર્સ કોડ માં જોયું, તે એક gotcha હતો કે જો તમે માત્ર એક બીપ Comment અને બીપ Comment હતી

60
00:04:16,040 --> 00:04:18,120
તે અસ્પષ્ટ હતો.

61
00:04:18,120 --> 00:04:22,430
તે ક્યાં તો 1 પત્ર હોઈ શકે છે અથવા તે કરી શકે 2 અક્ષરોના ક્રમ હોઈ શકે છે.

62
00:04:22,430 --> 00:04:27,790
અને તેથી હફમેનના વૃક્ષો કરે છે શું છે તે અક્ષરો સ્વભાવ દ્વારા કારણ કે

63
00:04:27,790 --> 00:04:34,140
અથવા અમારી અંતિમ વાસ્તવિક શાખા પર છેલ્લા ગાંઠો છે અક્ષરો -

64
00:04:34,140 --> 00:04:39,300
અમે પાન તરીકે લોકો માટે નો સંદર્ભ લો - કે સદ્ગુણ દ્વારા કોઇ અસ્પષ્ટતા ન હોઈ શકે

65
00:04:39,300 --> 00:04:45,160
શરતો પત્ર જે તમે બિટ્સ ની શ્રેણી સાથે બેવડી પ્રયાસ કરી રહ્યા છો માં

66
00:04:45,160 --> 00:04:50,670
કારણ કે બિટ્સ કે 1 પત્ર પ્રતિનિધિત્વ સાથે ક્યાંય

67
00:04:50,670 --> 00:04:55,960
તમે અન્ય સંપૂર્ણ પત્ર મળે છે, અને કોઇ મૂંઝવણ ત્યાં હશે નહિં.

68
00:04:55,960 --> 00:04:58,430
પરંતુ અમે ઉદાહરણો જાય છે કે તમે ગાય્ઝ ખરેખર જોઈ શકો છો કરીશું કે

69
00:04:58,430 --> 00:05:02,120
બદલે અમને હમણાં જ તમને કહેવાની કે જે સાચું છે.

70
00:05:02,120 --> 00:05:06,390
>> ચાલો એક હફમેનના વૃક્ષ એક સરળ ઉદાહરણ જુઓ.

71
00:05:06,390 --> 00:05:09,380
હું અહીં એક શબ્દમાળા કે 12 અક્ષર લાંબો છે.

72
00:05:09,380 --> 00:05:14,010
હું જેમ, 6 bs અને 2 સીએસ 4 છે.

73
00:05:14,010 --> 00:05:17,270
મારી પ્રથમ પગલું ગણતરી હશે.

74
00:05:17,270 --> 00:05:20,760
કેટલી વખત એ દેખાતું નથી? તે શબ્દમાળા માં 4 વખત દેખાય છે.

75
00:05:20,760 --> 00:05:25,060
બી 6 વખત દેખાય છે, અને C 2 વખત દેખાય છે.

76
00:05:25,060 --> 00:05:28,970
કુદરતી રીતે, હું કહેવા હું બી ઉપયોગ કરું છું, મોટે ભાગે જાઉં છું,

77
00:05:28,970 --> 00:05:35,970
તેથી હું બિટ્સ ના સૌથી ઓછા નંબર, 0s અને 1 સે ના સૌથી ઓછા નંબર સાથે બી પ્રતિનિધિત્વ કરવા માંગો છો.

78
00:05:35,970 --> 00:05:42,600
અને પછી હું પણ સી 0s અને 1 સે સૌથી જથ્થો જરૂર તેમજ અપેક્ષા જાઉં છું.

79
00:05:42,600 --> 00:05:48,550
પ્રથમ હું શું અહીં કર્યું હું આવર્તન દ્રષ્ટિએ ચડતા ક્રમમાં છે તેમને મૂકવામાં આવે છે.

80
00:05:48,550 --> 00:05:52,710
અમે જુઓ કે સી અને એ, તે અમારી 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 અનુસરવા સી મેળવવા કરશે

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
અહીં આપણે હફમેનના વૃક્ષ હોય છે

92
00:06:36,300 --> 00:06:40,020
જ્યાં બી મેળવવા માટે, કે જે ફક્ત 1 બીટ હશે

93
00:06:40,020 --> 00:06:45,430
અને પછી એ વિચાર અમે 01 હોય છે અને તે પછી થશે સી 00 હોય છે.

94
00:06:45,430 --> 00:06:51,300
અહીં અમે જુઓ કે મૂળભૂત રીતે આપણે ક્યાં 1 અથવા 2 બીટ્સ સાથે આ અક્ષરો રજૂ કરી રહ્યા છીએ

95
00:06:51,300 --> 00:06:55,160
જ્યાં બી, આગાહી, ઓછામાં ઓછી હોય છે.

96
00:06:55,160 --> 00:07:01,730
અને પછી અમે સી સૌથી વધુ હોય તેવી અપેક્ષા હતી, પરંતુ કારણ કે તે આવા નાના હફમેનના વૃક્ષ છે,

97
00:07:01,730 --> 00:07:06,020
પછી એ પણ 2 તરીકે મધ્યમાં ક્યાંક વિરોધ બિટ્સ દ્વારા રજૂ થાય છે.

98
00:07:07,820 --> 00:07:11,070
>> ફક્ત હફમેનના વૃક્ષ બીજા સરળ ઉદાહરણ પર જાઓ,

99
00:07:11,070 --> 00:07:19,570
કહેવું તમે શબ્દમાળા ધરાવે છે "હેલો."

100
00:07:19,570 --> 00:07:25,360
તમે શું પ્રથમ છે તમે કહ્યું કેટલી વખત એચ આ દેખાતું નથી?

101
00:07:25,360 --> 00:07:34,200
એચ દેખાય વાર અને પછી ઈ દેખાય વાર અને પછી અમે બે વખત દેખાય છે l છે

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
[વિદ્યાર્થી] l. >> L. યાહ. l અધિકાર છે.

105
00:07:47,450 --> 00:07:50,730
અમે l બિટ્સ ના ઓછામાં ઓછા નંબર દ્વારા રજૂ એવી અપેક્ષા રાખે છે

106
00:07:50,730 --> 00:07:55,890
કારણ કે l સૌથી શબ્દમાળા ઉપયોગ થાય છે "હેલો."

107
00:07:55,890 --> 00:08:04,280
મારે શું હવે કરવા જાઉં છું આ ગાંઠો દોરવા છે.

108
00:08:04,280 --> 00:08:15,580
હું 1 છે, કે જે એચ છે, અને પછી 1 અન્ય, જે ઈ છે તો પછી અને 1 એ છે, કે જે ઓ છે -

109
00:08:15,580 --> 00:08:23,410
હમણાં હું તેમને ક્રમમાં મૂકી રહ્યો છું - અને પછી 2, કે જે l છે.

110
00:08:23,410 --> 00:08:32,799
પછી હું કહું છું કે જે રીતે હું હફમેનના વૃક્ષ બીલ્ડ કરવા માટે ઓછામાં ઓછું આવર્તન સાથે 2 ગાંઠો શોધે છે

111
00:08:32,799 --> 00:08:38,010
અને તેમને પિતૃ નોડ બનાવીને ભાઈ બનાવે છે.

112
00:08:38,010 --> 00:08:41,850
અહીં અમે સૌથી ઓછી આવૃત્તિ સાથે 3 ગાંઠો હોય છે. તેઓ 1 બધા છો.

113
00:08:41,850 --> 00:08:50,620
અહીં અમે પસંદ કરો કે જે એક આપણે પ્રથમ લિંક રહ્યા છીએ.

114
00:08:50,620 --> 00:08:54,850
હવે કહો કે હું એચ અને ઈ પસંદ કરો.

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
1 સે હંમેશા અધિકાર શાખા અને 0s છે ડાબી એક છે.

123
00:09:37,480 --> 00:09:45,880
પછી અમે 2 દ્વારા માત્ર 1 અને પછી બિટ ઓ દ્વારા રજૂ l છે

124
00:09:45,880 --> 00:09:52,360
અને પછી 2 દ્વારા ઈ અને પછી એચ 3 બિટ્સ માટે નીચે પડે છે.

125
00:09:52,360 --> 00:09:59,750
તેથી તમે આ સંદેશો પ્રસારિત "હેલો" ને બદલે હકીકતમાં અક્ષરોનો ઉપયોગ

126
00:09:59,750 --> 00:10:02,760
માત્ર 0s અને 1 સે દ્વારા.

127
00:10:02,760 --> 00:10:07,910
જોકે યાદ રાખો કે ઘણા કિસ્સાઓમાં આપણે આવૃત્તિ સાથે જોડાણ કર્યું.

128
00:10:07,910 --> 00:10:11,900
અમે ક્યાં તો એચ અને ઓ પ્રથમ કદાચ છે જોડાયા શકે છે.

129
00:10:11,900 --> 00:10:15,730
અથવા ત્યાર બાદ જ્યારે અમે 2 દ્વારા રજૂ l હતી

130
00:10:15,730 --> 00:10:19,410
તેમજ એક 2 દ્વારા રજૂ જોડાયા, અમે એક ક્યાં કડી થયેલ હોઈ શકે છે.

131
00:10:19,410 --> 00:10:23,630
>> અને એટલે જ્યારે તમે મોકલો 0s અને 1 સે, કે જે વાસ્તવમાં બાંહેધરી નથી આપતું

132
00:10:23,630 --> 00:10:27,090
કે પ્રાપ્તકર્તા સંપૂર્ણપણે બેટ બોલ અધિકાર તમારો સંદેશ વાંચી શકે છે

133
00:10:27,090 --> 00:10:30,490
કારણ કે તેઓ જાણતા ન શકે નિર્ણય કે જે તમે બનાવી હતી.

134
00:10:30,490 --> 00:10:34,920
તેથી જ્યારે અમે હફમેનના સંકોચન સાથે કામ કરીએ છીએ,

135
00:10:34,920 --> 00:10:40,090
કોઈક અમે અમારા સંદેશો મેળવનાર અમે કેવી રીતે નક્કી કર્યું કહેવું હોય -

136
00:10:40,090 --> 00:10:43,470
તેઓ વધારે માહિતી માટે અમુક પ્રકારના જાણવાની જરૂર છે

137
00:10:43,470 --> 00:10:46,580
સંકુચિત સંદેશા માટે વધુમાં છે.

138
00:10:46,580 --> 00:10:51,490
તેઓ સમજવા માટે વૃક્ષ શું ખરેખર આના જેવું દેખાય છે જરૂર છે,

139
00:10:51,490 --> 00:10:55,450
અમે કેવી રીતે વાસ્તવમાં તે નિર્ણયો કર્યા છે.

140
00:10:55,450 --> 00:10:59,100
>> અહીં અમે ફક્ત વાસ્તવિક ગણતરી પર આધારિત ઉદાહરણો કરી રહ્યા હતા,

141
00:10:59,100 --> 00:11:01,550
પરંતુ ક્યારેક તમે પણ હફમેનના વૃક્ષ થઈ શકે છે

142
00:11:01,550 --> 00:11:05,760
આવર્તન પર આધારિત છે કે અક્ષરો દેખાય છે, અને તે ચોક્કસ જ પ્રક્રિયા છે.

143
00:11:05,760 --> 00:11:09,090
અહીં હું તે ટકાવારી અથવા અપૂર્ણાંક દ્રષ્ટિએ વ્યકત છું,

144
00:11:09,090 --> 00:11:11,290
અને તેથી અહીં ચોક્કસ જ વાત.

145
00:11:11,290 --> 00:11:15,300
હું 2 સૌથી નીચો તેમને સરવાળો, આગામી સૌથી નીચો 2, તેમને સરવાળો શોધવા માટે,

146
00:11:15,300 --> 00:11:19,390
ત્યાં સુધી હું સંપૂર્ણ વૃક્ષ હોય છે.

147
00:11:19,390 --> 00:11:23,610
તેમ છતાં અમે તે કાં તો તે રીતે, જ્યારે અમે ટકાવારી સાથે કામ કરીએ છીએ કરી શકે છે,

148
00:11:23,610 --> 00:11:27,760
તેનો અર્થ એ કે અમે વસ્તુઓ વિભાજન કરી રહ્યાં છો અને દશાંશ સાથે વ્યવહાર અથવા બદલે તરે

149
00:11:27,760 --> 00:11:30,900
જો અમે માથામાં માહિતી માળખાં વિશે વિચારી રહ્યાં છો.

150
00:11:30,900 --> 00:11:32,540
અમે શું ફ્લોટ્સ વિશે જાણો છો?

151
00:11:32,540 --> 00:11:35,180
એક સામાન્ય સમસ્યા જ્યારે અમે ફ્લોટ્સ સાથે વ્યવહાર કરી રહ્યા છો શું છે?

152
00:11:35,180 --> 00:11:38,600
[વિદ્યાર્થી] અશુદ્ધ અંકગણિત. >> યાહ. અશુદ્ધિ.

153
00:11:38,600 --> 00:11:43,760
અપૂર્ણાંક બિંદુ અશુદ્ધિ કારણે, આ pset માટે કે જેથી અમે ખાતરી કરો

154
00:11:43,760 --> 00:11:49,450
કે અમે કોઈ કિંમતો ગુમાવી નથી, તો પછી અમે ખરેખર ગણના સાથે વ્યવહાર કરવામાં જઈ રહ્યાં છો.

155
00:11:49,450 --> 00:11:54,880
તેથી જો તમે હફમેનના નોડ લાગે છે, જો તમે માળખું માટે અહીં જોવા હતા,

156
00:11:54,880 --> 00:12:01,740
જો તમે ગ્રીન મુદ્દાઓ જુઓ તે તેની સાથે સંકળાયેલ આવર્તન ધરાવે છે

157
00:12:01,740 --> 00:12:08,760
તેમજ તેની ડાબી નોડ તેમજ તેની જમણી નોડ નિર્દેશ કરે છે.

158
00:12:08,760 --> 00:12:13,970
અને પછી લાલ મુદ્દાઓ પણ તેમની સાથે સંકળાયેલ પાત્ર હોય છે.

159
00:12:13,970 --> 00:12:18,900
અમે પછી અને માતા - પિતા અંતિમ ગાંઠો માટે અલગ મુદ્દાઓ બનાવી નથી જઈ રહ્યાં છો,

160
00:12:18,900 --> 00:12:23,680
જે અમે પાન તરીકે નો સંદર્ભ લો, પરંતુ તે માત્ર નલ કિંમતો હશે.

161
00:12:23,680 --> 00:12:31,050
દરેક નોડ માટે અમે એક અક્ષર, તો સંજ્ઞા કે જે નોડ રજૂ પડશે,

162
00:12:31,050 --> 00:12:40,490
પછી તેમજ તેની ડાબી તેમજ તેના અધિકાર બાળક બાળક માટે નિર્દેશક આવૃત્તિ છે.

163
00:12:40,490 --> 00:12:45,680
પાંદડા, જે ખૂબ જ તળિયે છે પણ નોડ પોઇંટરો હશે

164
00:12:45,680 --> 00:12:49,550
તેમની ડાબી અને તેમના અધિકાર છે, પરંતુ તે કિંમતો વાસ્તવિક ગાંઠો નથી પોઇન્ટ છે, કારણ

165
00:12:49,550 --> 00:12:53,970
તેમની કિંમત શું હશે? >> [વિદ્યાર્થી] NULL. >> NULL. બરાબર.

166
00:12:53,970 --> 00:12:58,430
અહીં તમે કેવી રીતે ફ્લોટ્સ માં આવર્તન પ્રતિનિધિત્વ કરી શકે છે તેનું ઉદાહરણ છે,

167
00:12:58,430 --> 00:13:02,130
પણ અમે તેની સાથે પૂર્ણાંકો સાથે વ્યવહાર કરવામાં જઈ રહ્યાં છો,

168
00:13:02,130 --> 00:13:06,780
તેથી હું કર્યું છે દશાંશ માહિતી પ્રકાર ત્યાં બદલો.

169
00:13:06,780 --> 00:13:09,700
>> ચાલો થોડો જટીલ ઉદાહરણ વધુ પર જાઓ.

170
00:13:09,700 --> 00:13:13,360
પરંતુ હવે અમે સરળ મુદ્દાઓ કર્યું છે, તે માત્ર એ જ પ્રક્રિયા છે.

171
00:13:13,360 --> 00:13:20,290
તમે 2 નીચા આવર્તનના શોધવા માટે, આવૃત્તિઓ સરવાળો

172
00:13:20,290 --> 00:13:22,450
અને જે તમારા પિતૃ નોડને નવા આવૃત્તિ છે,

173
00:13:22,450 --> 00:13:29,310
જે પછી 0 અને 1 શાખા સાથે યોગ્ય શાખા સાથે તેના ડાબા નિર્દેશ કરે છે.

174
00:13:29,310 --> 00:13:34,200
જો અમે શબ્દમાળા "આ cs50 છે," હોય તો પછી અમે ગણતરી કેટલી વખત ટી ઉલ્લેખ કર્યો છે,

175
00:13:34,200 --> 00:13:38,420
ક ઉલ્લેખ કર્યો છે, આઇ, એસ, સી, 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
તે બે 1 સે છે, અને પછી તે 2 તેમજ બની જાય છે.

186
00:14:26,100 --> 00:14:31,570
હવે હું જાણું છું કે મારા આગળનું પગલું એ સૌથી નીચો નંબર જોડાયા કરી રહ્યું છે,

187
00:14:31,570 --> 00:14:41,380
જે ટી છે, 1 છે, અને પછી એક નોડ કે જે આવૃત્તિ 2 પ્રમાણે હોય પસંદ કરીને.

188
00:14:41,380 --> 00:14:44,560
અહીં અમે 3 વિકલ્પો હોય છે.

189
00:14:44,560 --> 00:14:47,980
મારે શું સ્લાઇડ માટે કરવા જાઉં છું ફક્ત દૃષ્ટિની છે તેમને તમે ફરીથી ગોઠવવા

190
00:14:47,980 --> 00:14:51,790
જેથી તમે જોઈ શકો છો કે હું કેવી રીતે તે મકાન છું છે.

191
00:14:51,790 --> 00:14:59,040
કોડ અને તમારા વિતરણ કોડ શું રહ્યું છે ટી એક જોડાવા આવશે

192
00:14:59,040 --> 00:15:01,410
0 ની અને 5 નોડ છે.

193
00:15:01,410 --> 00:15:05,060
તેથી પછી તે 3 થી સંક્ષિપ્તમાં કહેવાયું હતું, અને તે પછી અમે પ્રક્રિયા ચાલુ રાખો.

194
00:15:05,060 --> 00:15:08,660
આ 2 અને 2 હવે સૌથી નીચો છે, તેથી તે પછી 4 તે રકમ.

195
00:15:08,660 --> 00:15:12,560
દરેક વ્યક્તિને અત્યાર સુધી નીચેના? ઠીક છે.

196
00:15:12,560 --> 00:15:16,410
પછી તે પછી અમે 3 અને 3 તે ઉમેરો કરવાની જરૂર હોય,

197
00:15:16,410 --> 00:15:21,650
જેથી ફરીથી હું હમણાં જ તે સ્વિચ છું કે જેથી તમે દૃષ્ટિની જેથી જુઓ કે તે ખૂબ અવ્યવસ્થિત ન મળી નથી કરી શકો છો.

198
00:15:21,650 --> 00:15:25,740
તો પછી અમે 6 એક છે, અને તે પછી અમારા અંતિમ પગલું હવે એ છે કે અમે માત્ર 2 ગાંઠો હોય છે

199
00:15:25,740 --> 00:15:30,440
અમે તે સંક્ષેપમાં અમારા વૃક્ષ છે, જે 10 છે જે રુટ બનાવે છે.

200
00:15:30,440 --> 00:15:34,100
અને 10 નંબર અર્થમાં બનાવે છે કારણ કે દરેક નોડ રજૂ,

201
00:15:34,100 --> 00:15:40,750
તેમની કિંમત, તેમના આવૃત્તિ નંબર હતો કેટલી વખત તેઓ શબ્દમાળા માં દેખાયા હતા,

202
00:15:40,750 --> 00:15:46,350
અને પછી અમે અમારી શબ્દમાળામાં 5 અક્ષરો છે, તેથી તે અર્થમાં બનાવે છે.

203
00:15:48,060 --> 00:15:52,320
જો અમે અમે કેવી રીતે વાસ્તવમાં તે બેવડી કરશે ઉપર જુઓ,

204
00:15:52,320 --> 00:15:56,580
ઈચ્છિત તરીકે, તો હું અને ઓ, કે જે મોટે ભાગે દેખાશે

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
એક મોટા એસ એક લોઅરકેસ ઓ કરતાં અલગ છે.

209
00:16:13,670 --> 00:16:21,260
જો આપણે મૂડી અક્ષરો સાથે "આ CS50 છે", પછી નાના ઓ માત્ર બે વખત દેખાય છે,

210
00:16:21,260 --> 00:16:27,120
2 તેની કિંમત તરીકે સાથે નોડ હશે, અને પછી એસ મોટા માત્ર એક વાર જ હશે.

211
00:16:27,120 --> 00:16:33,440
તેથી પછી તમારા વૃક્ષ માળખાં બદલવા કારણ કે તમે ખરેખર વધારાનો પર્ણ અહીં હશે.

212
00:16:33,440 --> 00:16:36,900
પરંતુ રકમ હજુ 10 હશે.

213
00:16:36,900 --> 00:16:39,570
કે અમે ખરેખર શું પછી ચકાસણીની કૉલ કરી રહ્યા છીએ,

214
00:16:39,570 --> 00:16:44,060
આ ગુનામાં તમામ વધુમાં.

215
00:16:46,010 --> 00:16:50,990
>> હવે અમે હફમેનના વૃક્ષો આવરી લીધી છે, અમે Huff'n દોડ્યા પછી એકદમ હાંફવું છે, pset માં ડાઇવ કરી શકો છો.

216
00:16:50,990 --> 00:16:52,900
અમે પ્રશ્નો વિભાગ સાથે શરૂ જઈ રહ્યાં છો,

217
00:16:52,900 --> 00:16:57,990
અને આ વિચાર તમે બાઈનરી વૃક્ષો અને તે આસપાસ કામ કેવી રીતે પરિચિત રહ્યું છે:

218
00:16:57,990 --> 00:17:03,230
રેખાંકન ગાંઠો, નોડ માટે તમારા પોતાના typedef સ્ટ્રક્ટ બનાવવા માટે,

219
00:17:03,230 --> 00:17:07,230
અને જોઈ તમે કેવી રીતે દ્વિસંગી વૃક્ષ, એક કે છટણી છે દાખલ કરી શકે છે,

220
00:17:07,230 --> 00:17:09,050
તે છે, અને તે જેવી વસ્તુઓ સરકાઉ.

221
00:17:09,050 --> 00:17:14,560
જ્ઞાન કે ચોક્કસપણે તમને જ્યારે તમે Huff'n દોડ્યા પછી એકદમ હાંફવું ભાગ માં ડાઈવ મદદ રહ્યું છે

222
00:17:14,560 --> 00:17:17,089
આ pset છે.

223
00:17:19,150 --> 00:17:26,329
આ pset પ્રમાણભૂત આવૃત્તિ, તમારા કાર્ય માટે દોડ્યા પછી એકદમ હાંફવું અમલમાં છે,

224
00:17:26,329 --> 00:17:30,240
અને હેકર આવૃત્તિ તમારા કાર્ય માટે મિજાજ અમલમાં છે.

225
00:17:30,240 --> 00:17:38,490
રીસ શું કરે છે તે લખાણ લે છે અને પછી તેને 0s અને 1 સે રૂપાંતર

226
00:17:38,490 --> 00:17:41,990
જેથી પ્રક્રિયા કે અમે ઉપર હતી જ્યાં અમે ફ્રીક્વન્સીઝ ગણાશે

227
00:17:41,990 --> 00:17:50,970
અને પછી વૃક્ષ કરી અને પછી જણાવ્યું હતું કે, "હું ટી કેવી રીતે મેળવી શકું?"

228
00:17:50,970 --> 00:17:54,840
ટી 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 અને 1 સે એક દ્વિસંગી ફાઈલ આપવામાં આવે છે

233
00:18:17,980 --> 00:18:21,740
અને પણ ફ્રિક્વન્સીના વિશે જાણકારી આપવામાં આવે છે.

234
00:18:21,740 --> 00:18:26,740
અમે મૂળ સંદેશ કે હતો તે 0s અને 1 સે પાછા બધા અનુવાદ કરો,

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
અને પછી એ તમારા ઈનપુટ તરીકે કે આઉટપુટ વાપરવા માટે દોડ્યા પછી એકદમ હાંફવું.

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
અને તે અન્ય લોકોની કોડ reading માટે ઉપયોગ કરો ઉપયોગી છે.

250
00:19:38,940 --> 00:19:48,270
>> Huffile.h અંતે છીએ, ટિપ્પણીઓ તેને હફમેનના કોડેડ ફાઈલો માટે અમૂર્તનો સ્તર જાહેર.

251
00:19:48,270 --> 00:20:01,660
જો અમે નીચે જાય છે, અમે જુઓ કે ત્યાં 256 પ્રતીકો મહત્તમ કે અમે કોડ માટે જરૂર પડી શકે છે છે.

252
00:20:01,660 --> 00:20:05,480
મોટા અને નાના - આ મૂળાક્ષરો તમામ અક્ષરો સમાવે છે -

253
00:20:05,480 --> 00:20:08,250
અને પછી સંજ્ઞાઓ અને નંબરો, વગેરે

254
00:20:08,250 --> 00:20:11,930
પછી અહીં અમે જાદુ ફાઇલ હફમેનના કોડેડ ઓળખવા નંબર હોય છે.

255
00:20:11,930 --> 00:20:15,890
એક હફમેનના કોડ અંદર તેઓ ચોક્કસ જાદુ નંબર હોય રહ્યા છીએ

256
00:20:15,890 --> 00:20:18,560
હેડર સાથે સંકળાયેલું છે.

257
00:20:18,560 --> 00:20:21,110
આ માત્ર એક રેન્ડમ જાદુ નંબર લાગતો શકે છે,

258
00:20:21,110 --> 00:20:27,160
પરંતુ જો તમે ખરેખર તે ASCII અનુવાદિત, પછી તે ખરેખર બહાર મિજાજ બેસે.

259
00:20:27,160 --> 00:20:34,290
અહીં અમે એક ફાઇલ હફમેનના-encoded માટે સ્ટ્રક્ટ છે.

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
પહેલાં, અમે કોઈ રન નોંધાયો માત્ર fclose સાથે વ્યવહાર કરવામાં આવી હતી,

276
00:21:57,290 --> 00:22:01,190
પરંતુ જ્યારે તમે એક મિજાજ ફાઈલ હોય, તો તેના બદલે fclosing ઓફ

277
00:22:01,190 --> 00:22:06,080
તમે ખરેખર કરવા જઈ રહ્યાં છો શું છે hfclose અને તે hfopen.

278
00:22:06,080 --> 00:22:13,220
જે લોકો આ રીસ ફાઇલો ચોક્કસ કાર્યો કે અમે સાથે કામ કરી રહ્યા છીએ છે.

279
00:22:13,220 --> 00:22:19,230
પછી અહીં અમે હેડરમાં વાંચો અને પછી હેડર લખો.

280
00:22:19,230 --> 00:22:25,700
>> આ ક. ફાઈલ વાંચવાથી દ્વારા જસ્ટ અમે મિજાજ ફાઈલ શું હોઈ શકે એક અર્થમાં વિચાર પ્રકારની કરી શકો છો,

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
અમે તે પ્રતીક છે, આવૃત્તિ, અને પછી 2 નોડ તારાઓ પાસે અપેક્ષા રાખીએ છીએ.

293
00:23:38,360 --> 00:23:41,870
આ કિસ્સામાં અમે કરી રહ્યા છીએ શું છે આ અનિવાર્યપણે છે તે જ

294
00:23:41,870 --> 00:23:46,880
તેના બદલે ગાંઠની સિવાય અમે તેમને વૃક્ષો કહી રહ્યા છીએ.

295
00:23:48,790 --> 00:23:56,760
અમે એક કાર્ય છે કે જ્યારે તમે વૃક્ષ બનાવે કહી તે તમને એક વૃક્ષ નિર્દેશક આપે છે.

296
00:23:56,760 --> 00:24:03,450
સ્પેલર પાછળ, જ્યારે તમે એક નવો નોડ બની ગઇ હતી

297
00:24:03,450 --> 00:24:11,410
તમે કહ્યું હતું કે નોડ * નવો શબ્દ = (sizeof) malloc અને તે જેવી વસ્તુઓ.

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
આ 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
આ શું કરે છે તે recursively વૃક્ષ ડાબી નોડ પર વૃક્ષ દૂર કરવા કહે છે

312
00:25:29,560 --> 00:25:31,650
તેમજ યોગ્ય નોડ તરીકે.

313
00:25:31,650 --> 00:25:37,790
તે પહેલાં પિતૃ મુક્ત કરે છે, તે બાળકો તેમજ મુક્ત કરવાની જરૂર છે.

314
00:25:37,790 --> 00:25:42,770
પિતૃ પણ છે મૂળ સાથે વિનિમયક્ષમ.

315
00:25:42,770 --> 00:25:46,500
મહાન-મહાન-મહાન-પરદાદા જેવા કે જેથી પ્રથમ પિતૃ,

316
00:25:46,500 --> 00:25:52,130
અથવા દાદી વૃક્ષ, પ્રથમ અમે નીચે સ્તર પ્રથમ મુક્ત હોય છે.

317
00:25:52,130 --> 00:25:58,490
જેથી નીચે પસાર, મફત તે અને પછી પાછા આવો અપ, મફત તે વગેરે,

318
00:26:00,400 --> 00:26:02,210
જેથી વૃક્ષ છે.

319
00:26:02,210 --> 00:26:04,240
>> હવે અમે વન જુઓ.

320
00:26:04,240 --> 00:26:09,860
વન છે કે જ્યાં તમે તમારા હફમેનના વૃક્ષો બધા મૂકો.

321
00:26:09,860 --> 00:26:12,910
એ કહ્યા છે કે અમે કંઈક જઈ રહ્યાં છો કહેવાતા પ્લોટ

322
00:26:12,910 --> 00:26:22,320
કે એક વૃક્ષ પર એક નિર્દેશક તેમજ આગામી કહેવાય પ્લોટ માટે નિર્દેશક ધરાવે છે.

323
00:26:22,320 --> 00:26:28,480
શું માળખું જેવા દેખાવ આ પ્રકારની કરે છે?

324
00:26:29,870 --> 00:26:32,490
તે પ્રકારની છે કે ત્યાં કહે બનાવ્યા.

325
00:26:34,640 --> 00:26:36,700
અહીં બનાવ્યા.

326
00:26:37,340 --> 00:26:39,170
એક કડી થયેલ યાદી.

327
00:26:39,170 --> 00:26:44,590
અમે જુઓ કે જ્યારે અમે પ્લોટ હોય તે પ્લોટ એક કડી થયેલ યાદી જેવું છે.

328
00:26:44,590 --> 00:26:53,020
એક વન પ્લોટ એક કડી થયેલ યાદી તરીકે વ્યાખ્યાયિત થયેલ છે,

329
00:26:53,020 --> 00:26:58,100
અને તેથી વન માળખું છે અમે અમારા પ્રથમ પ્લોટ માટે કરી રહ્યાં છો એક નિર્દેશક હોય જઈને

330
00:26:58,100 --> 00:27:02,740
અને તે પ્લોટ તેની અંદર એક વૃક્ષ હોય અથવા તેના બદલે એક વૃક્ષ નિર્દેશ

331
00:27:02,740 --> 00:27:06,190
અને પછી આગામી પ્લોટ નિર્દેશ પર તેથી અને તેથી આગળ.

332
00:27:06,190 --> 00:27:11,100
એક વન બનાવવા અમે mkforest કૉલ કરો.

333
00:27:11,100 --> 00:27:14,930
પછી અમે કેટલીક ખૂબ ઉપયોગી કાર્યો અહીં છે.

334
00:27:14,930 --> 00:27:23,240
અમે પસંદ હોય છે જ્યાં તમે એક વન પાસ કરો અને પછી પરત કિંમત એક વૃક્ષ * છે,

335
00:27:23,240 --> 00:27:25,210
એક વૃક્ષ પર એક નિર્દેશક.

336
00:27:25,210 --> 00:27:29,370
ચૂંટેલા કરશે શું છે તે જંગલ જવા કરશે કે તમે પોઇન્ટ કરી રહ્યાં છો

337
00:27:29,370 --> 00:27:35,240
પછી સૌથી નીચા આવૃત્તિ સાથે જંગલ માંથી એક વૃક્ષ દૂર

338
00:27:35,240 --> 00:27:38,330
અને પછી તમે તે વૃક્ષ માટે નિર્દેશક આપે છે.

339
00:27:38,330 --> 00:27:43,030
એકવાર તમે પસંદ કૉલ, વૃક્ષ જંગલ માં હવે અસ્તિત્વમાં રહેશે,

340
00:27:43,030 --> 00:27:48,550
પરંતુ વળતર કિંમત છે કે જે વૃક્ષ માટે નિર્દેશક છે.

341
00:27:48,550 --> 00:27:50,730
પછી તમે પ્લાન્ટ ધરાવે છે.

342
00:27:50,730 --> 00:27:57,420
કે તમે નિર્દેશક એક વૃક્ષ કે જે આવૃત્તિ બિન 0 ધરાવે છે પસાર છે,

343
00:27:57,420 --> 00:28:04,040
પ્લાન્ટ કરશે શું છે તે જંગલ લાગી, વૃક્ષ લઈ જશે, અને વનસ્પતિ કે વન વૃક્ષ અંદર.

344
00:28:04,040 --> 00:28:06,370
અહીં અમે rmforest છે.

345
00:28:06,370 --> 00:28:11,480
માટે વૃક્ષ છે, જે મૂળભૂત રીતે આપણા માટે અમારા વૃક્ષો તમામ મુક્ત દૂર સમાન,

346
00:28:11,480 --> 00:28:16,600
વન દૂર મફત કે જંગલ માં સમાયેલ બધું છે.

347
00:28:16,600 --> 00:28:24,890
>> જો અમે forest.c તપાસ, અમે ત્યાં ઓછામાં ઓછા 1 rmtree આદેશ જુઓ અપેક્ષા કરીશું,

348
00:28:24,890 --> 00:28:30,090
કારણ કે જંગલમાં મુક્ત મેમરી જો વન તેને વૃક્ષો ધરાવે છે,

349
00:28:30,090 --> 00:28:32,930
પછી છેવટે તમે તે વૃક્ષો ખૂબ દૂર હોય રહ્યા છીએ.

350
00:28:32,930 --> 00:28:41,020
જો અમે forest.c તપાસ, અમે અમારી mkforest, કે જે અમે અપેક્ષા હોય છે.

351
00:28:41,020 --> 00:28:42,890
અમે વસ્તુઓ malloc.

352
00:28:42,890 --> 00:28:51,740
અમે NULL તરીકે જંગલ માં પ્રથમ પ્લોટ પ્રારંભ કારણ કે તે ખાલી છે સાથે શરૂ કરવા માટે,

353
00:28:51,740 --> 00:29:05,940
તો પછી અમે પિક, જે સૌથી ઓછા વજન સાથે વૃક્ષ આપે સૌથી નીચો આવૃત્તિ જોવા માટે,

354
00:29:05,940 --> 00:29:13,560
અને પછી તે ખાસ નોડ છૂટકારો મળે છે કે જે વૃક્ષ પોઇન્ટ અને આગામી એક,

355
00:29:13,560 --> 00:29:16,760
તેથી તે જંગલ સંકળાયેલા યાદી બહાર લઈ જશે.

356
00:29:16,760 --> 00:29:24,510
અને પછી અહીં અમે પ્લાન્ટ યાદીની લિંક એક વૃક્ષ દાખલ જે હોય છે.

357
00:29:24,510 --> 00:29:29,960
વન શું છે એ નથી કે તે સરસ રીતે રાખે છે તે આપણા માટે સોર્ટ થાય છે.

358
00:29:29,960 --> 00:29:37,910
અને પછી છેવટે, અમે 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
અમે 2 આપણા વિતરણ કોડ બાકી ફાઈલો હોય.

369
00:30:39,490 --> 00:30:41,640
>> ચાલો ડમ્પ જુઓ.

370
00:30:41,640 --> 00:30:47,230
તેના ટિપ્પણી દ્વારા અહીં ડમ્પ ફાઈલ હફમેનના-સંકુચિત લે છે

371
00:30:47,230 --> 00:30:55,580
અને પછી ભાષાંતર અને બધી સામગ્રી ડમ્પ આઉટ.

372
00:31:01,010 --> 00:31:04,260
અહીં અમે જુઓ કે તે hfopen ફોન છે.

373
00:31:04,260 --> 00:31:10,770
આ * ઇનપુટ = fopen ફાઇલ પ્રતિબિંબ પ્રકારની છે,

374
00:31:10,770 --> 00:31:13,500
અને તે પછી તમને માહિતી પસાર કરે છે.

375
00:31:13,500 --> 00:31:18,240
તેના બદલે એક ફાઇલ * તમે Huffile માં પસાર કરી રહ્યાં છે સિવાય લગભગ સમાન છે;

376
00:31:18,240 --> 00:31:22,030
તેના બદલે fopen તમે hfopen માં પસાર કરી રહ્યાં છે.

377
00:31:22,030 --> 00:31:29,280
અહીં અમે હેડર પ્રથમ વાંચી છે, કે જે પ્રકારની છે અમે કેવી રીતે હેડરમાં વાંચવા માટે સમાન

378
00:31:29,280 --> 00:31:33,580
એક બીટમેપ ફાઇલ માટે.

379
00:31:33,580 --> 00:31:38,000
અમે અહીં શું કરી રહ્યા છે તે જોવા માટે ચકાસે છે કે શું હેડર જાણકારી

380
00:31:38,000 --> 00:31:44,330
જમણી જાદુ નંબર છે કે જે સૂચવે છે કે તે એક વાસ્તવિક મિજાજ ફાઈલ છે સમાવે છે,

381
00:31:44,330 --> 00:31:53,610
તો પછી આ તપાસમાં તમામ ખાતરી કરો કે જે ફાઈલ કે અમે ઓપન ખરેખર huffed ફાઇલ અથવા નથી.

382
00:31:53,610 --> 00:32:05,330
કરે છે શું છે તે પ્રતીકો છે કે અમે જોઈ શકો છો તમામ આવૃત્તિઓ આઉટપુટો

383
00:32:05,330 --> 00:32:09,790
ગ્રાફિકલ કોષ્ટકમાં ટર્મિનલ અંદર.

384
00:32:09,790 --> 00:32:15,240
આ ભાગ માટે ઉપયોગી હોઈ રહ્યું છે.

385
00:32:15,240 --> 00:32:24,680
તે થોડી છે અને ચલ બીટ માં ક્રમેક્રમે વાંચો અને પછી તેને છાપે આઉટ.

386
00:32:28,220 --> 00:32:35,430
તેથી જો હું hth.bin છે, કે જે ફાઈલ 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 છે: એચ, જે બે વખત દેખાય છે,

390
00:32:51,180 --> 00:32:54,820
અને પછી ટી, જે એક વખત દેખાય છે.

391
00:32:54,820 --> 00:33:07,860
અને પછી અહીં અમે 0s અને 1 સે વાસ્તવિક સંદેશ છે.

392
00:33:07,860 --> 00:33:15,450
જો અમે hth.txt જોવા છે, જે કદાચ મૂળ સંદેશો કે huffed હતું,

393
00:33:15,450 --> 00:33:22,490
અમે ત્યાં કેટલાક HS અને TS જુઓ અપેક્ષા.

394
00:33:22,490 --> 00:33:28,720
ખાસ કરીને, અમે ફક્ત 1 T અને 2 HS જુઓ અપેક્ષા.

395
00:33:32,510 --> 00:33:37,440
અહીં અમે hth.txt છે. તે ખરેખર HTH છે.

396
00:33:37,440 --> 00:33:41,270
તેમાં સમાવેશ થાય છે, જોકે અમે તેને જોઈ શકે છે, એક NEWLINE પાત્ર છે.

397
00:33:41,270 --> 00:33:53,190
આ રીસ ફાઈલ hth.bin પણ NEWLINE પાત્ર છે તેમજ એન્કોડિંગ.

398
00:33:55,680 --> 00:34:01,330
અહીં આપણે જાણીએ છીએ કારણ કે તે ક્રમમાં HTH અને પછી NEWLINE છે,

399
00:34:01,330 --> 00:34:07,340
અમે તે કદાચ એચ રજૂ થાય છે માત્ર એક 1 દ્વારા જોઈ શકો છો

400
00:34:07,340 --> 00:34:17,120
અને પછી ટી કદાચ 01 અને પછી આગામી એચ 1 છે તેમજ

401
00:34:17,120 --> 00:34:21,139
અને પછી અમે બે 0s દ્વારા સૂચવાયેલ NEWLINE છે.

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

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
અને તેથી અહીં અમે મેકફાઇલ Language જે તમારા માટે ડમ્પ બનાવે છે.

406
00:34:40,460 --> 00:34:47,070
પરંતુ, વાસ્તવમાં, તમે તમારી પોતાની puff.c ફાઈલ બનાવવા જઈ છે.

407
00:34:47,070 --> 00:34:54,330
આ મેકફાઇલ Language ખરેખર તમારા માટે puff.c બનાવવા સાથે કામ કરી શકતું નથી.

408
00:34:54,330 --> 00:34:59,310
અમે તે છોડી રહ્યા છો અપ તમે મેકફાઇલ Language ફેરફાર કરો.

409
00:34:59,310 --> 00:35:05,930
જ્યારે તમે તે બધા જેવા આદેશ દાખલ કરો, ઉદાહરણ તરીકે, તમે તે બધા કરશે.

410
00:35:05,930 --> 00:35:10,760
માટે ભૂતકાળમાં pset માંથી મેકફાઇલ Language ઉદાહરણો જોવા નિઃસંકોચ

411
00:35:10,760 --> 00:35:17,400
તેમજ આ એક બંધ જઈને જોવા માટે તમે કેવી રીતે તમારા દોડ્યા પછી એકદમ હાંફવું ફાઈલ કરી શકે છે

412
00:35:17,400 --> 00:35:20,260
આ મેકફાઇલ Language ફેરફાર કરીને.

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
અમારા જંગલ માં જો આપણે માત્ર 3 અક્ષર છે, કે જે 3 વૃક્ષો એક વન છે.

430
00:36:42,070 --> 00:36:45,150
અને પછી આપણે પર જાઓ, જ્યારે અમે પ્રથમ પિતૃ ઉમેર્યું હતું કે,

431
00:36:45,150 --> 00:36:48,080
અમે 2 વૃક્ષો વન કરી હતી.

432
00:36:48,080 --> 00:36:54,930
અમે અમારા જંગલ માંથી 2 તે બાળકો દૂર કરો અને પછી તે પિતૃ નોડ સાથે બદલી

433
00:36:54,930 --> 00:36:58,820
કે બાળકો પેલા 2 ગાંઠો હતી.

434
00:36:58,820 --> 00:37:05,600
અને છેલ્લે પછી, અમારી જેમ bs સાથે અમારી ઉદાહરણ બનાવવા સાથે છેલ્લું પગલું, અને CS

435
00:37:05,600 --> 00:37:08,030
માટે અંતિમ પિતૃ બનાવવા હશે,

436
00:37:08,030 --> 00:37:13,190
અને તેથી પછી તે 1 થી અમારી જંગલમાં વૃક્ષો કુલ ગણતરી મળશે.

437
00:37:13,190 --> 00:37:18,140
નથી દરેક લોકોને જોવા તમે કેવી રીતે બહુવિધ વૃક્ષો સાથે તમારા વન શરૂ

438
00:37:18,140 --> 00:37:22,520
અને 1 અંત? ઠીક છે. સરસ.

439
00:37:25,530 --> 00:37:28,110
>> માટે અમે શું દોડ્યા પછી એકદમ હાંફવું માટે શું જરૂરી છે?

440
00:37:28,110 --> 00:37:37,110
અમે જરૂર શું છે તેની ખાતરી છે કે, હંમેશા તેઓ અમને ઇનપુટ જમણી પ્રકાર આપી

441
00:37:37,110 --> 00:37:39,090
જેથી અમે ખરેખર કાર્યક્રમ ચલાવી શકો છો.

442
00:37:39,090 --> 00:37:43,130
આ કિસ્સામાં તેઓ અમને તેમની પ્રથમ દલીલ આદેશ લીટી પછી બક્શી જઈ રહ્યાં છો

443
00:37:43,130 --> 00:37:53,440
વધુ 2: ફાઈલ કે અમે વિસંકુચિત અને decompressed ફાઈલ નું આઉટપુટ કરવા માંગો છો.

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 અને 1 સે કે તેઓ માં પસાર વ્યવહાર કરી શકો છો

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
જેથી 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
અમે તે જાણો છો, પરંતુ અમે પણ 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
4 pset પાછા જ્યારે અમે ફાઇલ copy.c કે RGB triples માં તેની નકલ કરી હતી

470
00:40:12,680 --> 00:40:14,860
અને અમે ગૂઢ રહસ્યની અથવા ડિટેક્ટિવ વાર્તા કે નાટક અને કદ બદલવા માટે કે અર્થઘટન,

471
00:40:14,860 --> 00:40:20,390
એ જ રીતે, તમે કરી શકે શું માત્ર cp dump.c puff.c જેવા આદેશ ચલાવો છે

472
00:40:20,390 --> 00:40:23,600
અને ત્યાં કોડ કેટલાક વાપરો.

473
00:40:23,600 --> 00:40:28,210
જો કે, તે એક પ્રક્રિયા સરળ નથી ચાલી રહ્યું છે

474
00:40:28,210 --> 00:40:33,010
puff.c તમારી dump.c અનુવાદ માટે

475
00:40:33,010 --> 00:40:36,160
પરંતુ ઓછામાં ઓછા તે તમે ક્યાંક આપે શરૂ

476
00:40:36,160 --> 00:40:40,540
કેવી રીતે ખાતરી કરવા માટે કે જે ઇનપુટ વાસ્તવમાં અથવા ન 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
ઝડપી પ્રશ્ન: ઘણા કેવી રીતે જંગલો તમે જ્યારે તમે હફમેનના વૃક્ષ બીલ્ડ કરી રહ્યા છો પડશે?

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
માટે હફમેનના વૃક્ષ બીલ્ડ કરવા, તમે તે ક્રમમાં અને પ્રતીકો આવૃત્તિ વાંચી શકે છે

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
અને સ્પેક માં તેને પ્રભાવશાળીપણે હેન્ડલ કહે છે,

525
00:44:54,580 --> 00:45:00,280
જેથી બહાર વપરાશકર્તા માટે એક સંદેશ તેમને કહેવાની શા માટે કાર્યક્રમ છોડવાનો છે છાપી માંગો

526
00:45:00,280 --> 00:45:03,050
અને પછી તરત તેને છોડી દીધું.

527
00:45:03,050 --> 00:45:09,490
આ ભૂલ નિયંત્રણમાં કરી યાદ રાખો કે તમે તેને ચેક કરવા માંગો છો

528
00:45:09,490 --> 00:45:12,160
દરેક એક સમય કે ત્યાં નિષ્ફળતા હોઈ શકે છે.

529
00:45:12,160 --> 00:45:14,660
દરેક એક સમય કે તમે નવી નિર્દેશક બનાવી રહ્યા છો

530
00:45:14,660 --> 00:45:17,040
તમે તેની ખાતરી કરવા માટે કે જે સફળ છે બનાવવા માંગો છો.

531
00:45:17,040 --> 00:45:20,320
અમે શું વપરાય છે નવા નિર્દેશક અને તે malloc બનાવવા પહેલાં,

532
00:45:20,320 --> 00:45:22,380
અને પછી અમે તપાસો કે શું નિર્દેશક NULL છે.

533
00:45:22,380 --> 00:45:25,670
તેથી ત્યાં કેટલાક ઉદાહરણો છે જ્યાં તમે હમણાં જ આવું કરી શકે જવું છે,

534
00:45:25,670 --> 00:45:28,610
પરંતુ ક્યારેક તમે ખરેખર કાર્ય કૉલ કરી રહ્યાં છો

535
00:45:28,610 --> 00:45:33,100
અને તે કાર્ય અંદર, કે જે એક કે mallocing કરી રહ્યો છે.

536
00:45:33,100 --> 00:45:39,110
તે કિસ્સામાં, જો અમે કેટલાક કાર્યોને પાછળ કોડ અંદર જુઓ,

537
00:45:39,110 --> 00:45:42,260
તેમાંના કેટલાક બુલિયન વિધેયો છે.

538
00:45:42,260 --> 00:45:48,480
અમૂર્ત કિસ્સામાં જો અમે બુલિયન foo કહેવાય કાર્ય હોય છે,

539
00:45:48,480 --> 00:45:54,580
મૂળભૂત રીતે, અમે કરવાનું ગમે foo કરે વધુમાં કે ધારણ કરી શકે છે,

540
00:45:54,580 --> 00:45:57,210
કારણ કે તે એક બુલિયન કાર્ય છે, તે સાચી કે ખોટી આપે છે -

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 (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
તેથી પછી તે કેવી રીતે તમે કંઈક જો કાર્ય સાચું આપે છે અને સફળ છે.

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
જેથી ગમે, "આ વૃક્ષ બનાવી શકાયું" અને પછી 1 અથવા કે કંઈક આવો.

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 અને 1 સે અનુસરો.

573
00:48:39,260 --> 00:48:45,480
અને તેથી અમે સંમેલન દ્વારા જાણો છો કે હફમેનના વૃક્ષ 0s બાકી સૂચવે છે

574
00:48:45,480 --> 00:48:48,360
અને 1 સે અધિકાર દર્શાવે છે.

575
00:48:48,360 --> 00:48:53,540
તેથી પછી જો તમે ક્રમેક્રમે માં વાંચો, તે દરેક સમયે તમે એક 0 વિચાર

576
00:48:53,540 --> 00:48:59,100
તમે ડાબી શાખા અનુસરો, અને પડશે પછી દરેક વખતે તમે 1 માં વાંચો

577
00:48:59,100 --> 00:49:02,100
તમે જમણી શાખા અનુસરો રહ્યા છીએ.

578
00:49:02,100 --> 00:49:07,570
અને પછી તમે ચાલુ રાખવા જઈ રહ્યાં છો ત્યાં સુધી તમે એક પર્ણ ફટકો

579
00:49:07,570 --> 00:49:11,550
કારણ કે પાંદડા માટે શાખાઓ ઓવરને અંતે હશે આવે છે.

580
00:49:11,550 --> 00:49:16,870
અમે શું આપણે એક પર્ણ નથી અથવા ફટકો કર્યું છે કે કેવી રીતે કહી શકે છે?

581
00:49:19,800 --> 00:49:21,690
અમે પહેલાં જણાવ્યું હતું.

582
00:49:21,690 --> 00:49:24,040
[વિદ્યાર્થી] જો પોઇંટરો NULL છે. >> યાહ.

583
00:49:24,040 --> 00:49:32,220
અમે જો આપણે એક પર્ણ ફટકો કર્યા છે જો બન્ને ડાબી અને જમણી વૃક્ષો માટે પોઇંટરો NULL છે કહી શકે છે.

584
00:49:32,220 --> 00:49:34,110
પરફેક્ટ.

585
00:49:34,110 --> 00:49:40,320
અમે જાણીએ છીએ કે અમે ક્રમેક્રમે અમારા મિજાજ ફાઈલ માં વાંચવા માંગો છો.

586
00:49:43,870 --> 00:49:51,220
આપણે dump.c પહેલા થયો હતો, તેઓ શું કર્યું છે તેઓ ક્રમેક્રમે માં મિજાજ ફાઇલમાં વાંચો

587
00:49:51,220 --> 00:49:54,560
અને માત્ર છપાયેલ તે બિટ્સ શું હતા.

588
00:49:54,560 --> 00:49:58,430
અમે તે કરી શકાતી નથી જઈ રહ્યાં છો. અમે કંઈક કે જે થોડી વધુ જટિલ છે કરી શકાય જઈ રહ્યાં છો.

589
00:49:58,430 --> 00:50:03,620
પરંતુ અમે શું કરી શકો છો છે અમે કોડ કે બીટ કે બીટ માં વાંચો લઈ શકો છો.

590
00:50:03,620 --> 00:50:10,250
અહીં અમે પૂર્ણાંક વર્તમાન બીટ કે અમે છો રજૂ બીટ છે.

591
00:50:10,250 --> 00:50:15,520
આ ફાઈલમાં બિટ્સ તમામ વારો કાળજી લે ત્યાં સુધી તમે આ ફાઈલ ઓવરને નહીં.

592
00:50:15,520 --> 00:50:21,270
પર આધારિત છે, પછી તમે iterator કેટલાક પ્રકારની માંગો છો જઈ રહ્યાં છો

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
તમે ક્યાં તો ડાબી કે 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
અમે હફમેનના ફાઈલ નથી પરંતુ મોર્સ કોડ સાથે શા માટે આ કરી શકો છો?

599
00:50:54,300 --> 00:50:56,610
કારણ કે મોર્સ કોડ ત્યાં સંદિગ્ધતા એક બીટ છે.

600
00:50:56,610 --> 00:51:04,440
અમે જેમ, ઓહ રાહ હોઇ શકે છે, અમે માર્ગ સાથે એક પત્ર ફટકો છે, જેથી કદાચ આ અમારી પત્ર છે,

601
00:51:04,440 --> 00:51:08,150
જ્યારે જો આપણે માત્ર થોડોક લાંબો સમય ચાલુ રહી, તો પછી અમે બીજા પત્ર ફટકો હોત.

602
00:51:08,150 --> 00:51:13,110
પરંતુ તે માટે થાય છે હફમેનના એન્કોડિંગ નથી ચાલી રહ્યું છે,

603
00:51:13,110 --> 00:51:17,540
તેથી અમે ખાતરી કરો કે માત્ર રસ્તો છે કે અમે જઈ રહ્યાં છો, એક અક્ષર હિટ આરામ કરી શકો છો

604
00:51:17,540 --> 00:51:23,480
જો કે નોડ ડાબી અને જમણી બાળકો NULL છે.

605
00:51:28,280 --> 00:51:32,350
>> છેલ્લે, અમે અમારા મેમરી બધા મુક્ત કરવા માંગો છો.

606
00:51:32,350 --> 00:51:37,420
અમે બંને નજીક મિજાજ ફાઈલ કરવા માંગો છો કે અમે સાથે વ્યવહાર કર્યો છે

607
00:51:37,420 --> 00:51:41,940
તેમજ અમારા જંગલ માં વૃક્ષો બધા દૂર કરો.

608
00:51:41,940 --> 00:51:46,470
તમારા અમલીકરણ પર આધાર રાખીને, તમે કદાચ કરવા માંગો છો જઈ રહ્યાં છો માટે વન દૂર કૉલ

609
00:51:46,470 --> 00:51:49,780
બદલે વાસ્તવમાં જાતે વૃક્ષો બધા પસાર થઇ.

610
00:51:49,780 --> 00:51:53,430
પરંતુ જો તમે કોઈ કામચલાઉ વૃક્ષો બનાવી, તમે તે મુક્ત કરવા માંગો છો પડશે.

611
00:51:53,430 --> 00:51:59,060
તમે તમારો કોડ શ્રેષ્ઠ ખબર છે, તેથી તમે જાણો છો કે જ્યાં તમે મેમરી allocating કરી રહ્યાં છો.

612
00:51:59,060 --> 00:52:04,330
અને તેથી જો તમે જાય છે, પણ malloc માટે F'ing નિયંત્રણ દ્વારા શરૂ કરવા માટે,

613
00:52:04,330 --> 00:52:08,330
જોયા જ્યારે તમે malloc અને તેની ખાતરી કરીને કે જે તમને બધી મુક્ત

614
00:52:08,330 --> 00:52:10,190
પરંતુ તે પછી ફક્ત તમારા કોડ પસાર થઇ,

615
00:52:10,190 --> 00:52:14,260
સમજ્યા કે જ્યાં તમે મેમરી ફાળવવામાં હોઈ શકે છે.

616
00:52:14,260 --> 00:52:21,340
સામાન્ય રીતે તમે માત્ર કહેવું, શકે "ફાઈલ અંતે હું માત્ર મારા વન પર જંગલ દૂર કરવા જઈ રહ્યો છું,"

617
00:52:21,340 --> 00:52:23,850
જેથી મૂળભૂત કે મેમરી સાફ કરો, મફત છે કે,

618
00:52:23,850 --> 00:52:28,310
"અને પછી હું પણ ફાઇલ બંધ કરો અને પછી મારું કાર્યક્રમ છોડવાનો રહ્યું છે જાઉં છું."

619
00:52:28,310 --> 00:52:33,810
પરંતુ તે જ સમયે તમારા કાર્યક્રમ સરખેસરખા છે?

620
00:52:33,810 --> 00:52:37,880
ના, કારણ કે ઘણી વખત ભૂલ કે બન્યું હોઇ શકે છે.

621
00:52:37,880 --> 00:52:42,080
કદાચ અમે ફાઈલ ખોલવા કે અમે અન્ય વૃક્ષ ન કરી શકે

622
00:52:42,080 --> 00:52:49,340
અથવા ભૂલ અમુક પ્રકારના મેમરી ફાળવણી પ્રક્રિયા થયું અને તેથી તે NULL ફર્યા.

623
00:52:49,340 --> 00:52:56,710
એક ભૂલ આવી અને તે પછી અમે પાછા ફર્યા અને છોડી દીધું.

624
00:52:56,710 --> 00:53:02,040
તેથી તો તમે ખાતરી કરો કે કોઇ પણ શક્ય સમય છે કે જે તમારા કાર્યક્રમ બહાર નીકળવા શકે બનાવવા માંગો છો,

625
00:53:02,040 --> 00:53:06,980
તમે તમારા મેમરી બધા ત્યાં મુક્ત કરવા માંગો છો.

626
00:53:06,980 --> 00:53:13,370
તે માત્ર મુખ્ય કાર્ય કે તમે તમારા કોડ બહાર નીકળવા ખૂબ જ ઓવરને અંતે નથી ચાલી રહ્યું છે.

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
પછી તે આદર્શ રીતે, તમારા 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 અને પછી NEWLINE.

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
>> તમે પણ કદાચ કોમ્પ્રેસ ખાતે શોટ લેવા કરી શકો છો અને પછી decompressing

654
00:55:38,110 --> 00:55:41,600
યુદ્ધ અને શાંતિ જેમ ફાઈલો કે જે તમે સ્પેલર ઉપયોગમાં કેટલીક

655
00:55:41,600 --> 00:55:46,710
અથવા ઑસ્ટિન જેન અથવા તે કંઈક - કે જે ઠંડી પ્રકારની હશે - અથવા ઓસ્ટિન પાવર્સ,

656
00:55:46,710 --> 00:55:51,880
મોટી ફાઈલો સાથે વ્યવહાર પ્રકારની કારણ કે અમે નીચે તેને આવશે

657
00:55:51,880 --> 00:55:55,590
જો અમે આગામી અહીં સાધન, ls-l ઉપયોગ થાય છે.

658
00:55:55,590 --> 00:56:01,150
અમે ls, કે જે મૂળભૂત રીતે અમારી વર્તમાન ડિરેક્ટરીમાં બધા સમાવિષ્ટો યાદી આપે છે ઉપયોગ કરી રહ્યા છો.

659
00:56:01,150 --> 00:56:07,860
ધ્વજ-l માં પસાર વાસ્તવમાં તે ફાઈલો માપ દર્શાવે છે.

660
00:56:07,860 --> 00:56:12,690
જો તમે pset સ્પેક મારફતે જાઓ, તે ખરેખર તમે બાઈનરી ફાઈલ બનાવવા સુધી લઈ,

661
00:56:12,690 --> 00:56:16,590
તે huffing, અને તમે ખૂબ નાની ફાઇલો માટે કે જુઓ

662
00:56:16,590 --> 00:56:23,910
તે કોમ્પ્રેસ અને તે તમામ માહિતી અનુવાદ ની જગ્યા કિંમત

663
00:56:23,910 --> 00:56:26,980
બધી જ વસ્તુઓ અને ફ્રિકવન્સીમાં ના વાસ્તવિક લાભ outweighs

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 Walkthrough હતી. અને નસીબ સારા.

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