[Powered by Google Translate] [Walkthrough - సమస్య సెట్ 6]
[Zamyla చాన్ - హార్వర్డ్ యూనివర్శిటీ]
[ఈ CS50 ఉంది. - CS50.TV]
>> హలో, ప్రతి ఒక్కరూ, మరియు Walkthrough 6 స్వాగతం: Huff'n వాచిన.
Huff'n వాచిన మనం ఏమి చేస్తున్నారో ఒక హఫ్ఫ్మన్ సంపీడన ఫైలు వ్యవహరించే విధంగా అన్నారు
తరువాత, తిరిగి అప్ ఇది puffing కాబట్టి, అది decompressing
మేము 0 సె మరియు 1s యూజర్ మాకు పంపిస్తుంది నుండి తద్వారా
మరియు వాస్తవ వచనాన్ని గా తిరిగి మార్చేందుకు.
మీరు కొన్ని ఉపకరణాలు చూడండి చూడాలని ఎందుకంటే Pset 6 చాలా బాగుంది అని అన్నారు
మీరు 1 అందంగా చక్కగా భావన వాటిని కలిపే pset 4 మరియు pset 5 మరియు రకమైన లో ఉపయోగించిన
మీరు దాని గురించి ఆలోచించటం వచ్చినప్పుడు.
>> అలాగే, నిస్సందేహంగా, pset 4 మరియు 5 మేము అందించే వచ్చింది అత్యంత సవాలుగా psets ఉన్నారు.
కాబట్టి ఇప్పుడు, మేము, C లో ఈ 1 మరింత pset కలిగి
మరియు ఆ తర్వాత మేము వెబ్ కార్యక్రమాలను లో ఉన్నారు.
కాబట్టి CS50 లో క్లిష్ట hump పైగా పొందడానికి నిన్ను నీవు అభినందించేందుకు.
>> Huff'n వాచిన కోసం వెళ్లడానికి, ఈ pset కోసం మా పరికరాలపెట్టె, హఫ్ఫ్మన్ చెట్లు ఉంటాయని నేను
కాబట్టి బైనరీ చెట్లు కానీ కూడా ప్రత్యేకంగా హఫ్ఫ్మన్ చెట్లు మాత్రమే ఎలా అర్ధం
ఎలా నిర్మించారు చేస్తున్నారు.
మరియు తర్వాత మేము, ఈ pset పంపిణీ కోడ్ చాలా చూడాలని
మరియు మేము కోడ్ యొక్క కొన్ని వాస్తవానికి చూడటానికి వచ్చిన చేస్తాము
మేము, పూర్తిగా ఇంకా అర్థం చేసుకోవడం కాదు
అందువలన ఆ తర్వాత వారి సహ. h ఫైళ్లు. సి ఫైళ్ళు కాని
మాకు మేము ఆ విధులు పని ఎలా కాబట్టి అవసరమైన తగినంత అవగాహన ఇస్తుంది
లేదా కనీసం వారు ఏమి చేయాలో ఉంటాయి - వారి ఇన్పుట్లను మరియు ప్రతిఫలాన్ని -
మేము బ్లాక్ బాక్స్ లో ఏం తెలియదు కూడా
లేదా లోపల బ్లాక్ బాక్స్ లో ఏం జరుగుతున్నది అర్థం లేదు.
మరియు తర్వాత చివరకు, సాధారణ గా, మేము, కొత్త డేటా నిర్మాణాలు వ్యవహరించే ఉంటాయి
ఆ ల నిర్దిష్ట రకాల కొన్ని విషయాలను సూచించండి
మరియు ఇక్కడ రూపకల్పన ప్రక్రియ కోసం మాత్రమే కలం మరియు కాగితం కలిగి
మరియు మీరు మీ pset పని ఎలా గుర్తించడానికి ప్రయత్నిస్తున్న
కానీ డీబగ్గింగ్ సమయంలో.
మీరు విలువలు ఏమిటో రాసుకోదగిన మీరు, మీ కలం మరియు కాగితం పాటు GDB కలిగి
పేరు మీ బాణాలు పై, మరియు ఆ వంటి విషయాలు.
>> మొదటి హఫ్ఫ్మన్ చెట్లు చూడండి యొక్క తెలపండి.
హఫ్ఫ్మన్ చెట్లు ప్రతి నోడ్ మాత్రమే 2 పిల్లలు అంటే, బైనరీ చెట్లు ఉన్నాయి.
హఫ్ఫ్మన్ చెట్లు లో లక్షణం అని తరచుగా విలువలు
తక్కువ బిట్స్ ప్రాతినిధ్యం వహిస్తున్నారు.
మేము మోర్స్ కోడ్ ఉపన్యాసం ఉదాహరణలు, సంఘటిత ఏ రకమైన కొన్ని అక్షరాలు లో చూసింది.
మీరు ఉదాహరణకు ఒక A లేదా ఒక E, అనువదించడానికి ప్రయత్నిస్తున్న ఉంటే
మీరు ఆ తరచుగా తర్జుమా చేస్తున్నాం బదులుగా బిట్స్ పూర్తి సెట్ ఉపయోగించడానికి అవసరం
ఆ సాధారణ డేటా రకం కోసం కేటాయించబడిన, మీరు, తక్కువ దాన్ని కుదించుము
ఆపై ప్రాతినిధ్యం వారికి అక్షరాలు తక్కువ తరచుగా ఎక్కువ బిట్స్ తో ప్రాతినిధ్యం ఉంటాయి
ఆ అక్షరాలు కనిపించే ఫ్రీక్వెన్సీలను అవుట్ బరువు మీరు ఆ కోరుకుంటాను ఎందుకంటే.
మేము హఫ్ఫ్మన్ చెట్లు ఇక్కడ అదే ఆలోచన ఉంది
అక్కడ ఒక గొలుసు, కొన్ని అక్షరాలు చెయ్యడానికి మార్గం ఒక రకమైన చేస్తున్నాము.
మరియు తర్వాత చాలా ఫ్రీక్వెన్సీ కలిగిన అక్షరాలు
తక్కువ బిట్స్ తో ఇస్తున్నాయి.
>> మీరు ఒక హఫ్ఫ్మన్ చెట్టు నిర్మించడానికి విధంగా
టెక్స్ట్ కనిపించే అక్షరాలు అన్ని ఉంచడం ద్వారా
మరియు వారి ఫ్రీక్వెన్సీ గణన, ఎంత తరచుగా కనిపిస్తాయి.
ఈ గాని ఆ అక్షరాలు కనిపిస్తాయి ఎన్ని సార్లు COUNT కావచ్చు
లేదా బహుశా ప్రతి ఒక కనిపిస్తుంది ఎన్ని అన్ని అక్షరాలు నుండి ఒక శాతం.
కాబట్టి మీరు ఏమి, మీరు ఆ మ్యాప్ అవ్ట్ అన్ని ఉంటుంది
అప్పుడు మీరు 2 తక్కువ పౌనః కోసం చూడండి మరియు తరువాత తోబుట్టువుల వాటిని చేరడానికి
పేరు మాతృ నోడ్ దాని 2 పిల్లలు మొత్తం ఒక ఫ్రీక్వెన్సీ ఉంది.
ఆపై మీరు కన్వెన్షన్ ద్వారా పేర్కొన్నట్లు ఎడమ నోడ్,
మీరు, 0 శాఖ అనుసరించడం ద్వారా ఆ
ఆపై కుడివైపు నోడ్ 1 శాఖ.
మేము మోర్స్ కోడ్ లో చూసిన, ఒక gotcha అని మీరు ఒక బీప్ మరియు బీప్ కలిగి ఉంటే
ఇది అస్పష్టమైన ఉంది.
ఇది గాని 1 లేఖ ఉంటుంది లేదా 2 అక్షరాల క్రమాన్ని ఉంటుంది.
కాబట్టి ఏమి హఫ్ఫ్మన్ చెట్లు ఉండదు పాత్రల స్వభావం ద్వారా ఎందుకంటే
లేదా మా చివరి అసలు అక్షరాలు శాఖ చివరి నోడ్స్ ఉండటం -
మేము ఆకులు ఆ చూడండి - ఆ కారణం వలన ఏదైనా సందిగ్ధత ఉండదు
మీరు బిట్ల వరుస ఎన్కోడ్ ప్రయత్నిస్తున్న ఇది లేఖ పరంగా
ఎందుకంటే 1 లేఖ సూచించే బిట్స్ పాటు ఎక్కడా
మీరు మరొక మొత్తం లేఖ ఎదుర్కునే, ఇక్కడ కూడా ఏ గందరగోళం ఉండవు.
కానీ మీరు అబ్బాయిలు వాస్తవానికి చూసే ఉదాహరణలు వెళ్ళాలని మేము
బదులుగా మాకు ఆ నిజమని మీరు చెప్పటం.
>> యొక్క ఒక హఫ్ఫ్మన్ చెట్టు యొక్క ఒక చిన్న ఉదాహరణ చూద్దాం.
నేను 12 అక్షరాలు ఇక్కడ ఒక స్ట్రింగ్ కలిగి ఉంటాయి.
నేను 6 Bs, మరియు 2 CS, 4 ఉంటాయి.
నా మొదటి అడుగు లెక్కించడానికి ఉంటుంది.
ఒక ఎన్ని సార్లు కనిపిస్తుంది? ఇది స్ట్రింగ్ లో 4 సార్లు కనిపిస్తుంది.
B 6 సార్లు కనిపిస్తుంది, మరియు సి 2 సార్లు కనిపిస్తుంది.
సహజంగానే, నేను, చాలా తరచుగా B ఉపయోగించి నేను చెప్పడానికి వెళుతున్న
నేను బిట్స్ యొక్క తక్కువ సంఖ్య, 0 సె మరియు 1s యొక్క తక్కువ సంఖ్యలో B ప్రాతినిధ్యం మీరు.
మరియు నేను కూడా సి అలాగే 0 సె మరియు 1s చాలా అవసరమవుతుంది అంచనా వెళుతున్న.
మొదటి నేను ఇక్కడ ఏమి పౌనఃపున్యం పరంగా క్రమంలో వాటిని ఉంచుతారు.
మేము సి మరియు A, ఆ మా 2 తక్కువ పౌనః అని చూడండి.
, మేము ఒక పేరెంట్ నోడ్ సృష్టించడానికి, మరియు ఆ పేరెంట్ నోడ్ ఇది సంబంధం ఒక లేఖ లేదు
కానీ మొత్తానికి ఒక ఫ్రీక్వెన్సీ, కలిగి ఉంది.
మొత్తం 6 ఇది 2 + 4, అవుతుంది.
అప్పుడు మేము ఎడమ శాఖ అనుసరించండి.
మేము ఆ 6 నోడ్ వద్ద ఉంటే, అప్పుడు మేము సి చెయ్యడానికి 0 అనుసరించింది
మరియు తర్వాత 1 A. చెయ్యడానికి
కాబట్టి ఇప్పుడు మేము 2 నోడ్స్ ఉన్నాయి.
మేము విలువ 6 కలిగి ఆపై మేము కూడా విలువ 6 తో మరొక నోడ్ ఉన్నాయి.
కాబట్టి ఆ 2 అత్యల్ప 2 కూడా వదిలి కేవలం 2, ఇది నిలిచింది
కాబట్టి మేము మొత్తం 12 తో మరో మాతృ ద్వారా ఆ చేరండి.
కాబట్టి ఇక్కడ మా హఫ్ఫ్మన్ చెట్టు కలిగి
B ను ఎక్కడ, కేవలం బిట్ 1 ఉంటుంది
మరియు తరువాత వెళ్ళడానికి మేము సి 00 కలిగి అప్పుడు 01 కలిగి మరియు ఉంటుంది.
కాబట్టి ఇక్కడ ప్రధానంగా మేము 1 లేదా 2 బిట్స్ గాని ఈ అక్షరాలు ప్రాతినిధ్యం మేము చూసాము
పేరు గా అంచనా B,, కనీసం ఉంది.
ఆపై, మేము సి అత్యంత కలిగి భావించారు, కానీ ఇది ఒక చిన్న హఫ్ఫ్మన్ చెట్టు నుండి
అప్పుడు కూడా మధ్య ఎక్కడో వ్యతిరేకంగా 2 బిట్స్ ప్రాతినిధ్యం వహిస్తుంది.
>> జస్ట్ హఫ్ఫ్మన్ చెట్టు యొక్క మరొక చిన్న ఉదాహరణ వెళ్ళి కు,
మీరు స్ట్రింగ్ కలిగి చెప్పారు "హలో."
మీరు ఏమి మీరు ఎన్ని సార్లు H ఈ కనిపిస్తాయి చెబుతున్నారు మొదటి ఉంది?
H ఒకసారి మరియు తరువాత ఇ కనిపిస్తుంది కనిపిస్తే తరువాత మేము రెండుసార్లు కనిపించే l కలిగి
మరియు o ఒకసారి కనిపించే.
కాబట్టి అప్పుడు మేము బిట్స్ అతి తక్కువ సంఖ్యలో ద్వారా ప్రాతినిధ్యం వహించే ఇది లేఖ ఆశించడం?
[విద్యార్థి] l. >> L. అవును. l హక్కు.
మేము l బిట్స్ అతి తక్కువ సంఖ్యలో ద్వారా ప్రాతినిధ్యం కోరుకోవడం
ఎందుకంటే l "హలో." స్ట్రింగ్ లో ఉపయోగిస్తారు
నేను ఇప్పుడు ఏమి వెళుతున్న ఏమి ఈ నోడ్స్ అవుట్ డ్రా ఉంది.
నేను o ఇది ఇ మరొక 1, ఆపై ఒక 1, H ఇది 1 ఉంది, మరియు -
l ఇది, ఆపై 2 - ప్రస్తుతం నేను వీరిని చూస్తూ నేను.
అప్పుడు నేను ఒక హఫ్ఫ్మన్ చెట్టు నిర్మించడానికి విధంగా కనీసం పౌనఃపున్యాలు కలిగిన 2 నోడ్స్ కనుగొనేందుకు అంటారు
మరియు ఒక పేరెంట్ నోడ్ సృష్టించడం ద్వారా వాటిని తోబుట్టువుల చేయండి.
ఇక్కడ మేము తక్కువ పౌనఃపున్య 3 నోడ్స్ ఉన్నాయి. వారు అన్ని 1 ఉన్నాము.
కాబట్టి ఇక్కడ మేము మొదటి లింక్ చూడాలని ఇది ఒకదాన్ని ఎంచుకోండి.
లెట్ యొక్క నేను H మరియు ఇ ఎంచుకోండి చెప్పారు.
1 మొత్తం + 1 2, కానీ ఈ నోడ్ ఇది సంబంధం ఒక లేఖ లేదు.
ఇది కేవలం విలువ కలిగి ఉంది.
ఇప్పుడు రాబోయే 2 తక్కువ పౌనః చూడండి.
ఆ 2 మరియు 1 మాత్రమే. దానిని ఆ 2 యొక్క ఉంటుంది, కానీ నేను ఈ ఒకదాన్ని ఎంచుకోండి వెళుతున్న.
మొత్తం 3.
మరియు తర్వాత చివరకు, నేను మాత్రమే కాబట్టి అప్పుడు 5 మారుతుంది, 2 మిగిలింది.
నేను ఆ ఎన్కోడింగును పూర్తి అయితే ఇక్కడ, వంటి, అంచనా,
1s ఎల్లప్పుడూ సరైన శాఖ మరియు 0 సె ఒక్క ఉంటాయి.
అప్పుడు మేము 2 కేవలం 1 బిట్ మరియు తరువాత o ద్వారా ప్రాతినిధ్యం l కలిగి
ఆపై 2 ఇ ఆపై H 3 బిట్స్ క్రిందికి వస్తుంది.
కాబట్టి మీరు "హలో" ఈ సందేశం ప్రసారం చేయవచ్చు బదులుగా వాస్తవానికి అక్షరాలు ఉపయోగించి
కేవలం 0 సె మరియు 1s ద్వారా.
అయితే, అనేక సందర్భాల్లో మేము మా తరచుగా సంబంధాలు గుర్తుంచుకోవాలి.
మేము గాని ఉండవచ్చు మొదటి H మరియు o చేరారు కాలేదు.
లేదా తర్వాత మేము 2 ప్రాతినిధ్యం l ఉన్నప్పుడు న
అలాగే 2 ప్రాతినిధ్యం ఒక చేరారు, మేము గాని ఒక లింక్ లేదు.
>> కాబట్టి మీరు పంపించినప్పుడు 0 సె మరియు 1s, వాస్తవానికి హామీ లేదు
స్వీకర్త పూర్తిగా కుడి బ్యాట్ ఆఫ్ మీ సందేశం చదవగలరు
వారు మీరు చేసిన నిర్ణయం కాదు కాబట్టి.
కాబట్టి మేము హఫ్ఫ్మన్ కుదింపు వ్యవహరించే చేసినప్పుడు,
ఏదో మనం నిర్ణయించుకుంది మా భాషా గ్రహీత చెప్పడం కలిగి -
వారు అదనపు సమాచారం రకమైన తెలుసుకోవాలి
సంపీడన సందేశాన్ని పాటు.
వారు చెట్టు నిజానికి ఎలా అర్థం చేసుకోవాలి
మేము నిజంగా ఆ నిర్ణయాలను తీసుకున్నాడు ఎలా.
>> ఇక్కడ మనం కేవలం వాస్తవ లెక్కింపు ఆధారంగా ఉదాహరణలు చేస్తున్న
కానీ కొన్నిసార్లు మీరు కూడా ఒక హఫ్ఫ్మన్ చెట్టు ఉండవచ్చు
ఫ్రీక్వెన్సీ ఆధారంగా అక్షరాలను కనిపిస్తాయి, మరియు అది ఖచ్చితమైన ప్రక్రియ ఇందులో వద్ద.
ఇక్కడ నేను, శాతాలు లేదా ఒక భిన్నం పరంగా అది వ్యక్తం చేస్తున్నాను
మరియు ఇక్కడ ఖచ్చితమైన విషయం.
నేను, 2 అత్యల్ప, వాటిని సంకలనం, అత్యల్ప తదుపరి 2, వాటిని సంకలనం కనుగొనడానికి
నేను ఒక పూర్తి చెట్టు వరకు.
మేము అది మేము శాతాలు వ్యవహరించే చేసినప్పుడు గాని మార్గం,, చేయగల ఉన్నప్పటికీ
మేము విషయాలు విభజన మరియు దశాంశాలు వ్యవహరించే ఉన్నారని అర్ధం లేదా బదులుగా తేలియాడు
మేము ఒక తల డేటా నిర్మాణాలు గురించి ఆలోచిస్తున్నామని మీరు ఉంటే.
మేము తేలియాడుతున్న గురించి ఏమి తెలుసు?
మేము తేలియాడుతున్న వ్యవహరించే చేసినప్పుడు ఒక సమస్య ఏమిటి?
[విద్యార్థి] అస్పష్టమైన అంకగణితం. >> అవును. Imprecision.
ఎందుకంటే ఫ్లోటింగ్ పాయింట్ imprecision ఈ pset కోసం మేము నిర్ధారించుకోండి తద్వారా
మేము ఏ విలువలు కోల్పోతే లేని, అప్పుడు మేము నిజంగా COUNT వ్యవహరించే కావడం చేస్తున్నారు.
మీరు ఇక్కడ నిర్మాణం తిరిగి చూస్తే, ఒక హఫ్ఫ్మన్ నోడ్ ఆలోచించడానికి అలా అయితే
మీరు ఆకుపచ్చ వాటిని చూడండి ఉంటే ఆ సంబంధిత ఒక ఫ్రీక్వెన్సీ ఉంది
అలాగే తన ఎడమ ఒక నోడ్ అలాగే దాని కుడివైపున ఒక నోడ్ సూచిస్తుంది.
మరియు తర్వాత ఎరుపు వాటిని అక్కడ కూడా వారికి సంబంధం ఒక పాత్ర కలిగి.
మేము, తల్లిదండ్రులు మరియు అప్పుడు ఫైనల్ నోడ్స్ ప్రత్యేక వాటిని సిధ్ధంగా లేదు
ఇది మేము ఆకులు వంటి చూడండి, అయితే కేవలం కొన్ని శూన్య విలువలు ఉంటుంది.
ప్రతి నోడ్ కొరకు మేము ఒక పాత్ర, ఆ నోడ్ ప్రాతినిధ్యం గుర్తు, ఉంటుంది
అప్పుడు ఒక ఫ్రీక్వెన్సీ మరియు దాని ఎడమ చైల్డ్ అలాగే దాని కుడి చైల్డ్ ఒక పాయింటర్.
చాలా దిగువన ఉండే ఆకులు కూడా నోడ్ గమనికలు ఉంటుంది
వారి ఎడమ మరియు వారి కుడి, కాని ఆ విలువకు అసలు నోడ్స్ సూచించే లేనందున,
వారి విలువ విధంగా ఉంటుంది? >> [విద్యార్థి] NULL. >> NULL. సరిగ్గా.
ఇక్కడ మీరు తేలియాడుతున్న పౌనఃపున్య ప్రాతినిధ్యం ఎలా ఒక ఉదాహరణ, యొక్క
కానీ మేము, పూర్ణ తో వ్యవహరించే కావడం చేస్తున్నారు
నేను అది అన్ని అక్కడ డేటా రకం మార్పు.
>> యొక్క ఒక క్లిష్టమైన ఉదాహరణ యొక్క కొద్దిగా ఎక్కువ వెళ్లే లెట్.
అయితే ఇప్పుడు మేము సాధారణ వాటిని పూర్తి చేసారు, అది కేవలం అదే ప్రక్రియ ఉంది.
మీరు 2 తక్కువ పౌనః కనుగొనడానికి, పౌనఃపున్యాలు సంకలనం
మరియు ఆ, మీ తల్లిదండ్రుల నోడ్ యొక్క కొత్త ఫ్రీక్వెన్సీ ఉంది
ఇది 1 శాఖ తో 0 శాఖ మరియు కుడి తన ఎడమ సూచిస్తుంది.
మేము స్ట్రింగ్ "ఈ cs50 ఉంది," ఉంటే అప్పుడు మేము, T పేర్కొన్నారు ఎన్ని COUNT సార్లు
h పేర్కొన్నారు, నేను, s, సి, 5, 0.
అప్పుడు నేను ఇక్కడ చేశాడు, నేను నాటిన ఎరుపు నోడ్స్ తో ఉంది
నేను నా చెట్టు క్రింద ఉన్న చివరికి ఈ అక్షరాలు వెళుతున్న చెప్పారు.
ఆ ఆకులు అన్ని ఉంటాయని నేను.
ఇంకా ఏమిటి ఐ డిడ్, ఐ క్రమంలో తరచుగా వాటిని క్రమబద్ధీకరించబడింది
మరియు ఈ నిజంగా pset కోడ్ అది ఆ మార్గం
ఇది తరచుగా రకాల అది తరువాత అక్షర ఉంది.
కాబట్టి అది ఫ్రీక్వెన్సీ ద్వారా అక్షర మరియు తర్వాత సంఖ్యలు ఉన్నాయి.
అప్పుడు నేను ఉంటుంది నేను 2 అత్యల్ప గుర్తించవచ్చు ఉంది. ఆ 0 మరియు 5 మాత్రమే.
నేను వాటిని సంకలనం, మరియు ఆ 2 ఉంది. అప్పుడు నేను తరువాత 2 అత్యల్ప కనుగొనడానికి, కొనసాగింది.
ఆ రెండు 1s, తరువాత ఆ అలాగే 2 మారింది.
ఇప్పుడు నా తదుపరి దశలో, అతి తక్కువ చేరడం కావడం మనకు తెలుసు
ఇది 1 T, ఆపై ఫ్రీక్వెన్సీ వంటి 2 కలిగి నోడ్స్ యొక్క ఒక ఎంచుకోవడం.
కాబట్టి ఇక్కడ 3 ఎంపికలు ఉన్నాయి.
నేను స్లయిడ్ కోసం చేయ బోతున్నాను అంటే కేవలం కనిపించే వాటిని మీ కోసం క్రమాన్ని ఉంది
తద్వారా మీరు నేను దీనిని నేను ఎలా చూడగలరు.
కోడ్ మరియు మీ పంపిణీ కోడ్ చేయబోవడం ఏమి T ఒక చేరడానికి ఉంటుంది
0 మరియు 5 నోడ్ తో.
కాబట్టి అప్పుడు 3 మొత్తాలను, మరియు మేము ప్రక్రియ కొనసాగుతుంది ఆ.
2 మరియు 2 ఇప్పుడు అప్పుడు, 4 ఆ మొత్తం అత్యల్ప ఉంటాయి.
అందరూ ఇప్పటివరకు తరువాత? సరే.
ఆ తర్వాత మేము, 3 మరియు జోడించడానికి అవసరమైన 3 కలిగి
మీరు చాలా దారుణంగా పొందండి లేదు దృశ్యపరంగా కాబట్టి చూడగలరు కాబట్టి మరలా నేను అది మారే చేస్తున్నాను.
మేము కేవలం 2 నోడ్స్ కలిగి అప్పుడు మేము ఒక 6 కలిగి, తరువాత మా చివరి దశ ప్రస్తుతం
మేము 10 ఇది మా చెట్టు యొక్క root చేయడానికి ఆ మొత్తం.
ప్రతి నోడ్ ప్రాతినిధ్యం ఎందుకంటే మరియు సంఖ్య 10, అర్ధమే
వారి విలువ, వాటి తరచుదనం సంఖ్య, వారు స్ట్రింగ్ కనిపించింది ఎన్ని సార్లు ఉంది
మరియు తర్వాత మేము మా స్ట్రింగ్ లో 5 అక్షరాలు, అర్ధమే తద్వారా.
మేము దీన్ని ఎన్కోడ్ ఎలా వద్ద చూసేందుకు, ఉంటే
అనుకున్న, నేను మరియు తరచుగా కనిపించే s,
బిట్ల తక్కువ సంఖ్య సూచించబడతాయి.
>> ఇక్కడ జాగ్రత్తగా ఉండండి.
హఫ్ఫ్మన్ చెట్లు లో కేసు వాస్తవానికి ముఖ్యమైనది.
ఒక పెద్ద S ఒక చిన్న s కంటే భిన్నంగా ఉంటుంది.
మేము కలిగి ఉంటే, చిన్న s మాత్రమే రెండుసార్లు కనిపిస్తుంది అప్పుడు, పెద్ద అక్షరాలతో "ఈ CS50 ఉంది"
దాని విలువ 2 తో నోడ్ ఉంటుంది, మరియు తర్వాత పెద్ద S మాత్రమే ఒకసారి ఉంటుంది.
మీరు నిజంగా ఇక్కడ ఒక అదనపు ఆకు ఎందుకంటే కాబట్టి అప్పుడు మీ వృక్ష నిర్మాణాలు మార్చుకోవచ్చు.
కానీ మొత్తం ఇప్పటికీ 10 ఉంటుంది.
అంటే, మేము నిజంగా చెక్సమ్ కాల్ కావడం ఏమి ఉంది
గణనలు అన్ని యొక్క అదనంగా.
>> ఇప్పుడు మేము హఫ్ఫ్మన్ చెట్లు కవర్ చేసిన, మేము Huff'n వాచిన, pset ప్రవేశిస్తాడు చేయవచ్చు.
మేము, ప్రశ్నలు ఒక విభాగం ప్రారంభం చూడాలని
మరియు ఈ మీరు బైనరీ చెట్లు మరియు ఆ చుట్టూ ఆపరేట్ తో అలవాటుపడిన పొందడానికి అన్నారు:
గీయడం నోడ్స్, నోడ్సుకోసం మీ స్వంత typedef struct సృష్టిస్తుంది
మరియు మీరు ఒక బైనరీ చెట్టు, క్రమబద్ధీకరించబడింది ఉండే ఇన్సర్ట్ ఎలా చూడటం,
అది, మరియు ఆ వంటి వాటిని నదీ ప్రవాహానికి అడ్డంగా ప్రయాణం.
విజ్ఞానం ఖచ్చితంగా Huff'n వాచిన భాగంలోకి మీరు డైవ్ మీకు సహాయం అన్నారు
pset యొక్క.
Pset యొక్క ప్రామాణిక ఎడిషన్, మీ పని, వాచిన అమలు చేయడం
మరియు హ్యాకర్ వెర్షన్ లో మీ పని హఫ్ అమలు ఉంది.
హఫ్ ఏమి, టెక్స్ట్ తీసుకుని అప్పుడు 0 సె మరియు 1s గా అనువదిస్తుంది
కాబట్టి మేము ఫ్రీక్వెన్సీలను లెక్కిస్తారు పేరు మేము పైన అని ప్రక్రియ
ఆపై చెట్టు చేసిన తరువాత చెప్పారు, "నేను T వస్తుందా?"
T 100 ప్రాతినిధ్యం వహిస్తుంది, ఆ వంటి వాటిని,
ఆపై హఫ్ టెక్స్ట్ మరియు తరువాత అవుట్పుట్ ఆ బైనరీ పడుతుంది.
కానీ మేము సందేశాన్ని మా గ్రహీత అనుమతించాలనుకుంటున్న తెలుసు ఎందుకంటే
ఖచ్చితమైన చెట్టు సృష్టించడానికి, అది కూడా పౌనఃపున్య గణనలు గురించి సమాచారాన్ని కలిగి ఉంది.
అప్పుడు వాచిన తో మేము 0 సె మరియు 1s ఒక బైనరీ ఫైలు ఇవ్వబడ్డాయి
మరియు పౌనఃపున్యాల గురించి సమాచారం ఇచ్చారు.
మేము, ఒక యదార్ధ సందేశానికి ఆ 0 సె మరియు 1s తిరిగి అన్ని అనువదించు
కాబట్టి మేము ఆ decompressing చేస్తున్నారు.
మీరు ప్రామాణిక ఎడిషన్ చేయడం, మీరు, హఫ్ అమలు లేదు
కాబట్టి అప్పుడు మీరు హఫ్ యొక్క సిబ్బంది అమలు ఉపయోగించవచ్చు.
అలా ఎలా స్పెక్ సూచనలను ఉన్నాయి.
మీరు ఒక నిర్దిష్ట టెక్స్ట్ ఫైల్ మీద హఫ్ యొక్క సిబ్బంది అమలు అమలు చెయ్యవచ్చు
ఆపై పఫ్ మీ ఇన్పుట్ ఆ అవుట్పుట్ ఉపయోగించండి.
>> నేను ముందు చెప్పినట్లుగా, మేము ఈ ఒక పంపిణీ కోడ్ చాలా ఉన్నాయి.
నేను ద్వారా వెళ్ళి మొదలు వెళుతున్న.
నేను అధిక సమయాన్ని వెళుతున్న. H ఫైళ్లు
మేము. h ఎందుకంటే. సి ఫైళ్లను, ఎందుకంటే
మరియు ఆ, ఫంక్షన్స్ నమూనాలను అందిస్తుంది
మేము పూర్తిగా ఖచ్చితంగా అర్థం లేదు -
మీరు. సి ఫైళ్లను ఏమి అర్థం లేదు, అప్పుడు, చాలా ఆందోళన చెందకండి
అది కొన్ని సూచనలు ఇస్తుంది కాబట్టి కానీ ఖచ్చితంగా చూడాల్సిన ప్రయత్నించండి
మరియు అది ఇతరుల కోడ్ reading ఉపయోగిస్తారు పెట్టడానికి ఉపయోగం.
>> Huffile.h వద్ద గురించి, వ్యాఖ్యలు లో హఫ్ఫ్మన్-కోడెడ్ ఫైళ్లను సంగ్రహణం ఒక పొర ప్రకటించాడు.
మేము ఓడిపోవుట ఉంటే, మేము కోసం సంకేతాలు అవసరం అని 256 చిహ్నాలు గరిష్టంగా ఉందని చూడండి.
పెద్ద మరియు చిన్న - - ఈ వర్ణమాల యొక్క అన్ని అక్షరాలు కలిగి
ఆపై చిహ్నాలు మరియు సంఖ్యలు, మొదలైనవి
ఇక్కడ మేము ఒక హఫ్ఫ్మన్-కోడెడ్ ఫైలు గుర్తించబడిన మేజిక్ ఉన్నాయి.
ఒక హఫ్ఫ్మన్ కోడ్ లోపల వారు ఒక నిర్దిష్ట మేజిక్ సంఖ్య చూడాలని
శీర్షిక సంబంధం.
ఇది, కేవలం ఒక యాదృచ్చిక మేజిక్ సంఖ్య లాగా ఉండవచ్చు
మీరు నిజంగా ASCII అనువదించండి అయితే, అది నిజంగా హఫ్ అవుట్ వ్రాయబడి ఉండేది.
ఇక్కడ మేము ఒక హఫ్ఫ్మన్-ఎన్కోడ్ ఫైల్ కోసం ఒక struct ఉన్నాయి.
ఒక హఫ్ ఫైలు సంబంధం ఈ లక్షణాలు అన్ని ఉన్నాయి.
అప్పుడు డౌన్ ఇక్కడ మేము ఒక హఫ్ ఫైల్ శీర్షిక కలిగి ఉంటాయి, కాబట్టి మేము అది Huffeader కాల్
బదులుగా ఇది ఎలాగైనా అదే ధ్వనులు ఎందుకంటే అదనపు h జోడించే.
అందమైన.
మేము దానికి సంబంధించిన ఒక మాయా ఉన్నాయి.
అది అసలైన హఫ్ ఫైల్, అది, అప్ పై ఈ మాయా ఒక సంఖ్య చేస్తాడు.
అది ఒక అర్రే ఉంటుంది.
కాబట్టి ప్రతి చిహ్నాన్ని, వీటిలో 256 ఉన్నాయి
అది ఆ చిహ్నాలు యొక్క ఫ్రీక్వెన్సీ హఫ్ ఫైలులోని ఏమిటో జాబితా చెప్పారు.
మరియు తర్వాత, చివరిగా మనకు, పౌనఃపున్యాలకు చెక్సమ్ కలిగి
ఆ పౌనఃపున్యాల మొత్తం ఉండాలి.
కాబట్టి ఆ ఏమి ఒక Huffeader ఉంది.
అప్పుడు మేము హఫ్ ఫైలు తదుపరి బిట్ తిరిగి కొన్ని విధులు
అలాగే hfclose, ఇక్కడ ఈ ఫంక్షన్ తర్వాత, హఫ్ ఫైలు ఒక బిట్ రాశాడు, మరియు
వాస్తవానికి హఫ్ ఫైలు ముగుస్తాయి.
ముందు, మేము నేరుగా కేవలం fclose వ్యవహరించే చేశారు
కానీ మీరు ఒక హఫ్ ఫైలు ఉన్నప్పుడు, బదులుగా fclosing యొక్క
మీరు నిజంగా చేయబోతున్నామని hfclose మరియు hfopen ఉంది.
ఆ మేము వ్యవహరించే కావడం చేస్తున్న హఫ్ ఫైళ్ళకు నిర్దిష్ట విధులు.
ఇక్కడ మేము శీర్షికలో చదివి అప్పుడు శీర్షిక వ్రాసే.
>> జస్ట్. H ఫైలు చదవడం ద్వారా మేము, ఒక హఫ్ ఫైలు కావచ్చు దేనిని పొందుటకు రకం చెయ్యవచ్చు
ఇది నిజానికి huffile.c వెళ్లడానికి లేకుండా, దానికి లక్షణాలు
ఇది మేము లో ఈత కొట్టడానికి ఉంటే, ఒక మరింత క్లిష్టతరంగా అన్నారు.
ఇది I / O ఇక్కడ గమనికలు వ్యవహరించే ఫైలు యొక్క అన్ని ఉన్నాయి.
ఇక్కడ మేము hfread కాల్ చేసినప్పుడు, ఉదాహరణకు, ఇది fread వ్యవహరించే చేసే చూడండి.
మేము పూర్తిగా ఆ విధులను తొలగిస్తున్నాము లేదు, కానీ మేము జాగ్రత్తగా తీసుకోవలసిన ఆ పంపిస్తున్నాం
బదులుగా ఇది మనలోని అన్ని చేయడం యొక్క హఫ్ ఫైలు లోపల.
మీరు ఆసక్తిగా ఉంటే ఈ ద్వారా స్కాన్ సంకోచించకండి చేయవచ్చు
మరియు వెళ్లి తిరిగి పొర కొద్దిగా చర్మము.
>> మేము చూడండి చూడాలని ఉద్దేశ్యంతో తదుపరి ఫైలు tree.h. ఉంది
Walkthrough స్లయిడ్లలో ముందు మనం ఒక హఫ్ఫ్మన్ నోడ్ ఆశించడం చెప్పారు
మరియు మేము ఒక typedef struct నోడ్ చేసింది.
మేము ఒక గుర్తు, ఫ్రీక్వెన్సీ, ఆపై 2 నోడ్ నక్షత్రాలు కలిగి ఉంటుందని అంచనా.
ఈ సందర్భంలో మనం చేస్తున్నా ఈ తప్పనిసరిగా అదే ఉంది
బదులుగా నోడ్ యొక్క తప్ప మేము వాటిని చెట్లు కాల్ చూడాలని.
మీరు చెట్టు తయారు కాల్ అది మీరు ఒక చెట్టు పాయింటర్ తిరిగి ఒక చర్య.
మీరు ఒక కొత్త నోడ్ తయారు చేసేటప్పుడు, స్పెల్లర్ తిరిగి
మీరు చెప్పారు నోడ్ * కొత్త పదం = malloc (sizeof) మరియు ఆ వంటి వాటిని.
సాధారణంగా, mktree మీరు ఆ వ్యవహరించే విధంగా అన్నారు.
అదేవిధంగా, మీరు ఒక చెట్టు తొలగించాలని ఉన్నప్పుడు,
కాబట్టి ముఖ్యంగా, మీరు పూర్తి చేసినప్పుడు చెట్టు ఉండండి యొక్క
బదులుగా స్పష్టంగా ఆ ఉచిత కాల్, మీరు నిజానికి rmtree ఫంక్షన్ను ఉపయోగించడానికి వెళుతున్న
మీరు ఆ చెట్టు పాయింటర్ లో పాస్ మరియు tree.c మీరు ఆ జాగ్రత్త పడుతుంది.
>> మేము tree.c. పరిశీలిస్తాము
మేము అదే అమలు చూడండి తప్ప అదే విధంగా భావిస్తున్నారు.
మేము ఊహించిన విధంగా, మీరు mktree కాల్ అది, ఒక పాయింటర్ ఒక చెట్టు యొక్క పరిమాణం mallocs
శూన్య విలువను, కాబట్టి 0 సె లేదా NULLs కు విలువలు అన్ని initializes
మరియు తర్వాత మీరు మీకు malloc'd చేసిన ఆ చెట్టు పాయింటర్ తిరిగి.
ఇక్కడ మీరు చెట్టు తొలగించు కాల్ అది మొదటి మీరు డబుల్ ఉండండి లేదు అని మీరు చేస్తుంది.
మీరు నిజంగానే మీరు తొలగించాలని ఒక చెట్టు ఉందని చేస్తుంది.
ఒక చెట్టు కూడా దాని పిల్లలు కూడా ఉన్నారు, ఇక్కడ ఎందుకంటే
ఈ ఏమి ఇది పునరావృతంగా చెట్టు యొక్క ఎడమ ఉపయుక్త లో చెట్టు తొలగించు కాల్స్
అలాగే కుడి నోడ్ వంటి.
ఇది మాతృ కాపాడి ముందు, అది పిల్లలను అవసరం.
మాతృ కూడా root పరస్పర మార్పిడి ఉంది.
కాబట్టి గొప్ప-మునిమనమడు-ముత్తాత వంటి మొట్టమొదటి మాతృ,
లేదా అమ్మమ్మ చెట్టు, మొదటి మేము మొదటి స్థాయిలు డౌన్ విడిపించేందుకు ఉంటుంది.
కాబట్టి ఆ ఉచిత, దిగువ ప్రయాణించి, తర్వాత ఆ, మొదలైనవి తిరిగి ఉచిత ఆలోచన
కాబట్టి ఆ చెట్టు.
>> ఇప్పుడు మేము అటవీ చూడండి.
మీరు మీ హఫ్ఫ్మన్ చెట్లు అన్ని ఉంచండి పేరు ఫారెస్ట్.
ఇది ఒక ప్లాట్లు అని ఏదో చూడాలని చెప్పి యొక్క
ఒక చెట్టు ఒక పాయింటర్ అలాగే తదుపరి అనే కథాంశం ఒక పాయింటర్ కలిగి ఉంది.
ఏ నిర్మాణం ఎలా ఈ రకమైన చేస్తుంది?
ఇది రకమైన అక్కడ దాని పై అన్నారు.
ఇక్కడే మీద.
అనుబంధ జాబితా.
మేము ఒక ప్లాట్లు ఉన్నప్పుడు అది ప్లాట్లు యొక్క అనుబంధ జాబితా వంటిది చూస్తారు.
అడవి, ప్లాట్లు యొక్క అనుబంధ జాబితా నిర్వచిస్తారు
అందువలన అడవుల నిర్మాణం మేము మా మొదటి ప్లాట్లు ఒక పాయింటర్ చూడాలని ఉంది
మరియు ఆ ప్లాట్లు అది ఒక చెట్టు ఉంది లేదా బదులుగా ఒక చెట్టు పాయింతు
మరియు ఆ విధంగా మరియు మొదలైనవి, తదుపరి ప్లాట్లు సూచిస్తుంది.
ఒక అడవి చేయడానికి మేము mkforest కాల్.
అప్పుడు మేము ఇక్కడ కొన్ని ఉపయోగకరమైన అందంగా పనులను కలిగి ఉన్నాయి.
మీరు తిరిగి విలువ ఒక చెట్టు * ఆ తరువాత ఒక అడవిలో పాస్ మరియు మేము, పిక్ కలిగి
ఒక చెట్టు ఒక పాయింటర్.
ఏ పిక్ చేస్తుంది మీరు సూచించే చేస్తున్న అది అడవి లోకి వెళ్ళి ఉంటుంది
ఆ అడవి నుండి అత్యల్ప పౌనఃపున్యం ఒక చెట్టు తొలగించు
మరియు ఆ చెట్టు మీరు పాయింటర్ ఇస్తాయి.
మీరు ఎంపిక కాల్ ఒకసారి, చెట్టు, ఇకపై అడవిలో ఉనికిలో ఉంటుంది
కానీ తిరిగి విలువ ఆ చెట్టు పాయింటర్ ఉంది.
అప్పుడు మీరు PLANT ఉన్నాయి.
మీరు ఒక కాని 0 ఫ్రీక్వెన్సీ కలిగి చెట్టు ఒక పాయింటర్ లో పాస్ అందించిన
ఏ మొక్క చేస్తుంది ఇది అటవీ తీసుకుని చెట్టు తీసుకుని, మొక్క ఉంటుంది అని అడవి చెట్టు లోపల.
ఇక్కడ మేము rmforest ఉన్నాయి.
ప్రధానంగా మాకు మా చెట్లు అన్ని స్వేచ్ఛ చెట్టు, తొలగించడానికి ఇటువంటి
అటవీ తొలగించడానికి ఆ అడవి లో ఉన్న ఉచిత ప్రతిదీ రెడీ.
>> మేము forest.c పరిశీలిస్తాము ఉంటే, మేము, అక్కడ కనీసం 1 rmtree ఆదేశం చూడాలనుకుంటున్నారా చేస్తాము
ఎందుకంటే ఒక అడవి లో చెట్లు ఉంటే అడవిలో ఉచిత స్మృతికి,
అప్పుడు చివరికి మీరు చాలా ఆ చెట్లు తొలగించాలని చూడాలని.
మేము forest.c పరిశీలిస్తాము ఉంటే, మేము ఆశించిన విధంగా ఇది మా mkforest కలిగి.
మేము malloc విషయాలు.
అది లేదు ఖాళీ ఎందుకంటే మేము, NULL వంటి అడవిలో మొదటి ప్లాట్లు ప్రారంభించడం
అప్పుడు మేము తక్కువ బరువు కలిగిన చెట్లు చూపించే పిక్, అత్యల్ప పౌనఃపున్యం, చూడండి
మరియు ఆ ప్రత్యేక నోడ్ విమోచనం అందుతుంది అని ఆ చెట్టు పాయింట్లు మరియు తదుపరి,
కాబట్టి ఇది అడవి లింక్ జాబితా యొక్క తీస్తాడు.
మరియు ఇక్కడ మేము ఇది లింక్ జాబితాలో ఇన్సర్ట్ ఒక చెట్టు మొక్క, ఉన్నాయి.
ఏ అటవీ ఇది చక్కగా మా క్రమబద్ధీకరించబడతాయి చేస్తుంది లేదు.
మరియు తర్వాత, చివరిగా మనకు అంచనా, మేము పని rmtree కలిగి, rmforest కలిగి మరియు.
>> ఇప్పటివరకు పంపిణీ కోడ్ వద్ద గురించి, huffile.c, అర్థం దూరంగా కష్టతరమైన ద్వారా బహుశా
ఇతర ఫైళ్లు అయితే తాము అనుసరించడానికి చాలా సులభమైన ఉన్నారు.
గమనికలు మరియు అనుసంధాన జాబితాలు మరియు మా జ్ఞానం తో,
మేము ప్రెట్టీ బాగా అనుసరించండి సాధించారు.
కానీ మేము పూర్తిగా అర్థం నిర్ధారించుకోండి ఏమిటంటే. H దస్త్రాలు
మీరు, ఆ తిరిగి విలువలు వ్యవహరించే, ఆ విధులు కాల్ అవసరం ఎందుకంటే
కాబట్టి మీరు పూర్తిగా నిర్వహించబడుతుంది అన్నారు ఎలాంటి అర్థం నిర్ధారించుకోండి
ఆ కార్యక్రమాల్లో ఒకటి కాల్ చేసినప్పుడు.
కానీ నిజానికి అది లోపలి understanding మేము ఆ ఎందుకంటే చాలా అవసరం లేదు. H ఫైళ్లు.
మేము మా పంపిణీ కోడ్ మిగిలి 2 మరిన్ని ఫైళ్ళను ఉన్నాయి.
>> యొక్క డంప్ చూద్దాం.
ఇక్కడ దాని వ్యాఖ్య ద్వారా డంప్ ఒక హఫ్ఫ్మన్ కుదింపు ఫైలు పడుతుంది
మరియు తర్వాత మాట మరియు డంపుల కంటెంట్ యొక్క అల్ అవ్ట్.
ఇక్కడ మేము అది hfopen కాల్ చేసే చూడండి.
ఇది * ఇన్పుట్ = fopen ఫైల్ ప్రతిబింబించే రకం
మరియు మీరు సమాచారాన్ని పాస్.
ఇది బదులుగా మీరు ఒక Huffile అక్కడ మీరు ఒక ఫైల్ * యొక్క తప్ప దాదాపు ఒకేలా ఉంటుంది;
బదులుగా fopen యొక్క మీరు hfopen అక్కడ చేస్తున్నారు.
ఇక్కడ మేము రకమైన మేము శీర్షికలో చదివి ఎలా పోలి ఉంది, మొదటి శీర్షికలో చదవండి
ఒక Bitmap ఫైల్ కోసం.
మనం ఇక్కడ చేస్తున్నా చూడటానికి తనిఖీ అని శీర్షిక సమాచారం
అది అసలైన హఫ్ ఫైల్ సూచిస్తుంది కుడివైపు మ్యాజిక్ సంఖ్యను కలిగి,
అప్పుడు నిర్ధారించడానికి ఈ తనిఖీలు అన్ని మేము ఓపెన్ అసలు huffed ఫైలు లేదా ఫైల్ ఆ.
ఈ చేస్తుంది అది మేము చూసే గుర్తులు అన్ని పౌనఃపున్యాల అందిస్తుంది ఉంది
గ్రాఫికల్ పట్టిక ఒక టెర్మినల్ లోపల.
ఈ భాగం ఉపయోగకరంగా అన్నారు.
ఇది ఒక బిట్ ఉంది మరియు వేరియబుల్ బిట్ లోకి బిట్ బిట్ చదివి మరియు తరువాత దాన్ని ముద్రిస్తుంది.
నేను ఒక ఫైల్ huffing యొక్క ఫలితంగా hth.bin, న డంప్ కాల్ అలా అయితే
సిబ్బంది విధానాన్ని ఉపయోగించి, నేను ఈ పొందుతారు.
ఈ అక్షరాలు అన్ని ఔట్పుట్ మరియు అప్పుడు వారు కనిపించే వద్ద పౌనఃపున్యం ఉంచడం మాత్రమే.
మేము చూస్తే, వాటిలో చాలా ఈ తప్ప 0 సె ఉన్నాయి: రెండుసార్లు కనిపించే H,
తరువాత ఒకసారి కనిపించే T,.
మరియు ఇక్కడ మేము 0 సె మరియు 1s వాస్తవ సందేశం ఉంది.
మేము hth.txt విషయంలో చూస్తే, ఇది బహుశా huffed అసలు సందేశం
మేము అక్కడ కొన్ని Hs మరియు Ts చూడాలనుకుంటున్నారా.
ముఖ్యంగా, మేము కేవలం 1 T మరియు 2 Hs చూడాలనుకుంటున్నారా.
ఇక్కడ మేము hth.txt ఉన్నాయి. ఇది నిజంగానే HTH ఉంది.
మేము అది కనిపించడం లేదు, అయితే అక్కడ కూడా ఉంది, ఒక NEWLINE పాత్ర.
హఫ్ ఫైలు hth.bin కూడా NEWLINE క్యారెక్టర్ ఎన్కోడింగ్ ఉంది.
ఇక్కడ మేము, ఆర్డర్ NEWLINE అప్పుడు HTH మరియు అని తెలుసు ఎందుకంటే
మేము కేవలం ఒకే 1 బహుశా H ప్రాతినిధ్యం అని చూడగలరు
మరియు తర్వాత T బహుశా 01 మరియు తరువాత H 1 పాటు
మరియు తర్వాత మేము రెండు 0 సె ద్వారా సూచించిన ఒక NEWLINE ఉన్నాయి.
కూల్.
>> మరియు తర్వాత, చివరిగా మనకు అనేక. సి వ్యవహరించే మరియు. ఉన్నందున h ఫైళ్లు,
మేము, కంపైలర్ ఒక అందమైన క్లిష్టమైన వాదన చూడాలని
మరియు ఇక్కడ మేము మీ కోసం డంప్ చేస్తుంది ఒక Makefile ఉన్నాయి.
కానీ నిజానికి, మీరు మీ స్వంత puff.c ఫైలు తయారు చెయ్యటానికి ఉన్నాయి.
Makefile అయితే మీరు puff.c తయారు వ్యవహరించే లేదు.
మేము Makefile సవరించడానికి మీరు ఆ అప్ వదిలేస్తున్నారు.
మీరు అని వంటి ఆదేశాన్ని నమోదు చేసినప్పుడు, ఉదాహరణకు, మీరు వాటిని అన్ని చేస్తుంది.
గత pset నుండి Makefile ఉదాహరణలు చూడండి సంకోచించకండి
అలాగే మీరు మీ వాచిన ఫైలు చేయగలరు ఎలా చూడటానికి ఈ ఒక యొక్క షో
ఈ Makefile సవరించడం ద్వారా.
మా పంపిణీ కోడ్ అది గురించి.
>> మేము ఆ ద్వారా సంపాదించిన తర్వాత, ఇక్కడ మరొక రిమైండర్ ఉంది
ఎలా మేము హఫ్ఫ్మన్ నోడ్స్ వ్యవహరించే కావడం చేస్తున్నారు.
మేము వాటిని ఇకపై నోడ్స్ కాల్ కావడం లేదు; మేము వాటిని చెట్లు పిలుచుచున్నారు చూడాలని
మేము ఒక చార్ వారి చిహ్నం ప్రాతినిధ్యం చేయడానికి వెళుతున్న,
వాటి తరచుదనం, పూర్ణాంకం తో ఏర్పడడం సంఖ్య.
అది ఒక ఫ్లోట్ కంటే మరింత ఖచ్చితమైన ఎందుకంటే మేము ఆ ఉపయోగిస్తున్నారు.
మరియు తర్వాత మేము ఎడమ చైల్డ్ అలాగే కుడి బాల మరో పాయింటర్ ఉంది.
అడవి, మేము చూసిన వంటి, కేవలం చెట్ల అనుబంధ జాబితా ఉంది.
చివరకు, మేము మా హఫ్ ఫైలు రూపొందించడంలో చేసినప్పుడు,
మేము మా అడవి కేవలం 1 చెట్టు కలిగి అనుకుంటున్నారా -
1 చెట్టు, బహుళ పిల్లలతో 1 root.
గతంలో మేము మా హఫ్ఫ్మన్ చెట్లు తయారు చేసినప్పుడు న,
మేము మా స్క్రీన్ మీద నోడ్స్ అన్ని పెట్టడము ద్వారా ప్రారంభించారు
మరియు, మేము ఈ నోడ్స్ చూడాలని చెప్పడం
చివరికి వారు ఆకులు మాత్రం చేస్తున్నాము, ఈ వారి చిహ్నం, ఈ వారి ఫ్రీక్వెన్సీ.
మేము కేవలం 3 అక్షరాలు ఉంటే మా అడవి లో, ఆ 3 చెట్ల ఫారెస్ట్ యొక్క.
మరియు తర్వాత మేము, మేము మొదటి మాతృ రావడంతో, పయనించే వంటి
మేము 2 చెట్ల అడవి చేసింది.
మేము మా అడవి నుండి ఆ పిల్లల 2 తొలగించబడింది మరియు తరువాత మాతృ నోడ్ దాని స్థానంలో
పిల్లలు ఆ 2 నోడ్స్ వచ్చింది.
మరియు తర్వాత చివరకు, మా గత నాటికి, Bs మా ఉదాహరణ తయారు దశ, మరియు CS
చివరి మాతృ చేయడానికి ఉంటుంది,
మరియు అందువలన 1 అడవిలో వృక్షముల మా మొత్తం సభ్యత్వం తీసుకొచ్చే.
ప్రతి ఒక్కరూ మీరు మీ అడవిలో బహుళ చెట్లతో ప్రారంభమై ఎలా చూడండి లేదు
మరియు 1 తో ముగుస్తుంది? సరే. కూల్.
>> మనం వాచిన కోసం ఏమి చేయాలి?
మనం ఏమి చేయాలి వంటి ఎల్లప్పుడూ వారు మాకు ఇన్పుట్ కుడి రకం ఇవ్వాలని, నిర్ధారించడానికి ఉంది
మేము నిజంగా కార్యక్రమం అమలు చేయవచ్చు.
ఈ సందర్భంలో వారు తమ మొదటి ఆదేశ పంక్తి వాదన తర్వాత మాకు ఇస్తున్నట్టు చూడాలని
2 మరింత: మేము విస్తరించేందుకు మరియు విస్తరించినప్పుడు ఫైలు యొక్క అవుట్పుట్ చేయదలిచిన ఫైలు.
కానీ ఒకసారి మేము, వారు విలువలు కుడి మొత్తం మాకు పాస్ నిర్ధారించుకోండి
మేము ఇన్పుట్ హఫ్ ఫైలు లేదా ఆ హామీ ఇస్తున్నాము.
మరియు తర్వాత ఒకసారి మేము, అప్పుడు మేము మా చెట్టు నిర్మించడానికి కావలసిన, అది ఒక హఫ్ ఫైల్ హామీ
అది సందేశాన్ని పంపిన వ్యక్తి నిర్మాణంలో చెట్టు సరిపోయే అటువంటి చెట్టు నిర్మించే.
మేము చెట్టు నిర్మించడానికి తరువాత, అప్పుడు మేము తో 0 సె మరియు వారు జారీ చేసే 1s, లావాదేవీ చేస్తాయి
ఇది ఏకరూప ఎందుకంటే, మా చెట్టు పాటు ఆ అనుసరించండి
తరువాత, ఆ సందేశాన్ని వ్రాయండి అక్షరాలు తిరిగి బిట్స్ అర్థం.
మరియు తర్వాత చివరిలో మేము ఇక్కడ గమనికలు రంజింప చేయడానికి ప్రయత్నిస్తున్నాము
మేము ఏ మెమరీ లీకేజ్ లేని నిర్ధారించుకోవాలి
మరియు మేము ఉచిత ప్రతిదీ.
>> సరైన వాడుక భరోసా ఇప్పుడు మాకు పాత Hat ఉంది.
మేము ఒక ఇన్పుట్ తీసుకుని, ఇది వేగంగా ఊపిరి పీల్చు ఫైల్ యొక్క పేరు అని అన్నారు,
మరియు తర్వాత మేము, ఒక అవుట్పుట్ పేర్కొనండి
కాబట్టి టెక్స్ట్ ఫైల్ అవుతుంది అటుకులతో అవుట్పుట్, ఫైలు యొక్క పేరు.
ఈ ఉపయోగం ఉంది. ఇప్పుడు మేము ఇన్పుట్ huffed లేదా ఆ హామీ ఇస్తున్నాము.
తిరిగి థింకింగ్, మాకు సహాయపడే పంపిణీ కోడ్ లో ఏదైనా ఉంది
ఫైలు huffed లేదా అని చేసుకోవడంతో?
Huffeader గురించి huffile.c సమాచారం ఉంది.
మేము ప్రతి హఫ్ ఫైలు మేజిక్ సంఖ్య తో సంబంధం ఒక Huffeader కలిగి తెలుసు
ప్రతి చిహ్నాన్ని పౌనఃపున్యాల అలాగే వ్యూహం
అలాగే చెక్సమ్ వంటి.
మేము మీకు, కాని మేము కూడా, dump.c ఒక పీక్ పట్టింది
ఇది ఒక హఫ్ ఫైల్లోకి reading జరిగినది.
కాబట్టి ఆ విధంగా చేయడానికి, అది నిజంగా huffed లేదా లేదో తనిఖీ వచ్చింది.
అందువలన మేము మా puff.c. ఒక నిర్మాణం వంటి dump.c ఉపయోగించవచ్చు
తిరిగి pset 4 మేము RGB ట్రిపుల్స్ లో కాపీ ఫైల్ copy.c ఉన్నప్పుడు
మరియు మేము, హూడన్ఇట్ మరియు పునఃపరిమాణం ఆ అర్థం
అదేవిధంగా, మీరు ఏమి కాలేదు కేవలం cp dump.c puff.c వంటి ఆదేశాన్ని ఉంది
మరియు అక్కడ కోడ్ కొన్ని ఉపయోగించండి.
అయితే, ఒక ప్రక్రియ యొక్క సూటిగా మాత్రం కాదు
puff.c మీ dump.c అనువాదం కోసం,
కాని ఇది మొదలు ఎక్కడో మీరు ఇస్తుంది
ఇన్పుట్ వాస్తవానికి huffed లేదా అని నిర్ధారించుకోవడానికి ఎలా
అలాగే కొన్ని ఇతర విషయాలు.
మేము సరైన వాడుక అందేలా మరియు ఇన్పుట్ huffed అని లభించేది.
మేము మా సరైన దోష పరిశీలన చేసారు చేసిన ప్రతిసారి,
కాబట్టి సమస్య ఉంటే, తిరిగి మరియు కొన్ని వైఫల్యం సంభవిస్తుంది ఉంటే ఫంక్షన్ త్యజించడం.
>> ఇప్పుడు మనం చేయాలనుకుంటున్నారా అసలు చెట్టు నిర్మించడానికి ఉంది.
మేము ఫారెస్ట్ లో చూస్తే, 2 ప్రధాన విధులు ఉన్నాయి
మేము తో బాగా తెలిసిన కోరిక చూడాలని ఉద్దేశ్యంతో.
అక్కడ బూలియన్ ఫంక్షన్ మొక్క మా అడవి లోపల కాని 0 ఫ్రీక్వెన్సీ చెట్టు మొక్కలు.
కాబట్టి అక్కడ మీరు ఒక అడవి మరియు ఒక చెట్టు ఒక పాయింటర్ ఒక పాయింటర్ లో పాస్.
త్వరిత ప్రశ్న: మీరు ఒక హఫ్ఫ్మన్ చెట్టు నిర్మించడం చేసినప్పుడు ఎన్ని అడవులు మీరు ఉంటుంది?
మా అడవి కుడి, మా కాన్వాస్ ఉంటుంది?
కాబట్టి మేము మాత్రమే 1 అడవి చూడాలని, కానీ మేము అనేక చెట్లు చూడాలని.
మీరు మొక్కను కాబట్టి ముందు, మీరు బహుశా మీ అటవీ అనుకున్న చూడాలని.
మీరు ఒక అడవి చెయ్యడం గురించి forest.h పరిశీలిస్తాము ఒక ఆదేశం ఆ కోసం ఉంది.
మీరు ఒక చెట్టు నాటడం చేయవచ్చు. మేము అలా ఎలా తెలుసు.
ఆపై మీరు కూడా, అడవి నుండి ఒక చెట్టు ఎంచుకోవచ్చు
అత్యల్ప బరువు ఒక చెట్టు తొలగించడం మరియు మీరు పాయింటర్ ఇవ్వడం.
మేము ఉదాహరణలు మేమే చేస్తున్న సమయంలో తిరిగి థింకింగ్,
మేము దాన్ని గీయడం సమయంలో, మేము కేవలం కేవలం లింకులు జోడించారు.
కానీ ఇక్కడ బదులుగా కేవలం, లింకులు జోడించడం
ఆ ల 2 తొలగించడం మరియు వేరొక ఒక దాన్ని భర్తీ చేస్తున్నాము వంటి ఆలోచించి.
ఎంచుకోవడం మరియు పెంచటం పరంగా ఆ వ్యక్తీకరించడానికి,
మీరు 2 చెట్లు ఎంచుకోవడం మరియు తరువాత మరొక చెట్లు నాటడం చేస్తున్నారు
మీరు పిల్లలు తీసుకోబడింది ఆ 2 చెట్లను కలిగి ఉంది.
హఫ్ఫ్మన్ యొక్క చెట్టు రూపొందించడానికి, మీరు క్రమంలో చిహ్నాలు మరియు పౌనఃపున్యాల్లో చదువుకోవచ్చు
Huffeader మీరు ఆ ఇస్తుంది ఎందుకంటే,
మీరు పౌనఃపున్యాల వ్యూహం ఇస్తుంది.
కాబట్టి మీరు ముందుకు మరియు కేవలం అది 0 తో ఏదైనా విస్మరించు
మేము అది ముగింపులో 256 ఆకులు ఇష్టం లేదు ఎందుకంటే.
మేము పాత్రలు మాత్రమే ఆ ఆకులు సంఖ్య కావలసిన
వాస్తవానికి ఫైలు ఉపయోగిస్తారు.
మీరు, ఆ గుర్తులను చదవండి, మరియు 0 ఫ్రీక్వెన్సీలను కలిగి ఉన్న చిహ్నాలు యొక్క ప్రతి చేయవచ్చు
ఆ చెట్లు ఉంటాయని నేను.
మీరు ఏమి, మీరు ఒక కాని 0 ఫ్రీక్వెన్సీ గుర్తు చదివిన ప్రతి సారి
మీరు అడవిలో ఆ చెట్టు నాటడం చేయవచ్చు.
మీరు అడవిలో చెట్లు నాటడం, మీరు తోబుట్టువుల ఆ చెట్లు చేరడానికి, చేయవచ్చు
కాబట్టి, పెంచటం మరియు మీరు ఎంపిక పేరు ఎంచుకోవడం 2 మరియు ప్లాంట్ 1 కు వెళుతున్నారు
పేరు 1 మీరు PLANT మీరు ఎంచుకున్న ఆ 2 పిల్లల తల్లిదండ్రుల అని.
కాబట్టి అప్పుడు మీ తుది ఫలితంగా మీ అడవిలో ఒక చెట్టు అని అన్నారు.
అది మీరు మీ చెట్టు నిర్మించడానికి ఎలా.
>> ఇక్కడ తప్పు అని అనేక అంశాలు ఉన్నాయి
ఎందుకంటే మేము కొత్త చెట్లు తయారు మరియు వంటి గమనికలు మరియు విషయాలు వ్యవహరించే వ్యవహరించే చేస్తున్నారు.
మేము గమనికలు వ్యవహరించే సమయంలో ముందు,
మేము malloc'd చేసినప్పుడు మేము ఒక నల్ పాయింటర్ విలువ ఇవ్వలేదు అని మీరు అనుకున్నారు.
కాబట్టి ఈ ప్రక్రియ అనేక దశలను వద్ద అనేక సందర్భాల్లో ఉన్నట్లు వెళ్తున్నారు
పేరు మీ ప్రోగ్రామ్ విఫలం కాలేదు.
మీరు ఏమి అనుకుంటున్నారా, ఆ లోపాలను నిర్వహించే నిర్ధారించుకోవాలి ఉంది
మరియు స్పెక్ లో, సరసముగా వాటిని నిర్వహించడానికి చెప్పారు
కాబట్టి కార్యక్రమం నిష్క్రమించాలి కలిగి ఉండటానికి వాటిని చెప్పడం వినియోగదారుకు ఒక సందేశాన్ని ముద్రించండి ఇష్టం
మరియు తర్వాత వెంటనే అది నిష్క్రమించాడు.
ఈ లోపాల నిర్వహణ చేయుటకు మీరు తనిఖీ మీరు గుర్తుంచుకోండి
ఒక వైఫల్యం ఉండవచ్చు ప్రతి ఒక్క సారి.
మీరు ఒక కొత్త పాయింటర్ చేస్తున్న ప్రతి ఒక్క సమయం
మీరు విజయవంతమైన అని నిర్ధారించుకోవాలి.
మేము ఒక కొత్త పాయింటర్ మరియు malloc తయారు నాకు ఉపయోగించారు ఏమి ముందు,
మరియు తర్వాత ఆ పాయింటర్ NULL అనే తనిఖీ చేస్తాడు.
కాబట్టి, మీరు అలా కేవలం ఇక్కడ కొన్ని సందర్భాల్లో ఉన్నట్లు వెళ్తున్నారు
కానీ కొన్నిసార్లు మీరు నిజంగా ఒక చర్యను కాల్ చేస్తున్నారు
మరియు ఆ ఫంక్షన్ లో, ఆ mallocing ఏమి ఒకరి.
ఆ సందర్భంలో, మనం కోడ్ లోపల విధులు కొన్ని తిరిగి చూస్తే,
వాటిలో కొన్ని బూలియన్ క్రియలు.
వియుక్త సందర్భంలో మేము foo అనే బూలియన్ ఫంక్షన్ ఉంటే,
ప్రధానంగా, మేము, foo చేస్తుంది ఏమి పాటు ఆ పొందవచ్చు
అది బూలియన్ ఫంక్షన్ నుంచి, అది ఒప్పు లేదా తప్పు తిరిగి -
ఒకవేళ నిజమైన విజయవంతమైన, తప్పుడు కాకపోయినా.
కాబట్టి మేము foo తిరిగి విలువ ఒప్పు లేదా తప్పు అనే తనిఖీ మీరు.
అది తప్పు అయితే, ఆ మేము సందేశాన్ని రకమైన ప్రింట్ మీరు చూడాలని అంటే
ఆపై ప్రోగ్రామ్ నిష్క్రమించాడు.
మనం చేయాలనుకుంటున్నారా foo తిరిగి విలువ తనిఖీ ఉంది.
Foo తప్పుడు తిరిగి, అప్పుడు మేము లోపం రకమైన ఎదుర్కొంది తెలుసు
మరియు మేము మా కార్యక్రమం మీరు నిష్క్రమించాలి.
ఈ ఏదో ఒక దారి వాస్తవ ఫంక్షన్ కూడా మీ పరిస్థితిని ఉన్న ఈ పరిస్థితిని ఉంది.
Foo x లో పడుతుంది సే.
మేము ఒక షరతు కలిగి (foo (x)).
Foo అమలు చివరిలో అది నిజమైన తిరిగి ఉంటే ప్రాథమికంగా, ఆ, అర్థం
ఫంక్షన్ foo విశ్లేషించడానికి ఎందుకంటే అప్పుడు మేము చేయవచ్చు
మొత్తం పరిస్థితి మదింపు చేయడానికి.
కాబట్టి ఆ ఫంక్షన్ నిజమైన తిరిగి మరియు విజయవంతమైన ఉంటే మీరు ఏదో ఒకటి చెయ్యాలి ఎలా.
కానీ మీరు దోష పరిశీలన ఉన్నప్పుడు, మీరు మీ ఫంక్షన్ తప్పుడు తిరిగి ఉంటే నిష్క్రమించాలి అనుకుంటున్నారా.
మీరు ఏమి కాలేదు కేవలం జోడించండి ఒక == తప్పుడు లేదా అది ముందు బ్యాంగ్ జోడించండి
మరియు తర్వాత మీరు (! foo) ఉంటే ఉన్నాయి.
ఆ పరిస్థితి అని లోపల మీరు, లోపాల నిర్వహణ అన్ని ఉంటుంది
కాబట్టి "ఈ చెట్టు సృష్టించడం సాధ్యం కాలేదు" వంటి ఆపై 1 లేదా అలాంటిదే తిరిగి.
ఆ ఏమి, అయితే, foo తప్పుడు తిరిగి అయినప్పటికీ ఆ -
Foo నిజమైన తిరిగి సే.
అప్పుడు మీరు మళ్ళీ foo కాల్ లేదు. ఒక సాధారణ దురభిప్రాయం ఉంది.
మీ పరిస్థితి ఉంది కాబట్టి, దానిని ఇప్పటికే మూల్యాంకనం యొక్క,
మీరు చెట్టు లేదా అలాంటిదే తయారు ఉపయోగించే కనుక మీరు ఇప్పటికే ఫలితంగా
లేదా మొక్క లేదా పిక్ లేదా ఏదో.
ఇది ఇప్పటికే ఆ విలువను కలిగి ఉంది. ఇది ఇప్పటికే అమలు చేసిన.
కనుక ఇది పరిస్థితి బోలియన్ ఫంక్షన్లు ఉపయోగపడుతుంది యొక్క
ఎందుకంటే లేదా మీరు నిజంగా లూప్ యొక్క శరీరం అమలు కావడం,
అది ఏమైనప్పటికీ ఫంక్షన్ అమలు.
>> చివరి దశలో మా రెండవ ఫైల్ సందేశాన్ని రాస్తుంటే.
ఒకసారి మేము హఫ్ఫ్మన్ చెట్టు నిర్మించడానికి, అప్పుడు ఫైలు సందేశాన్ని వ్రాయడం చాలా సూటిగా ఉంటుంది.
ఇది కేవలం 0 సె మరియు 1s అనుసరించండి ఇప్పుడు చాలా సూటిగా ఉంది.
కాబట్టి సమావేశం ద్వారా మేము ఒక హఫ్ఫ్మన్ చెట్టు లో 0 సె వదిలి సూచించే తెలిసిన
మరియు 1s కుడి సూచిస్తున్నాయి.
మీరు ఒక 0 పొందుతారు మీరు బిట్ ద్వారా బిట్ లో చదవండి కాబట్టి అప్పుడు ఉంటే, ప్రతి సమయం
మీరు ఒక 1 చదివిన ప్రతిసారీ తర్వాత ఎడమ శాఖ అనుసరించండి మరియు మీరు
మీరు కుడి శాఖ అనుసరించండి చూడాలని.
మీరు ఒక ఆకు హిట్ వరకు, ఆపై మీరు కొనసాగించడానికి వెళుతున్న
ఆకులు శాఖలు చివరిలో మాత్రం ఎందుకంటే.
మేము ఒక ఆకు లేదా హిట్ లేదో మేము ఎలా చెప్పగలవు?
మేము ముందు చెప్పారు.
[విద్యార్థి] గమనికలు NULL ఉంటే. >> అవును.
ఎడమ మరియు కుడి రెండు చెట్లను గమనికలు NULL ఉంటే మేము ఒక ఆకు హిట్ ఉంటే మేము తెలియజేయవచ్చు.
పర్ఫెక్ట్.
మేము మా హఫ్ ఫైల్లోకి బిట్ బిట్ లో చదవడానికి కావలసిన తెలుసు.
మేము dump.c లో ముందు చూసిన, వారు ఏమి వారు హఫ్ ఫైల్లోకి బిట్ బిట్ చదవబడుతుంది
మరియు కేవలం ఆ బిట్స్ ఏం చేస్తున్నారో ముద్రించిన.
మేము చేసే విధంగా కావడం లేదు. మేము మరింత క్లిష్టతరంగా అని ఏదో ఒక పని చేస్తూ చూడాలని.
కాని మేము మేము bit కు చదివే కోడ్ సూచించే బిట్ పడుతుంది ఉంది.
ఇక్కడ మేము ఆన్ అని ప్రస్తుత బిట్ ప్రాతినిధ్యం పూర్ణాంక బిట్ కలిగి ఉంటాయి.
మీరు ఫైల్ యొక్క ముగింపు హిట్ వరకు ఈ ఫైలులో బిట్స్ అన్ని iterating జాగ్రత్త తీసుకుంటుంది.
ఆ ఆధారంగా, అప్పుడు మీరు ఇటెరేటర్ రకమైన కావాలి చూడాలని
మీ చెట్టు దాటటానికి.
ఆపై, బిట్ 0 లేదా 1 అనే ఆధారంగా
మీరు ఎడమ ఆ ఇటెరేటర్ తరలించడానికి లేదా కుడి అది తరలించాలనుకుంటున్న చూడాలని
అన్ని మార్గం మీరు ఒక ఆకు హిట్ వరకు, అన్ని మార్గం మీరు ఆ నోడ్ వరకు
ఏ నోడ్స్ సూచించడానికి లేదు.
ఎందుకు మేము ఒక హఫ్ఫ్మన్ ఫైలు కానీ మోర్స్ కోడ్ తో చేయవచ్చు?
మోర్స్ కోడ్ లో సందిగ్దత ఒక బిట్ ఉంది ఎందుకంటే.
మేము వేచి OH వంటి ఉండవచ్చు, మేము మార్గం పాటు ఒక లేఖ హిట్ చేసిన, కాబట్టి బహుశా ఈ, మా అక్షరం
మేము ఒక బిట్ ఇక కొనసాగింది, అప్పుడు మేము మరొక అక్షరం తగిలేలా అయితే.
కానీ, హఫ్ఫ్మన్ ఎన్కోడింగ్ జరిగే కాదు
కనుక మేము వెళుతున్న ఏకైక మార్గం ఒక పాత్ర నొక్కండి గుర్తుంచుకోండి విశ్రాంతి తీసుకోవడానికి
ఆ నోడ్ యొక్క ఎడమ మరియు కుడి పిల్లలు NULL ఉంటే ఉంది.
>> చివరగా, మేము మా మెమరీ అన్ని ఉచిత మీరు.
మేము వ్యవహరించే చేసిన రెండు దగ్గరగా హఫ్ ఫైలు మీరు
అలాగే మా అడవిలో వృక్షముల అన్నీ తొలగించు.
మీ అమలు ఆధారంగా, మీరు బహుశా అటవీ తొలగించు కాల్ మీరు చూడాలని
బదులుగా వాస్తవానికి చెట్లు మీ అన్ని ద్వారా జరుగుతుంది.
మీరు ఏ తాత్కాలిక చెట్లు చేసిన అయితే, మీరు స్వేచ్ఛను చెయ్యవచ్చును.
మీరు మీ కోడ్ తెలుసుకోవటానికి, కాబట్టి మీరు మెమరీ పెడుతోంది చేస్తున్నారు ఇక్కడ మీరు తెలుసు.
మరియు మీరు వెళ్లి అలా అయితే, malloc కోసం F'ing కూడా కంట్రోల్ ప్రారంభించండి
చూసిన ప్రతిసారి మీరు malloc మరియు మీరు ఆ యొక్క ఉచిత నిర్ధారించాడు
కానీ అప్పుడు, మీ కోడ్ ద్వారా వెళ్లి
మీరు మెమరీ కేటాయించింది ఉండవచ్చు పేరు అవగాహన.
సాధారణంగా మీరు ", ఒక ఫైల్ చివరలో నేను నా అడవి మీద అటవీ తొలగించు వెళుతున్న" అని అనవచ్చు
కాబట్టి ప్రాథమికంగా ఉచిత, ఆ స్మృతి స్పష్టం,
"ఆ తరువాత కూడా ఫైల్ మూసి మరియు నా ప్రోగ్రామ్ విడిచి అన్నారు వెళుతున్న."
కానీ మీ ప్రోగ్రామ్ వదిలేసి ఆ సమయం మాత్రమే ఉంది?
కాదు, ఎందుకంటే కొన్నిసార్లు జరిగిన లోపం ఉండవచ్చు.
బహుశా మేము ఒక ఫైల్ను తెరవడం సాధ్యం కాలేదు లేదా మేము మరొక చెట్టు చేయలేకపోయాము
లేదా లోపం రకమైన మెమరీ కేటాయింపు ప్రక్రియ జరిగిన మరియు కనుక ఇది NULL తిరిగి.
ఒక లోపం ఏర్పడింది ఆపై మేము తిరిగి నిష్క్రమించాడు.
కాబట్టి మీరు, మీ ప్రోగ్రామ్ ఏదైనా సాధ్యం సమయం విడిచి దాన్ని ఆ నిర్ధారించుకోవాలి
మీరు అక్కడ మీ మెమరీ అన్ని ఉచిత మీరు.
ఇది మీరు మీ కోడ్ విడిచి ప్రధాన విధి యొక్క చివరిలో మాత్రం కాదు.
మీరు మీ కోడ్ సమర్థవంతంగా ముందుగానే తిరిగి చేసే ప్రతి ఉదాహరణకు తిరిగి చూడవచ్చు
మరియు తర్వాత ఫ్రీ ఏ మెమరీ అర్థవంతంగా ఉంటుంది.
మీరు అటవీ తయారు మరియు ఆ తప్పుడు తిరిగి అని చెప్పారు.
అప్పుడు మీరు బహుశా మీ అటవీ తొలగించడానికి అవసరం లేదు
మీరు ఇంకా ఒక అడవి లేదు ఎందుకంటే.
కానీ కోడ్ ప్రతి పాయింట్ వద్ద మీరు ముందుగానే తిరిగి ఎక్కడ
మీరు ఏ అవకాశం మెమరీ విడిపించేందుకు ఆ నిర్ధారించుకోవాలి.
>> కాబట్టి మేము మెమరీ ఉండండి వ్యవహరించే మరియు సమర్థమైన దోషాలను సమస్య ఉన్నప్పుడు,
మేము మా తీర్పు మరియు మా తర్కం ఉపయోగించడానికి మాత్రమే మీరు
కానీ మేము సరిగా లేదా మా మెమరీ అన్ని విముక్తి లేదో గుర్తించడానికి Valgrind ఉపయోగించండి.
మీరు వాచిన న Valgrind అమలు చెయ్యవచ్చు మరియు మీరు కూడా ఉత్తీర్ణత సాధించవలసి ఉంటుంది
ఆదేశ పంక్తి వాదనలు కుడి సంఖ్య Valgrind కు.
ఆ నిర్వహించినప్పటికీ, అవుట్పుట్ ఒక బిట్ గుప్తమైన ఉంది.
, మేము స్పెల్లర్ దీనిని ఉపయోగిస్తారు బిట్ సంపాదించిన తర్వాత, కానీ మేము ఇంకా ఒక బిట్ మరింత సహాయం కావాలా
కాబట్టి అప్పుడు, లీక్ తనిఖీ = పూర్తి వంటి కొన్ని జెండాలతో అది అమలు
ఆ బహుశా మా Valgrind కొన్ని మరింత ఉపయోగకరంగా అవుట్పుట్ ఇస్తుంది.
>> అప్పుడు మీరు డీబగ్గింగ్ చేసేటప్పుడు మరొక ఉపయోగకరమైన చిట్కా తేడాలు ఆదేశం ఉంది.
మీరు, హఫ్ యొక్క సిబ్బంది యొక్క అమలు యాక్సెస్ అమలు ఒక టెక్స్ట్ ఫైల్ లో, చేయవచ్చు
మరియు తర్వాత ముఖ్యంగా, ఒక బైనరీ ఫైలు, ఒక బైనరీ హఫ్ ఫైలు దానిని అవుట్పుట్.
అప్పుడు మీరు ఆ బైనరీ ఫైలు మీ స్వంత పఫ్ అమలు, ఉంటే
అప్పుడు ఆదర్శంగా మీ outputted టెక్స్ట్ ఫైల్ సారూప్యంగా ఉండాలని అన్నారు
మీరు ఆమోదించారు అసలు ఒక
ఇక్కడ నేను ఉదాహరణగా hth.txt ఉపయోగించి నేను, మరియు మీ వివరాలను లో మాట్లాడారు ఒకటి.
ఆ మాటప్రకారము HTH మరియు తరువాత NEWLINE ఉంది.
కానీ ఖచ్చితంగా సంకోచించకండి మరియు మీరు ఖచ్చితంగా ఇక ఉదాహరణలు ఉపయోగించడానికి ప్రోత్సహించే
మీ టెక్స్ట్ ఫైల్ కోసం.
>> మీరు కూడా decompressing అప్పుడు బహుశా ఒత్తిడి వద్ద ఒక షాట్ తీసుకుంటుంది మరియు చేయవచ్చు
యుద్ధం మరియు శాంతి వంటి మీరు స్పెల్లర్ లో ఉపయోగించిన కొన్ని ఫైళ్ళను
లేదా జేన్ ఆస్టన్ లేదా అలాంటిదే - చల్లని రకం అని - లేదా ఆస్టిన్ పవర్స్,
మేము దానికి పెద్ద ఫైళ్ళను వ్యవహరించే రకం వచ్చి, ఎందుకంటే
మేము ఇక్కడ తదుపరి సాధనం, ls-l ఉపయోగిస్తే.
మేము ప్రధానంగా మా ప్రస్తుత డైరెక్టరీ అన్ని విషయాలను జాబితా ఇది ls, చేస్తున్నట్లుగానే.
జెండా-l అక్కడ నిజంగా ఆ ఫైళ్ళను యొక్క పరిమాణం ప్రదర్శిస్తుంది.
మీరు pset స్పెక్ ద్వారా వెళ్ళి ఉంటే, నిజానికి, బైనరీ ఫైలు సృష్టించడం ద్వారా మీరు నడుస్తున్న
ఇది huffing, మరియు మీరు చాలా చిన్న ఫైళ్ల కోసం ఆ చూడండి
ఇది ఒత్తిడి మరియు ఆ సమాచారాన్ని అనువదించే స్పేస్ ఖర్చు
ఆ వంటి అన్ని పౌనఃపున్యాల మరియు విషయాలను అసలు ప్రయోజనం కంటే
మొదటి స్థానంలో ఫైలు సంపీడనం.
మీరు కొన్ని పొడవైన టెక్స్ట్ ఫైళ్లు న అమలు అయితే, మీరు కొన్ని ప్రయోజనం పొందడానికి ప్రారంభించండి చూడవచ్చు
ఆ ఫైళ్ళను కుదించేందుకు లో.
>> మరియు తర్వాత, చివరిగా మనకు ఖచ్చితంగా చాలా ఉపయోగపడుట అన్నారు ఇది మా పాత పాల్ GDB కలిగి.
>> మేము చెట్లు తీసే బహుశా హఫ్ చెట్లు లేదా ప్రక్రియ ఏ ప్రశ్నలు ఉందా
లేదా Huff'n వాచిన ఏ ఇతర ప్రశ్నలు?
సరే. నేను ఒక బిట్ కోసం చుట్టూ ఉండడానికి చేస్తాము.
>> ధన్యవాదాలు, ప్రతి ఒక్కరూ. ఈ Walkthrough 6 ఉంది. మరియు అదృష్టం మంచి.
>> [CS50.TV]