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
>> హలో, ప్రతి ఒక్కరూ, మరియు Walkthrough 6 స్వాగతం: 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
మేము 0 సె మరియు 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
మీరు 1 అందంగా చక్కగా భావన వాటిని కలిపే pset 4 మరియు pset 5 మరియు రకమైన లో ఉపయోగించిన

11
00:00:41,730 --> 00:00:43,830
మీరు దాని గురించి ఆలోచించటం వచ్చినప్పుడు.

12
00:00:43,830 --> 00:00:50,110
>> అలాగే, నిస్సందేహంగా, pset 4 మరియు 5 మేము అందించే వచ్చింది అత్యంత సవాలుగా psets ఉన్నారు.

13
00:00:50,110 --> 00:00:53,950
కాబట్టి ఇప్పుడు, మేము, C లో ఈ 1 మరింత pset కలిగి

14
00:00:53,950 --> 00:00:56,480
మరియు ఆ తర్వాత మేము వెబ్ కార్యక్రమాలను లో ఉన్నారు.

15
00:00:56,480 --> 00:01:02,310
కాబట్టి CS50 లో క్లిష్ట hump పైగా పొందడానికి నిన్ను నీవు అభినందించేందుకు.

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
అందువలన ఆ తర్వాత వారి సహ. h ఫైళ్లు. సి ఫైళ్ళు కాని

23
00:01:30,080 --> 00:01:34,300
మాకు మేము ఆ విధులు పని ఎలా కాబట్టి అవసరమైన తగినంత అవగాహన ఇస్తుంది

24
00:01:34,300 --> 00:01:38,100
లేదా కనీసం వారు ఏమి చేయాలో ఉంటాయి - వారి ఇన్పుట్లను మరియు ప్రతిఫలాన్ని -

25
00:01:38,100 --> 00:01:40,760
మేము బ్లాక్ బాక్స్ లో ఏం తెలియదు కూడా

26
00:01:40,760 --> 00:01:44,090
లేదా లోపల బ్లాక్ బాక్స్ లో ఏం జరుగుతున్నది అర్థం లేదు.

27
00:01:44,090 --> 00:01:49,400
మరియు తర్వాత చివరకు, సాధారణ గా, మేము, కొత్త డేటా నిర్మాణాలు వ్యవహరించే ఉంటాయి

28
00:01:49,400 --> 00:01:51,840
ఆ ల నిర్దిష్ట రకాల కొన్ని విషయాలను సూచించండి

29
00:01:51,840 --> 00:01:56,080
మరియు ఇక్కడ రూపకల్పన ప్రక్రియ కోసం మాత్రమే కలం మరియు కాగితం కలిగి

30
00:01:56,080 --> 00:01:58,470
మరియు మీరు మీ pset పని ఎలా గుర్తించడానికి ప్రయత్నిస్తున్న

31
00:01:58,470 --> 00:02:00,520
కానీ డీబగ్గింగ్ సమయంలో.

32
00:02:00,520 --> 00:02:06,140
మీరు విలువలు ఏమిటో రాసుకోదగిన మీరు, మీ కలం మరియు కాగితం పాటు GDB కలిగి

33
00:02:06,140 --> 00:02:09,320
పేరు మీ బాణాలు పై, మరియు ఆ వంటి విషయాలు.

34
00:02:09,320 --> 00:02:13,720
>> మొదటి హఫ్ఫ్మన్ చెట్లు చూడండి యొక్క తెలపండి.

35
00:02:13,720 --> 00:02:19,600
హఫ్ఫ్మన్ చెట్లు ప్రతి నోడ్ మాత్రమే 2 పిల్లలు అంటే, బైనరీ చెట్లు ఉన్నాయి.

36
00:02:19,600 --> 00:02:24,870
హఫ్ఫ్మన్ చెట్లు లో లక్షణం అని తరచుగా విలువలు

37
00:02:24,870 --> 00:02:27,140
తక్కువ బిట్స్ ప్రాతినిధ్యం వహిస్తున్నారు.

38
00:02:27,140 --> 00:02:32,690
మేము మోర్స్ కోడ్ ఉపన్యాసం ఉదాహరణలు, సంఘటిత ఏ రకమైన కొన్ని అక్షరాలు లో చూసింది.

39
00:02:32,690 --> 00:02:38,030
మీరు ఉదాహరణకు ఒక A లేదా ఒక E, అనువదించడానికి ప్రయత్నిస్తున్న ఉంటే

40
00:02:38,030 --> 00:02:43,940
మీరు ఆ తరచుగా తర్జుమా చేస్తున్నాం బదులుగా బిట్స్ పూర్తి సెట్ ఉపయోగించడానికి అవసరం

41
00:02:43,940 --> 00:02:48,640
ఆ సాధారణ డేటా రకం కోసం కేటాయించబడిన, మీరు, తక్కువ దాన్ని కుదించుము

42
00:02:48,640 --> 00:02:53,730
ఆపై ప్రాతినిధ్యం వారికి అక్షరాలు తక్కువ తరచుగా ఎక్కువ బిట్స్ తో ప్రాతినిధ్యం ఉంటాయి

43
00:02:53,730 --> 00:02:59,840
ఆ అక్షరాలు కనిపించే ఫ్రీక్వెన్సీలను అవుట్ బరువు మీరు ఆ కోరుకుంటాను ఎందుకంటే.

44
00:02:59,840 --> 00:03:03,020
మేము హఫ్ఫ్మన్ చెట్లు ఇక్కడ అదే ఆలోచన ఉంది

45
00:03:03,020 --> 00:03:12,360
అక్కడ ఒక గొలుసు, కొన్ని అక్షరాలు చెయ్యడానికి మార్గం ఒక రకమైన చేస్తున్నాము.

46
00:03:12,360 --> 00:03:14,470
మరియు తర్వాత చాలా ఫ్రీక్వెన్సీ కలిగిన అక్షరాలు

47
00:03:14,470 --> 00:03:17,940
తక్కువ బిట్స్ తో ఇస్తున్నాయి.

48
00:03:17,940 --> 00:03:22,020
>> మీరు ఒక హఫ్ఫ్మన్ చెట్టు నిర్మించడానికి విధంగా

49
00:03:22,020 --> 00:03:27,430
టెక్స్ట్ కనిపించే అక్షరాలు అన్ని ఉంచడం ద్వారా

50
00:03:27,430 --> 00:03:30,630
మరియు వారి ఫ్రీక్వెన్సీ గణన, ఎంత తరచుగా కనిపిస్తాయి.

51
00:03:30,630 --> 00:03:33,880
ఈ గాని ఆ అక్షరాలు కనిపిస్తాయి ఎన్ని సార్లు COUNT కావచ్చు

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 అని మీరు ఒక బీప్ మరియు బీప్ కలిగి ఉంటే

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 CS, 4 ఉంటాయి.

73
00:05:14,010 --> 00:05:17,270
నా మొదటి అడుగు లెక్కించడానికి ఉంటుంది.

74
00:05:17,270 --> 00:05:20,760
ఒక ఎన్ని సార్లు కనిపిస్తుంది? ఇది స్ట్రింగ్ లో 4 సార్లు కనిపిస్తుంది.

75
00:05:20,760 --> 00:05:25,060
B 6 సార్లు కనిపిస్తుంది, మరియు సి 2 సార్లు కనిపిస్తుంది.

76
00:05:25,060 --> 00:05:28,970
సహజంగానే, నేను, చాలా తరచుగా B ఉపయోగించి నేను చెప్పడానికి వెళుతున్న

77
00:05:28,970 --> 00:05:35,970
నేను బిట్స్ యొక్క తక్కువ సంఖ్య, 0 సె మరియు 1s యొక్క తక్కువ సంఖ్యలో B ప్రాతినిధ్యం మీరు.

78
00:05:35,970 --> 00:05:42,600
మరియు నేను కూడా సి అలాగే 0 సె మరియు 1s చాలా అవసరమవుతుంది అంచనా వెళుతున్న.

79
00:05:42,600 --> 00:05:48,550
మొదటి నేను ఇక్కడ ఏమి పౌనఃపున్యం పరంగా క్రమంలో వాటిని ఉంచుతారు.

80
00:05:48,550 --> 00:05:52,710
మేము సి మరియు A, ఆ మా 2 తక్కువ పౌనః అని చూడండి.

81
00:05:52,710 --> 00:06:00,290
, మేము ఒక పేరెంట్ నోడ్ సృష్టించడానికి, మరియు ఆ పేరెంట్ నోడ్ ఇది సంబంధం ఒక లేఖ లేదు

82
00:06:00,290 --> 00:06:05,070
కానీ మొత్తానికి ఒక ఫ్రీక్వెన్సీ, కలిగి ఉంది.

83
00:06:05,070 --> 00:06:08,780
మొత్తం 6 ఇది 2 + 4, అవుతుంది.

84
00:06:08,780 --> 00:06:10,800
అప్పుడు మేము ఎడమ శాఖ అనుసరించండి.

85
00:06:10,800 --> 00:06:14,970
మేము ఆ 6 నోడ్ వద్ద ఉంటే, అప్పుడు మేము సి చెయ్యడానికి 0 అనుసరించింది

86
00:06:14,970 --> 00:06:17,450
మరియు తర్వాత 1 A. చెయ్యడానికి

87
00:06:17,450 --> 00:06:20,300
కాబట్టి ఇప్పుడు మేము 2 నోడ్స్ ఉన్నాయి.

88
00:06:20,300 --> 00:06:23,920
మేము విలువ 6 కలిగి ఆపై మేము కూడా విలువ 6 తో మరొక నోడ్ ఉన్నాయి.

89
00:06:23,920 --> 00:06:28,550
కాబట్టి ఆ 2 అత్యల్ప 2 కూడా వదిలి కేవలం 2, ఇది నిలిచింది

90
00:06:28,550 --> 00:06:33,820
కాబట్టి మేము మొత్తం 12 తో మరో మాతృ ద్వారా ఆ చేరండి.

91
00:06:33,820 --> 00:06:36,300
కాబట్టి ఇక్కడ మా హఫ్ఫ్మన్ చెట్టు కలిగి

92
00:06:36,300 --> 00:06:40,020
B ను ఎక్కడ, కేవలం బిట్ 1 ఉంటుంది

93
00:06:40,020 --> 00:06:45,430
మరియు తరువాత వెళ్ళడానికి మేము సి 00 కలిగి అప్పుడు 01 కలిగి మరియు ఉంటుంది.

94
00:06:45,430 --> 00:06:51,300
కాబట్టి ఇక్కడ ప్రధానంగా మేము 1 లేదా 2 బిట్స్ గాని ఈ అక్షరాలు ప్రాతినిధ్యం మేము చూసాము

95
00:06:51,300 --> 00:06:55,160
పేరు గా అంచనా B,, కనీసం ఉంది.

96
00:06:55,160 --> 00:07:01,730
ఆపై, మేము సి అత్యంత కలిగి భావించారు, కానీ ఇది ఒక చిన్న హఫ్ఫ్మన్ చెట్టు నుండి

97
00:07:01,730 --> 00:07:06,020
అప్పుడు కూడా మధ్య ఎక్కడో వ్యతిరేకంగా 2 బిట్స్ ప్రాతినిధ్యం వహిస్తుంది.

98
00:07:07,820 --> 00:07:11,070
>> జస్ట్ హఫ్ఫ్మన్ చెట్టు యొక్క మరొక చిన్న ఉదాహరణ వెళ్ళి కు,

99
00:07:11,070 --> 00:07:19,570
మీరు స్ట్రింగ్ కలిగి చెప్పారు "హలో."

100
00:07:19,570 --> 00:07:25,360
మీరు ఏమి మీరు ఎన్ని సార్లు H ఈ కనిపిస్తాయి చెబుతున్నారు మొదటి ఉంది?

101
00:07:25,360 --> 00:07:34,200
H ఒకసారి మరియు తరువాత ఇ కనిపిస్తుంది కనిపిస్తే తరువాత మేము రెండుసార్లు కనిపించే l కలిగి

102
00:07:34,200 --> 00:07:36,580
మరియు o ఒకసారి కనిపించే.

103
00:07:36,580 --> 00:07:44,310
కాబట్టి అప్పుడు మేము బిట్స్ అతి తక్కువ సంఖ్యలో ద్వారా ప్రాతినిధ్యం వహించే ఇది లేఖ ఆశించడం?

104
00:07:44,310 --> 00:07:47,450
[విద్యార్థి] l. >> 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
నేను o ఇది ఇ మరొక 1, ఆపై ఒక 1, H ఇది 1 ఉంది, మరియు -

109
00:08:15,580 --> 00:08:23,410
l ఇది, ఆపై 2 - ప్రస్తుతం నేను వీరిని చూస్తూ నేను.

110
00:08:23,410 --> 00:08:32,799
అప్పుడు నేను ఒక హఫ్ఫ్మన్ చెట్టు నిర్మించడానికి విధంగా కనీసం పౌనఃపున్యాలు కలిగిన 2 నోడ్స్ కనుగొనేందుకు అంటారు

111
00:08:32,799 --> 00:08:38,010
మరియు ఒక పేరెంట్ నోడ్ సృష్టించడం ద్వారా వాటిని తోబుట్టువుల చేయండి.

112
00:08:38,010 --> 00:08:41,850
ఇక్కడ మేము తక్కువ పౌనఃపున్య 3 నోడ్స్ ఉన్నాయి. వారు అన్ని 1 ఉన్నాము.

113
00:08:41,850 --> 00:08:50,620
కాబట్టి ఇక్కడ మేము మొదటి లింక్ చూడాలని ఇది ఒకదాన్ని ఎంచుకోండి.

114
00:08:50,620 --> 00:08:54,850
లెట్ యొక్క నేను 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
మరియు తర్వాత చివరకు, నేను మాత్రమే కాబట్టి అప్పుడు 5 మారుతుంది, 2 మిగిలింది.

121
00:09:26,410 --> 00:09:32,010
నేను ఆ ఎన్కోడింగును పూర్తి అయితే ఇక్కడ, వంటి, అంచనా,

122
00:09:32,010 --> 00:09:37,480
1s ఎల్లప్పుడూ సరైన శాఖ మరియు 0 సె ఒక్క ఉంటాయి.

123
00:09:37,480 --> 00:09:45,880
అప్పుడు మేము 2 కేవలం 1 బిట్ మరియు తరువాత o ద్వారా ప్రాతినిధ్యం l కలిగి

124
00:09:45,880 --> 00:09:52,360
ఆపై 2 ఇ ఆపై H 3 బిట్స్ క్రిందికి వస్తుంది.

125
00:09:52,360 --> 00:09:59,750
కాబట్టి మీరు "హలో" ఈ సందేశం ప్రసారం చేయవచ్చు బదులుగా వాస్తవానికి అక్షరాలు ఉపయోగించి

126
00:09:59,750 --> 00:10:02,760
కేవలం 0 సె మరియు 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 ప్రాతినిధ్యం l ఉన్నప్పుడు న

130
00:10:15,730 --> 00:10:19,410
అలాగే 2 ప్రాతినిధ్యం ఒక చేరారు, మేము గాని ఒక లింక్ లేదు.

131
00:10:19,410 --> 00:10:23,630
>> కాబట్టి మీరు పంపించినప్పుడు 0 సె మరియు 1s, వాస్తవానికి హామీ లేదు

132
00:10:23,630 --> 00:10:27,090
స్వీకర్త పూర్తిగా కుడి బ్యాట్ ఆఫ్ మీ సందేశం చదవగలరు

133
00:10:27,090 --> 00:10:30,490
వారు మీరు చేసిన నిర్ణయం కాదు కాబట్టి.

134
00:10:30,490 --> 00:10:34,920
కాబట్టి మేము హఫ్ఫ్మన్ కుదింపు వ్యవహరించే చేసినప్పుడు,

135
00:10:34,920 --> 00:10:40,090
ఏదో మనం నిర్ణయించుకుంది మా భాషా గ్రహీత చెప్పడం కలిగి -

136
00:10:40,090 --> 00:10:43,470
వారు అదనపు సమాచారం రకమైన తెలుసుకోవాలి

137
00:10:43,470 --> 00:10:46,580
సంపీడన సందేశాన్ని పాటు.

138
00:10:46,580 --> 00:10:51,490
వారు చెట్టు నిజానికి ఎలా అర్థం చేసుకోవాలి

139
00:10:51,490 --> 00:10:55,450
మేము నిజంగా ఆ నిర్ణయాలను తీసుకున్నాడు ఎలా.

140
00:10:55,450 --> 00:10:59,100
>> ఇక్కడ మనం కేవలం వాస్తవ లెక్కింపు ఆధారంగా ఉదాహరణలు చేస్తున్న

141
00:10:59,100 --> 00:11:01,550
కానీ కొన్నిసార్లు మీరు కూడా ఒక హఫ్ఫ్మన్ చెట్టు ఉండవచ్చు

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
[విద్యార్థి] అస్పష్టమైన అంకగణితం. >> అవును. Imprecision.

153
00:11:38,600 --> 00:11:43,760
ఎందుకంటే ఫ్లోటింగ్ పాయింట్ imprecision ఈ pset కోసం మేము నిర్ధారించుకోండి తద్వారా

154
00:11:43,760 --> 00:11:49,450
మేము ఏ విలువలు కోల్పోతే లేని, అప్పుడు మేము నిజంగా COUNT వ్యవహరించే కావడం చేస్తున్నారు.

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
ఇది 1 శాఖ తో 0 శాఖ మరియు కుడి తన ఎడమ సూచిస్తుంది.

174
00:13:29,310 --> 00:13:34,200
మేము స్ట్రింగ్ "ఈ cs50 ఉంది," ఉంటే అప్పుడు మేము, T పేర్కొన్నారు ఎన్ని COUNT సార్లు

175
00:13:34,200 --> 00:13:38,420
h పేర్కొన్నారు, నేను, s, సి, 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
ఇది 1 T, ఆపై ఫ్రీక్వెన్సీ వంటి 2 కలిగి నోడ్స్ యొక్క ఒక ఎంచుకోవడం.

188
00:14:41,380 --> 00:14:44,560
కాబట్టి ఇక్కడ 3 ఎంపికలు ఉన్నాయి.

189
00:14:44,560 --> 00:14:47,980
నేను స్లయిడ్ కోసం చేయ బోతున్నాను అంటే కేవలం కనిపించే వాటిని మీ కోసం క్రమాన్ని ఉంది

190
00:14:47,980 --> 00:14:51,790
తద్వారా మీరు నేను దీనిని నేను ఎలా చూడగలరు.

191
00:14:51,790 --> 00:14:59,040
కోడ్ మరియు మీ పంపిణీ కోడ్ చేయబోవడం ఏమి T ఒక చేరడానికి ఉంటుంది

192
00:14:59,040 --> 00:15:01,410
0 మరియు 5 నోడ్ తో.

193
00:15:01,410 --> 00:15:05,060
కాబట్టి అప్పుడు 3 మొత్తాలను, మరియు మేము ప్రక్రియ కొనసాగుతుంది ఆ.

194
00:15:05,060 --> 00:15:08,660
2 మరియు 2 ఇప్పుడు అప్పుడు, 4 ఆ మొత్తం అత్యల్ప ఉంటాయి.

195
00:15:08,660 --> 00:15:12,560
అందరూ ఇప్పటివరకు తరువాత? సరే.

196
00:15:12,560 --> 00:15:16,410
ఆ తర్వాత మేము, 3 మరియు జోడించడానికి అవసరమైన 3 కలిగి

197
00:15:16,410 --> 00:15:21,650
మీరు చాలా దారుణంగా పొందండి లేదు దృశ్యపరంగా కాబట్టి చూడగలరు కాబట్టి మరలా నేను అది మారే చేస్తున్నాను.

198
00:15:21,650 --> 00:15:25,740
మేము కేవలం 2 నోడ్స్ కలిగి అప్పుడు మేము ఒక 6 కలిగి, తరువాత మా చివరి దశ ప్రస్తుతం

199
00:15:25,740 --> 00:15:30,440
మేము 10 ఇది మా చెట్టు యొక్క root చేయడానికి ఆ మొత్తం.

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
అనుకున్న, నేను మరియు తరచుగా కనిపించే s,

205
00:15:56,580 --> 00:16:01,350
బిట్ల తక్కువ సంఖ్య సూచించబడతాయి.

206
00:16:03,660 --> 00:16:05,660
>> ఇక్కడ జాగ్రత్తగా ఉండండి.

207
00:16:05,660 --> 00:16:09,780
హఫ్ఫ్మన్ చెట్లు లో కేసు వాస్తవానికి ముఖ్యమైనది.

208
00:16:09,780 --> 00:16:13,670
ఒక పెద్ద S ఒక చిన్న s కంటే భిన్నంగా ఉంటుంది.

209
00:16:13,670 --> 00:16:21,260
మేము కలిగి ఉంటే, చిన్న s మాత్రమే రెండుసార్లు కనిపిస్తుంది అప్పుడు, పెద్ద అక్షరాలతో "ఈ CS50 ఉంది"

210
00:16:21,260 --> 00:16:27,120
దాని విలువ 2 తో నోడ్ ఉంటుంది, మరియు తర్వాత పెద్ద S మాత్రమే ఒకసారి ఉంటుంది.

211
00:16:27,120 --> 00:16:33,440
మీరు నిజంగా ఇక్కడ ఒక అదనపు ఆకు ఎందుకంటే కాబట్టి అప్పుడు మీ వృక్ష నిర్మాణాలు మార్చుకోవచ్చు.

212
00:16:33,440 --> 00:16:36,900
కానీ మొత్తం ఇప్పటికీ 10 ఉంటుంది.

213
00:16:36,900 --> 00:16:39,570
అంటే, మేము నిజంగా చెక్సమ్ కాల్ కావడం ఏమి ఉంది

214
00:16:39,570 --> 00:16:44,060
గణనలు అన్ని యొక్క అదనంగా.

215
00:16:46,010 --> 00:16:50,990
>> ఇప్పుడు మేము హఫ్ఫ్మన్ చెట్లు కవర్ చేసిన, మేము Huff'n వాచిన, pset ప్రవేశిస్తాడు చేయవచ్చు.

216
00:16:50,990 --> 00:16:52,900
మేము, ప్రశ్నలు ఒక విభాగం ప్రారంభం చూడాలని

217
00:16:52,900 --> 00:16:57,990
మరియు ఈ మీరు బైనరీ చెట్లు మరియు ఆ చుట్టూ ఆపరేట్ తో అలవాటుపడిన పొందడానికి అన్నారు:

218
00:16:57,990 --> 00:17:03,230
గీయడం నోడ్స్, నోడ్సుకోసం మీ స్వంత typedef struct సృష్టిస్తుంది

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
హఫ్ ఏమి, టెక్స్ట్ తీసుకుని అప్పుడు 0 సె మరియు 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
అప్పుడు వాచిన తో మేము 0 సె మరియు 1s ఒక బైనరీ ఫైలు ఇవ్వబడ్డాయి

233
00:18:17,980 --> 00:18:21,740
మరియు పౌనఃపున్యాల గురించి సమాచారం ఇచ్చారు.

234
00:18:21,740 --> 00:18:26,740
మేము, ఒక యదార్ధ సందేశానికి ఆ 0 సె మరియు 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
ఆపై పఫ్ మీ ఇన్పుట్ ఆ అవుట్పుట్ ఉపయోగించండి.

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
నేను అధిక సమయాన్ని వెళుతున్న. H ఫైళ్లు

244
00:19:04,400 --> 00:19:07,660
మేము. h ఎందుకంటే. సి ఫైళ్లను, ఎందుకంటే

245
00:19:07,660 --> 00:19:11,650
మరియు ఆ, ఫంక్షన్స్ నమూనాలను అందిస్తుంది

246
00:19:11,650 --> 00:19:15,520
మేము పూర్తిగా ఖచ్చితంగా అర్థం లేదు -

247
00:19:15,520 --> 00:19:20,280
మీరు. సి ఫైళ్లను ఏమి అర్థం లేదు, అప్పుడు, చాలా ఆందోళన చెందకండి

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
ఇక్కడ మేము ఒక హఫ్ఫ్మన్-ఎన్కోడ్ ఫైల్ కోసం ఒక struct ఉన్నాయి.

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
బదులుగా ఇది ఎలాగైనా అదే ధ్వనులు ఎందుకంటే అదనపు h జోడించే.

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
>> జస్ట్. H ఫైలు చదవడం ద్వారా మేము, ఒక హఫ్ ఫైలు కావచ్చు దేనిని పొందుటకు రకం చెయ్యవచ్చు

281
00:22:25,700 --> 00:22:32,480
ఇది నిజానికి huffile.c వెళ్లడానికి లేకుండా, దానికి లక్షణాలు

282
00:22:32,480 --> 00:22:36,750
ఇది మేము లో ఈత కొట్టడానికి ఉంటే, ఒక మరింత క్లిష్టతరంగా అన్నారు.

283
00:22:36,750 --> 00:22:41,270
ఇది I / O ఇక్కడ గమనికలు వ్యవహరించే ఫైలు యొక్క అన్ని ఉన్నాయి.

284
00:22:41,270 --> 00:22:48,010
ఇక్కడ మేము hfread కాల్ చేసినప్పుడు, ఉదాహరణకు, ఇది fread వ్యవహరించే చేసే చూడండి.

285
00:22:48,010 --> 00:22:53,050
మేము పూర్తిగా ఆ విధులను తొలగిస్తున్నాము లేదు, కానీ మేము జాగ్రత్తగా తీసుకోవలసిన ఆ పంపిస్తున్నాం

286
00:22:53,050 --> 00:22:59,760
బదులుగా ఇది మనలోని అన్ని చేయడం యొక్క హఫ్ ఫైలు లోపల.

287
00:22:59,760 --> 00:23:02,300
మీరు ఆసక్తిగా ఉంటే ఈ ద్వారా స్కాన్ సంకోచించకండి చేయవచ్చు

288
00:23:02,300 --> 00:23:08,410
మరియు వెళ్లి తిరిగి పొర కొద్దిగా చర్మము.

289
00:23:20,650 --> 00:23:24,060
>> మేము చూడండి చూడాలని ఉద్దేశ్యంతో తదుపరి ఫైలు tree.h. ఉంది

290
00:23:24,060 --> 00:23:30,210
Walkthrough స్లయిడ్లలో ముందు మనం ఒక హఫ్ఫ్మన్ నోడ్ ఆశించడం చెప్పారు

291
00:23:30,210 --> 00:23:32,960
మరియు మేము ఒక typedef struct నోడ్ చేసింది.

292
00:23:32,960 --> 00:23:38,360
మేము ఒక గుర్తు, ఫ్రీక్వెన్సీ, ఆపై 2 నోడ్ నక్షత్రాలు కలిగి ఉంటుందని అంచనా.

293
00:23:38,360 --> 00:23:41,870
ఈ సందర్భంలో మనం చేస్తున్నా ఈ తప్పనిసరిగా అదే ఉంది

294
00:23:41,870 --> 00:23:46,880
బదులుగా నోడ్ యొక్క తప్ప మేము వాటిని చెట్లు కాల్ చూడాలని.

295
00:23:48,790 --> 00:23:56,760
మీరు చెట్టు తయారు కాల్ అది మీరు ఒక చెట్టు పాయింటర్ తిరిగి ఒక చర్య.

296
00:23:56,760 --> 00:24:03,450
మీరు ఒక కొత్త నోడ్ తయారు చేసేటప్పుడు, స్పెల్లర్ తిరిగి

297
00:24:03,450 --> 00:24:11,410
మీరు చెప్పారు నోడ్ * కొత్త పదం = malloc (sizeof) మరియు ఆ వంటి వాటిని.

298
00:24:11,410 --> 00:24:17,510
సాధారణంగా, mktree మీరు ఆ వ్యవహరించే విధంగా అన్నారు.

299
00:24:17,510 --> 00:24:20,990
అదేవిధంగా, మీరు ఒక చెట్టు తొలగించాలని ఉన్నప్పుడు,

300
00:24:20,990 --> 00:24:24,810
కాబట్టి ముఖ్యంగా, మీరు పూర్తి చేసినప్పుడు చెట్టు ఉండండి యొక్క

301
00:24:24,810 --> 00:24:33,790
బదులుగా స్పష్టంగా ఆ ఉచిత కాల్, మీరు నిజానికి rmtree ఫంక్షన్ను ఉపయోగించడానికి వెళుతున్న

302
00:24:33,790 --> 00:24:40,360
మీరు ఆ చెట్టు పాయింటర్ లో పాస్ మరియు 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
శూన్య విలువను, కాబట్టి 0 సె లేదా NULLs కు విలువలు అన్ని initializes

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
కాబట్టి ఆ ఉచిత, దిగువ ప్రయాణించి, తర్వాత ఆ, మొదలైనవి తిరిగి ఉచిత ఆలోచన

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
అప్పుడు మీరు PLANT ఉన్నాయి.

342
00:27:50,730 --> 00:27:57,420
మీరు ఒక కాని 0 ఫ్రీక్వెన్సీ కలిగి చెట్టు ఒక పాయింటర్ లో పాస్ అందించిన

343
00:27:57,420 --> 00:28:04,040
ఏ మొక్క చేస్తుంది ఇది అటవీ తీసుకుని చెట్టు తీసుకుని, మొక్క ఉంటుంది అని అడవి చెట్టు లోపల.

344
00:28:04,040 --> 00:28:06,370
ఇక్కడ మేము rmforest ఉన్నాయి.

345
00:28:06,370 --> 00:28:11,480
ప్రధానంగా మాకు మా చెట్లు అన్ని స్వేచ్ఛ చెట్టు, తొలగించడానికి ఇటువంటి

346
00:28:11,480 --> 00:28:16,600
అటవీ తొలగించడానికి ఆ అడవి లో ఉన్న ఉచిత ప్రతిదీ రెడీ.

347
00:28:16,600 --> 00:28:24,890
>> మేము forest.c పరిశీలిస్తాము ఉంటే, మేము, అక్కడ కనీసం 1 rmtree ఆదేశం చూడాలనుకుంటున్నారా చేస్తాము

348
00:28:24,890 --> 00:28:30,090
ఎందుకంటే ఒక అడవి లో చెట్లు ఉంటే అడవిలో ఉచిత స్మృతికి,

349
00:28:30,090 --> 00:28:32,930
అప్పుడు చివరికి మీరు చాలా ఆ చెట్లు తొలగించాలని చూడాలని.

350
00:28:32,930 --> 00:28:41,020
మేము forest.c పరిశీలిస్తాము ఉంటే, మేము ఆశించిన విధంగా ఇది మా mkforest కలిగి.

351
00:28:41,020 --> 00:28:42,890
మేము malloc విషయాలు.

352
00:28:42,890 --> 00:28:51,740
అది లేదు ఖాళీ ఎందుకంటే మేము, NULL వంటి అడవిలో మొదటి ప్లాట్లు ప్రారంభించడం

353
00:28:51,740 --> 00:29:05,940
అప్పుడు మేము తక్కువ బరువు కలిగిన చెట్లు చూపించే పిక్, అత్యల్ప పౌనఃపున్యం, చూడండి

354
00:29:05,940 --> 00:29:13,560
మరియు ఆ ప్రత్యేక నోడ్ విమోచనం అందుతుంది అని ఆ చెట్టు పాయింట్లు మరియు తదుపరి,

355
00:29:13,560 --> 00:29:16,760
కాబట్టి ఇది అడవి లింక్ జాబితా యొక్క తీస్తాడు.

356
00:29:16,760 --> 00:29:24,510
మరియు ఇక్కడ మేము ఇది లింక్ జాబితాలో ఇన్సర్ట్ ఒక చెట్టు మొక్క, ఉన్నాయి.

357
00:29:24,510 --> 00:29:29,960
ఏ అటవీ ఇది చక్కగా మా క్రమబద్ధీకరించబడతాయి చేస్తుంది లేదు.

358
00:29:29,960 --> 00:29:37,910
మరియు తర్వాత, చివరిగా మనకు అంచనా, మేము పని rmtree కలిగి, rmforest కలిగి మరియు.

359
00:29:46,650 --> 00:29:55,440
>> ఇప్పటివరకు పంపిణీ కోడ్ వద్ద గురించి, huffile.c, అర్థం దూరంగా కష్టతరమైన ద్వారా బహుశా

360
00:29:55,440 --> 00:29:59,990
ఇతర ఫైళ్లు అయితే తాము అనుసరించడానికి చాలా సులభమైన ఉన్నారు.

361
00:29:59,990 --> 00:30:03,090
గమనికలు మరియు అనుసంధాన జాబితాలు మరియు మా జ్ఞానం తో,

362
00:30:03,090 --> 00:30:04,860
మేము ప్రెట్టీ బాగా అనుసరించండి సాధించారు.

363
00:30:04,860 --> 00:30:10,500
కానీ మేము పూర్తిగా అర్థం నిర్ధారించుకోండి ఏమిటంటే. H దస్త్రాలు

364
00:30:10,500 --> 00:30:15,840
మీరు, ఆ తిరిగి విలువలు వ్యవహరించే, ఆ విధులు కాల్ అవసరం ఎందుకంటే

365
00:30:15,840 --> 00:30:20,590
కాబట్టి మీరు పూర్తిగా నిర్వహించబడుతుంది అన్నారు ఎలాంటి అర్థం నిర్ధారించుకోండి

366
00:30:20,590 --> 00:30:24,290
ఆ కార్యక్రమాల్లో ఒకటి కాల్ చేసినప్పుడు.

367
00:30:24,290 --> 00:30:33,020
కానీ నిజానికి అది లోపలి understanding మేము ఆ ఎందుకంటే చాలా అవసరం లేదు. H ఫైళ్లు.

368
00:30:35,170 --> 00:30:39,490
మేము మా పంపిణీ కోడ్ మిగిలి 2 మరిన్ని ఫైళ్ళను ఉన్నాయి.

369
00:30:39,490 --> 00:30:41,640
>> యొక్క డంప్ చూద్దాం.

370
00:30:41,640 --> 00:30:47,230
ఇక్కడ దాని వ్యాఖ్య ద్వారా డంప్ ఒక హఫ్ఫ్మన్ కుదింపు ఫైలు పడుతుంది

371
00:30:47,230 --> 00:30:55,580
మరియు తర్వాత మాట మరియు డంపుల కంటెంట్ యొక్క అల్ అవ్ట్.

372
00:31:01,010 --> 00:31:04,260
ఇక్కడ మేము అది hfopen కాల్ చేసే చూడండి.

373
00:31:04,260 --> 00:31:10,770
ఇది * ఇన్పుట్ = fopen ఫైల్ ప్రతిబింబించే రకం

374
00:31:10,770 --> 00:31:13,500
మరియు మీరు సమాచారాన్ని పాస్.

375
00:31:13,500 --> 00:31:18,240
ఇది బదులుగా మీరు ఒక Huffile అక్కడ మీరు ఒక ఫైల్ * యొక్క తప్ప దాదాపు ఒకేలా ఉంటుంది;

376
00:31:18,240 --> 00:31:22,030
బదులుగా fopen యొక్క మీరు hfopen అక్కడ చేస్తున్నారు.

377
00:31:22,030 --> 00:31:29,280
ఇక్కడ మేము రకమైన మేము శీర్షికలో చదివి ఎలా పోలి ఉంది, మొదటి శీర్షికలో చదవండి

378
00:31:29,280 --> 00:31:33,580
ఒక Bitmap ఫైల్ కోసం.

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
నేను ఒక ఫైల్ huffing యొక్క ఫలితంగా hth.bin, న డంప్ కాల్ అలా అయితే

387
00:32:35,430 --> 00:32:39,490
సిబ్బంది విధానాన్ని ఉపయోగించి, నేను ఈ పొందుతారు.

388
00:32:39,490 --> 00:32:46,000
ఈ అక్షరాలు అన్ని ఔట్పుట్ మరియు అప్పుడు వారు కనిపించే వద్ద పౌనఃపున్యం ఉంచడం మాత్రమే.

389
00:32:46,000 --> 00:32:51,180
మేము చూస్తే, వాటిలో చాలా ఈ తప్ప 0 సె ఉన్నాయి: రెండుసార్లు కనిపించే H,

390
00:32:51,180 --> 00:32:54,820
తరువాత ఒకసారి కనిపించే T,.

391
00:32:54,820 --> 00:33:07,860
మరియు ఇక్కడ మేము 0 సె మరియు 1s వాస్తవ సందేశం ఉంది.

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
ఇక్కడ మేము, ఆర్డర్ NEWLINE అప్పుడు HTH మరియు అని తెలుసు ఎందుకంటే

399
00:34:01,330 --> 00:34:07,340
మేము కేవలం ఒకే 1 బహుశా H ప్రాతినిధ్యం అని చూడగలరు

400
00:34:07,340 --> 00:34:17,120
మరియు తర్వాత T బహుశా 01 మరియు తరువాత H 1 పాటు

401
00:34:17,120 --> 00:34:21,139
మరియు తర్వాత మేము రెండు 0 సె ద్వారా సూచించిన ఒక NEWLINE ఉన్నాయి.

402
00:34:22,420 --> 00:34:24,280
కూల్.

403
00:34:26,530 --> 00:34:31,600
>> మరియు తర్వాత, చివరిగా మనకు అనేక. సి వ్యవహరించే మరియు. ఉన్నందున h ఫైళ్లు,

404
00:34:31,600 --> 00:34:36,350
మేము, కంపైలర్ ఒక అందమైన క్లిష్టమైన వాదన చూడాలని

405
00:34:36,350 --> 00:34:40,460
మరియు ఇక్కడ మేము మీ కోసం డంప్ చేస్తుంది ఒక Makefile ఉన్నాయి.

406
00:34:40,460 --> 00:34:47,070
కానీ నిజానికి, మీరు మీ స్వంత puff.c ఫైలు తయారు చెయ్యటానికి ఉన్నాయి.

407
00:34:47,070 --> 00:34:54,330
Makefile అయితే మీరు puff.c తయారు వ్యవహరించే లేదు.

408
00:34:54,330 --> 00:34:59,310
మేము Makefile సవరించడానికి మీరు ఆ అప్ వదిలేస్తున్నారు.

409
00:34:59,310 --> 00:35:05,930
మీరు అని వంటి ఆదేశాన్ని నమోదు చేసినప్పుడు, ఉదాహరణకు, మీరు వాటిని అన్ని చేస్తుంది.

410
00:35:05,930 --> 00:35:10,760
గత pset నుండి Makefile ఉదాహరణలు చూడండి సంకోచించకండి

411
00:35:10,760 --> 00:35:17,400
అలాగే మీరు మీ వాచిన ఫైలు చేయగలరు ఎలా చూడటానికి ఈ ఒక యొక్క షో

412
00:35:17,400 --> 00:35:20,260
ఈ Makefile సవరించడం ద్వారా.

413
00:35:20,260 --> 00:35:22,730
మా పంపిణీ కోడ్ అది గురించి.

414
00:35:22,730 --> 00:35:28,380
>> మేము ఆ ద్వారా సంపాదించిన తర్వాత, ఇక్కడ మరొక రిమైండర్ ఉంది

415
00:35:28,380 --> 00:35:30,980
ఎలా మేము హఫ్ఫ్మన్ నోడ్స్ వ్యవహరించే కావడం చేస్తున్నారు.

416
00:35:30,980 --> 00:35:35,400
మేము వాటిని ఇకపై నోడ్స్ కాల్ కావడం లేదు; మేము వాటిని చెట్లు పిలుచుచున్నారు చూడాలని

417
00:35:35,400 --> 00:35:39,260
మేము ఒక చార్ వారి చిహ్నం ప్రాతినిధ్యం చేయడానికి వెళుతున్న,

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

425
00:36:12,420 --> 00:36:20,840
గతంలో మేము మా హఫ్ఫ్మన్ చెట్లు తయారు చేసినప్పుడు న,

426
00:36:20,840 --> 00:36:25,360
మేము మా స్క్రీన్ మీద నోడ్స్ అన్ని పెట్టడము ద్వారా ప్రారంభించారు

427
00:36:25,360 --> 00:36:27,790
మరియు, మేము ఈ నోడ్స్ చూడాలని చెప్పడం

428
00:36:27,790 --> 00:36:32,920
చివరికి వారు ఆకులు మాత్రం చేస్తున్నాము, ఈ వారి చిహ్నం, ఈ వారి ఫ్రీక్వెన్సీ.

429
00:36:32,920 --> 00:36:42,070
మేము కేవలం 3 అక్షరాలు ఉంటే మా అడవి లో, ఆ 3 చెట్ల ఫారెస్ట్ యొక్క.

430
00:36:42,070 --> 00:36:45,150
మరియు తర్వాత మేము, మేము మొదటి మాతృ రావడంతో, పయనించే వంటి

431
00:36:45,150 --> 00:36:48,080
మేము 2 చెట్ల అడవి చేసింది.

432
00:36:48,080 --> 00:36:54,930
మేము మా అడవి నుండి ఆ పిల్లల 2 తొలగించబడింది మరియు తరువాత మాతృ నోడ్ దాని స్థానంలో

433
00:36:54,930 --> 00:36:58,820
పిల్లలు ఆ 2 నోడ్స్ వచ్చింది.

434
00:36:58,820 --> 00:37:05,600
మరియు తర్వాత చివరకు, మా గత నాటికి, Bs మా ఉదాహరణ తయారు దశ, మరియు CS

435
00:37:05,600 --> 00:37:08,030
చివరి మాతృ చేయడానికి ఉంటుంది,

436
00:37:08,030 --> 00:37:13,190
మరియు అందువలన 1 అడవిలో వృక్షముల మా మొత్తం సభ్యత్వం తీసుకొచ్చే.

437
00:37:13,190 --> 00:37:18,140
ప్రతి ఒక్కరూ మీరు మీ అడవిలో బహుళ చెట్లతో ప్రారంభమై ఎలా చూడండి లేదు

438
00:37:18,140 --> 00:37:22,520
మరియు 1 తో ముగుస్తుంది? సరే. కూల్.

439
00:37:25,530 --> 00:37:28,110
>> మనం వాచిన కోసం ఏమి చేయాలి?

440
00:37:28,110 --> 00:37:37,110
మనం ఏమి చేయాలి వంటి ఎల్లప్పుడూ వారు మాకు ఇన్పుట్ కుడి రకం ఇవ్వాలని, నిర్ధారించడానికి ఉంది

441
00:37:37,110 --> 00:37:39,090
మేము నిజంగా కార్యక్రమం అమలు చేయవచ్చు.

442
00:37:39,090 --> 00:37:43,130
ఈ సందర్భంలో వారు తమ మొదటి ఆదేశ పంక్తి వాదన తర్వాత మాకు ఇస్తున్నట్టు చూడాలని

443
00:37:43,130 --> 00:37:53,440
2 మరింత: మేము విస్తరించేందుకు మరియు విస్తరించినప్పుడు ఫైలు యొక్క అవుట్పుట్ చేయదలిచిన ఫైలు.

444
00:37:53,440 --> 00:38:00,410
కానీ ఒకసారి మేము, వారు విలువలు కుడి మొత్తం మాకు పాస్ నిర్ధారించుకోండి

445
00:38:00,410 --> 00:38:05,820
మేము ఇన్పుట్ హఫ్ ఫైలు లేదా ఆ హామీ ఇస్తున్నాము.

446
00:38:05,820 --> 00:38:10,420
మరియు తర్వాత ఒకసారి మేము, అప్పుడు మేము మా చెట్టు నిర్మించడానికి కావలసిన, అది ఒక హఫ్ ఫైల్ హామీ

447
00:38:10,420 --> 00:38:20,940
అది సందేశాన్ని పంపిన వ్యక్తి నిర్మాణంలో చెట్టు సరిపోయే అటువంటి చెట్టు నిర్మించే.

448
00:38:20,940 --> 00:38:25,840
మేము చెట్టు నిర్మించడానికి తరువాత, అప్పుడు మేము తో 0 సె మరియు వారు జారీ చేసే 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
>> సరైన వాడుక భరోసా ఇప్పుడు మాకు పాత Hat ఉంది.

455
00:38:46,430 --> 00:38:51,980
మేము ఒక ఇన్పుట్ తీసుకుని, ఇది వేగంగా ఊపిరి పీల్చు ఫైల్ యొక్క పేరు అని అన్నారు,

456
00:38:51,980 --> 00:38:56,010
మరియు తర్వాత మేము, ఒక అవుట్పుట్ పేర్కొనండి

457
00:38:56,010 --> 00:39:01,580
కాబట్టి టెక్స్ట్ ఫైల్ అవుతుంది అటుకులతో అవుట్పుట్, ఫైలు యొక్క పేరు.

458
00:39:03,680 --> 00:39:08,820
ఈ ఉపయోగం ఉంది. ఇప్పుడు మేము ఇన్పుట్ 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
Huffeader గురించి huffile.c సమాచారం ఉంది.

462
00:39:26,910 --> 00:39:33,430
మేము ప్రతి హఫ్ ఫైలు మేజిక్ సంఖ్య తో సంబంధం ఒక Huffeader కలిగి తెలుసు

463
00:39:33,430 --> 00:39:37,240
ప్రతి చిహ్నాన్ని పౌనఃపున్యాల అలాగే వ్యూహం

464
00:39:37,240 --> 00:39:39,570
అలాగే చెక్సమ్ వంటి.

465
00:39:39,570 --> 00:39:43,180
మేము మీకు, కాని మేము కూడా, dump.c ఒక పీక్ పట్టింది

466
00:39:43,180 --> 00:39:49,120
ఇది ఒక హఫ్ ఫైల్లోకి reading జరిగినది.

467
00:39:49,120 --> 00:39:53,990
కాబట్టి ఆ విధంగా చేయడానికి, అది నిజంగా huffed లేదా లేదో తనిఖీ వచ్చింది.

468
00:39:53,990 --> 00:40:03,380
అందువలన మేము మా puff.c. ఒక నిర్మాణం వంటి dump.c ఉపయోగించవచ్చు

469
00:40:03,380 --> 00:40:12,680
తిరిగి pset 4 మేము RGB ట్రిపుల్స్ లో కాపీ ఫైల్ copy.c ఉన్నప్పుడు

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 మీరు PLANT మీరు ఎంచుకున్న ఆ 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 చేసినప్పుడు మేము ఒక నల్ పాయింటర్ విలువ ఇవ్వలేదు అని మీరు అనుకున్నారు.

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 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
కాబట్టి ఆ ఫంక్షన్ నిజమైన తిరిగి మరియు విజయవంతమైన ఉంటే మీరు ఏదో ఒకటి చెయ్యాలి ఎలా.

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
ఇది కేవలం 0 సె మరియు 1s అనుసరించండి ఇప్పుడు చాలా సూటిగా ఉంది.

573
00:48:39,260 --> 00:48:45,480
కాబట్టి సమావేశం ద్వారా మేము ఒక హఫ్ఫ్మన్ చెట్టు లో 0 సె వదిలి సూచించే తెలిసిన

574
00:48:45,480 --> 00:48:48,360
మరియు 1s కుడి సూచిస్తున్నాయి.

575
00:48:48,360 --> 00:48:53,540
మీరు ఒక 0 పొందుతారు మీరు బిట్ ద్వారా బిట్ లో చదవండి కాబట్టి అప్పుడు ఉంటే, ప్రతి సమయం

576
00:48:53,540 --> 00:48:59,100
మీరు ఒక 1 చదివిన ప్రతిసారీ తర్వాత ఎడమ శాఖ అనుసరించండి మరియు మీరు

577
00:48:59,100 --> 00:49:02,100
మీరు కుడి శాఖ అనుసరించండి చూడాలని.

578
00:49:02,100 --> 00:49:07,570
మీరు ఒక ఆకు హిట్ వరకు, ఆపై మీరు కొనసాగించడానికి వెళుతున్న

579
00:49:07,570 --> 00:49:11,550
ఆకులు శాఖలు చివరిలో మాత్రం ఎందుకంటే.

580
00:49:11,550 --> 00:49:16,870
మేము ఒక ఆకు లేదా హిట్ లేదో మేము ఎలా చెప్పగలవు?

581
00:49:19,800 --> 00:49:21,690
మేము ముందు చెప్పారు.

582
00:49:21,690 --> 00:49:24,040
[విద్యార్థి] గమనికలు NULL ఉంటే. >> అవును.

583
00:49:24,040 --> 00:49:32,220
ఎడమ మరియు కుడి రెండు చెట్లను గమనికలు NULL ఉంటే మేము ఒక ఆకు హిట్ ఉంటే మేము తెలియజేయవచ్చు.

584
00:49:32,220 --> 00:49:34,110
పర్ఫెక్ట్.

585
00:49:34,110 --> 00:49:40,320
మేము మా హఫ్ ఫైల్లోకి బిట్ బిట్ లో చదవడానికి కావలసిన తెలుసు.

586
00:49:43,870 --> 00:49:51,220
మేము dump.c లో ముందు చూసిన, వారు ఏమి వారు హఫ్ ఫైల్లోకి బిట్ బిట్ చదవబడుతుంది

587
00:49:51,220 --> 00:49:54,560
మరియు కేవలం ఆ బిట్స్ ఏం చేస్తున్నారో ముద్రించిన.

588
00:49:54,560 --> 00:49:58,430
మేము చేసే విధంగా కావడం లేదు. మేము మరింత క్లిష్టతరంగా అని ఏదో ఒక పని చేస్తూ చూడాలని.

589
00:49:58,430 --> 00:50:03,620
కాని మేము మేము bit కు చదివే కోడ్ సూచించే బిట్ పడుతుంది ఉంది.

590
00:50:03,620 --> 00:50:10,250
ఇక్కడ మేము ఆన్ అని ప్రస్తుత బిట్ ప్రాతినిధ్యం పూర్ణాంక బిట్ కలిగి ఉంటాయి.

591
00:50:10,250 --> 00:50:15,520
మీరు ఫైల్ యొక్క ముగింపు హిట్ వరకు ఈ ఫైలులో బిట్స్ అన్ని iterating జాగ్రత్త తీసుకుంటుంది.

592
00:50:15,520 --> 00:50:21,270
ఆ ఆధారంగా, అప్పుడు మీరు ఇటెరేటర్ రకమైన కావాలి చూడాలని

593
00:50:21,270 --> 00:50:26,760
మీ చెట్టు దాటటానికి.

594
00:50:26,760 --> 00:50:31,460
ఆపై, బిట్ 0 లేదా 1 అనే ఆధారంగా

595
00:50:31,460 --> 00:50:36,920
మీరు ఎడమ ఆ ఇటెరేటర్ తరలించడానికి లేదా కుడి అది తరలించాలనుకుంటున్న చూడాలని

596
00:50:36,920 --> 00:50:44,080
అన్ని మార్గం మీరు ఒక ఆకు హిట్ వరకు, అన్ని మార్గం మీరు ఆ నోడ్ వరకు

597
00:50:44,080 --> 00:50:48,260
ఏ నోడ్స్ సూచించడానికి లేదు.

598
00:50:48,260 --> 00:50:54,300
ఎందుకు మేము ఒక హఫ్ఫ్మన్ ఫైలు కానీ మోర్స్ కోడ్ తో చేయవచ్చు?

599
00:50:54,300 --> 00:50:56,610
మోర్స్ కోడ్ లో సందిగ్దత ఒక బిట్ ఉంది ఎందుకంటే.

600
00:50:56,610 --> 00:51:04,440
మేము వేచి OH వంటి ఉండవచ్చు, మేము మార్గం పాటు ఒక లేఖ హిట్ చేసిన, కాబట్టి బహుశా ఈ, మా అక్షరం

601
00:51:04,440 --> 00:51:08,150
మేము ఒక బిట్ ఇక కొనసాగింది, అప్పుడు మేము మరొక అక్షరం తగిలేలా అయితే.

602
00:51:08,150 --> 00:51:13,110
కానీ, హఫ్ఫ్మన్ ఎన్కోడింగ్ జరిగే కాదు

603
00:51:13,110 --> 00:51:17,540
కనుక మేము వెళుతున్న ఏకైక మార్గం ఒక పాత్ర నొక్కండి గుర్తుంచుకోండి విశ్రాంతి తీసుకోవడానికి

604
00:51:17,540 --> 00:51:23,480
ఆ నోడ్ యొక్క ఎడమ మరియు కుడి పిల్లలు NULL ఉంటే ఉంది.

605
00:51:28,280 --> 00:51:32,350
>> చివరగా, మేము మా మెమరీ అన్ని ఉచిత మీరు.

606
00:51:32,350 --> 00:51:37,420
మేము వ్యవహరించే చేసిన రెండు దగ్గరగా హఫ్ ఫైలు మీరు

607
00:51:37,420 --> 00:51:41,940
అలాగే మా అడవిలో వృక్షముల అన్నీ తొలగించు.

608
00:51:41,940 --> 00:51:46,470
మీ అమలు ఆధారంగా, మీరు బహుశా అటవీ తొలగించు కాల్ మీరు చూడాలని

609
00:51:46,470 --> 00:51:49,780
బదులుగా వాస్తవానికి చెట్లు మీ అన్ని ద్వారా జరుగుతుంది.

610
00:51:49,780 --> 00:51:53,430
మీరు ఏ తాత్కాలిక చెట్లు చేసిన అయితే, మీరు స్వేచ్ఛను చెయ్యవచ్చును.

611
00:51:53,430 --> 00:51:59,060
మీరు మీ కోడ్ తెలుసుకోవటానికి, కాబట్టి మీరు మెమరీ పెడుతోంది చేస్తున్నారు ఇక్కడ మీరు తెలుసు.

612
00:51:59,060 --> 00:52:04,330
మరియు మీరు వెళ్లి అలా అయితే, malloc కోసం F'ing కూడా కంట్రోల్ ప్రారంభించండి

613
00:52:04,330 --> 00:52:08,330
చూసిన ప్రతిసారి మీరు malloc మరియు మీరు ఆ యొక్క ఉచిత నిర్ధారించాడు

614
00:52:08,330 --> 00:52:10,190
కానీ అప్పుడు, మీ కోడ్ ద్వారా వెళ్లి

615
00:52:10,190 --> 00:52:14,260
మీరు మెమరీ కేటాయించింది ఉండవచ్చు పేరు అవగాహన.

616
00:52:14,260 --> 00:52:21,340
సాధారణంగా మీరు ", ఒక ఫైల్ చివరలో నేను నా అడవి మీద అటవీ తొలగించు వెళుతున్న" అని అనవచ్చు

617
00:52:21,340 --> 00:52:23,850
కాబట్టి ప్రాథమికంగా ఉచిత, ఆ స్మృతి స్పష్టం,

618
00:52:23,850 --> 00:52:28,310
"ఆ తరువాత కూడా ఫైల్ మూసి మరియు నా ప్రోగ్రామ్ విడిచి అన్నారు వెళుతున్న."

619
00:52:28,310 --> 00:52:33,810
కానీ మీ ప్రోగ్రామ్ వదిలేసి ఆ సమయం మాత్రమే ఉంది?

620
00:52:33,810 --> 00:52:37,880
కాదు, ఎందుకంటే కొన్నిసార్లు జరిగిన లోపం ఉండవచ్చు.

621
00:52:37,880 --> 00:52:42,080
బహుశా మేము ఒక ఫైల్ను తెరవడం సాధ్యం కాలేదు లేదా మేము మరొక చెట్టు చేయలేకపోయాము

622
00:52:42,080 --> 00:52:49,340
లేదా లోపం రకమైన మెమరీ కేటాయింపు ప్రక్రియ జరిగిన మరియు కనుక ఇది NULL తిరిగి.

623
00:52:49,340 --> 00:52:56,710
ఒక లోపం ఏర్పడింది ఆపై మేము తిరిగి నిష్క్రమించాడు.

624
00:52:56,710 --> 00:53:02,040
కాబట్టి మీరు, మీ ప్రోగ్రామ్ ఏదైనా సాధ్యం సమయం విడిచి దాన్ని ఆ నిర్ధారించుకోవాలి

625
00:53:02,040 --> 00:53:06,980
మీరు అక్కడ మీ మెమరీ అన్ని ఉచిత మీరు.

626
00:53:06,980 --> 00:53:13,370
ఇది మీరు మీ కోడ్ విడిచి ప్రధాన విధి యొక్క చివరిలో మాత్రం కాదు.

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
ఆ వంటి అన్ని పౌనఃపున్యాల మరియు విషయాలను అసలు ప్రయోజనం కంటే

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
>> ధన్యవాదాలు, ప్రతి ఒక్కరూ. ఈ Walkthrough 6 ఉంది. మరియు అదృష్టం మంచి.

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