[Powered by Google Translate] [విభాగం 7] [తక్కువ సౌకర్యవంతమైన]
[నేట్ Hardison] [హార్వర్డ్ విశ్వవిద్యాలయం]
[ఈ CS50 ఉంది.] [CS50.TV]
>> విభాగం 7 స్వాగతం.
, హరికేన్ శాండీ ధన్యవాదాలు
బదులుగా ఈ వారం ఒక సాధారణ విభాగం కలిగి,
మేము ప్రశ్నలు యొక్క విభాగం ద్వారా, WALK-ద్వారా ఈ చేయుచున్నారు.
నేను, 6 స్పెసిఫికేషన్ సెట్ సమస్య పాటు క్రింది విధంగా వెళుతున్న
మరియు అన్ని ప్రశ్నలకు ద్వారా వెళ్లి
ప్రశ్నలు విభాగం యొక్క ఒక విభాగం.
ఏ ప్రశ్నలు ఉంటే,
CS50 చర్చించండి ఈ పోస్ట్ చేయండి.
>> సరే. యొక్క ప్రారంభించడానికి లెట్.
ప్రస్తుతం నేను ప్రాబ్లం సెట్ స్పెసిఫికేషన్ యొక్క పేజ్ 3 చూస్తున్నాను.
మేము మొదటి బైనరీ చెట్లు గురించి మాట్లాడటం మొదలు చూడాలని
ఆ ఈ వారం యొక్క సమస్య సెట్ తగ్గట్టుగా చాలా నుండీ -
హఫ్ఫ్మన్ ట్రీ ఎన్కోడింగ్.
మేము CS50 న గురించి మాట్లాడారు మొట్టమొదటి డేటా నిర్మాణాలు శ్రేణి ఉంది.
వ్యూహం మూలకాల శ్రేణిని అని గుర్తుంచుకోండి -
ఒకే రకమైన అన్ని - మెమరీలో కుడి ఒకదాని తరువాత నిల్వ.
నేను ఈ బాక్సులను-సంఖ్యలు-పూర్ణాంకాల శైలి ఉపయోగించి డ్రా చేసే పూర్ణాంకం శ్రేణి ఉంటే -
లెట్ యొక్క నేను మొదటి బాక్స్ లో 5 ఉన్నాయి, అవి, నేను, రెండో 7 కలిగి
అప్పుడు నేను చివరి బాక్స్ లో 8, 10, మరియు 20 ఉన్నాయి.
ఈ శ్రేణి గురించి గుర్తుంచుకోండి, రెండు మంచి విషయాలు
మేము ఏ నిర్దిష్ట అంశానికి ఈ స్థిర కాల ఉపయోగానికి ఉంటాయి
అర్రే మనం దాని సూచిక తెలిస్తే.
ఉదాహరణకు, నేను శ్రేణి మూడవ మూలకం పట్టుకొను అనుకుంటే -
సూచిక వద్ద 2 మా జీరో ఆధారిత ఇండెక్సింగ్ వ్యవస్థ ఉపయోగించి -
నేను మాటప్రకారము ఒక సులభమైన గణిత లెక్కింపు లేదు
, అర్రే ఆ స్థానానికి హాప్
అక్కడ నిల్వ చేయబడిన 8, వెలికితీసి
మరియు నేను అన్నిటికి ఉన్నాను.
>> ఈ శ్రేణి గురించి చెడు విషయాల యొక్క ఒక - మేము గురించి చర్చిస్తామని
మేము లింక్ జాబితాలు చెప్పాలంటే -
నేను ఈ శ్రేణి ఒక మూలకం ఇన్సర్ట్ అనుకుంటే అనగా,
నేను కొన్ని చుట్టూ బదిలీ లేదు వెళుతున్న.
ఇక్కడే ఉదాహరణకు, ఈ శ్రేణి
క్రమబద్ధీకరించబడింది క్రమంలో ఉంటుంది - క్రమంలో క్రమబద్ధీకరించబడింది -
5, అప్పుడు అప్పుడు 7, 8, 10, మరియు అప్పుడు 20 -
కానీ నేను ఈ శ్రేణి లోకి సంఖ్య 9 ఇన్సర్ట్ అనుకుంటే,
నేను ఖాళీ చేయడానికి కొన్ని అంశాలను బదిలీ కలిగి వెళుతున్న.
మేము ఇక్కడ డ్రా చేయవచ్చు.
నేను 5, 7 తరలించడానికి కూడా ఉండదని, ఆపై 8 చేస్తున్నాను;
నేను 9 ఉంచవచ్చు పేరు ఖాళీ సృష్టించడానికి
ఆపై 10 మరియు 20 9 కుడి వెళ్ళవచ్చు.
ఈ ఒక నొప్పి రకం ఎందుకంటే చెత్త-సందర్భంలో -
మేము ప్రారంభంలో లేదా చివరిలో గాని ఇన్సర్ట్ అవసరం అయినప్పుడు
వరుస వలన ఆధారపడి మేము బదిలీ చేస్తున్న -
మేము అన్ని మూలకాల మార్చేందుకు మాత్రమే ముగుస్తుంది ఉండవచ్చు
మేము ప్రస్తుతం శ్రేణి లో నిల్వ చేయవచ్చు.
>> కాబట్టి, ఈ చుట్టూ మార్గం ఏమిటి?
ఈ చుట్టూ విధంగా పేరు మా లింక్ జాబితా పద్ధతి వెళుతుంది -
బదులుగా అంశాలు 5, 7, 8, 10, మరియు మెమొరీ లో ఒకదాని తరువాత 20 అన్ని నిల్వ యొక్క -
మేము బదులుగా మేము వాటిని నిల్వ అనుకున్నారు అక్కడ వాటిని రకమైన నిల్వ చేసినది
ఈ లింక్ జాబితా కణుపుల ఇది నేను, ఇక్కడ తాత్కాలిక రకం అవుట్ గీయడం చేస్తున్నాను.
మరియు తర్వాత మేము ఈ తదుపరి గమనికలు ఉపయోగించి వాటిని కలుపుతారు.
నేను, 5 నుండి 7 ఒక పాయింటర్ కలిగి
7 నుండి 8 వరకు ఒక పాయింటర్,
8 నుంచి 10 వరకూ పాయింటర్,
చివరకు, 10 నుండి 20 వరకు ఒక పాయింటర్,
ఆపై 20 వద్ద ఒక నల్ పాయింటర్ ఎడమ ఏదీ లేదు అని.
మేము ఇక్కడ కలిగి రాజీ
మేము మా క్రమబద్ధీకరించబడతాయి జాబితాలో సంఖ్య 9 ఇన్సర్ట్ అనుకుంటే ఆ, ఇప్పుడు
మేము అన్ని, 9 తో కొత్త నోడ్ సృష్టించడానికి ఉంది
, సరైన స్థలం సూచించడానికి దానిని WIRE
తరువాత తిరిగి WIRE 8 9 క్రిందికి మార్చాలి.
అంటే 9 ఇన్సర్ట్ చోట మేము ఖచ్చితంగా తెలుస్తుంది ఊహించి చాలా వేగమైనది.
కానీ ఈ బదులుగా రాజీ మేము ఇప్పుడు స్థిరంగా సమయం ప్రాప్యతను కోల్పోయి ఉంటుంది
మా డేటా నిర్మాణం ఏ అంశానికి.
ఉదాహరణకు, నేను ఈ లింక్ జాబితాలో నాలుగో మూలకం కావలసిన వారికి,
నేను జాబితా చాలా ప్రారంభంలో ప్రారంభించడానికి కలిగి వెళుతున్న
నేను నాలుగో ఒక కనుగొనడానికి వరకు మరియు నోడ్-by-నోడ్ లెక్కింపు ద్వారా నా మార్గం పని.
>> ఒక లింక్ జాబితా కంటే ఉత్తమ ప్రాప్తిని ప్రదర్శన పొందడానికి -
కానీ మేము కలిగి కొన్ని ప్రయోజనాలు కలిగి
ఒక లింక్ జాబితా నుండి చొప్పించడం సమయం పరంగా -
ఒక బైనరీ చెట్టు కొంచెం మెమరీ ఉపయోగించాలి అన్నారు.
ముఖ్యంగా, బదులుగా కేవలం ఒక బైనరీ చెట్టు నోడ్ లో ఒక పాయింటర్ కలిగి -
అనుసంధాన-జాబితా వంటి నోడ్ చేస్తుంది -
మేము బైనరీ చెట్టు నోడ్ రెండో పాయింటర్ జోడించండి చూడాలని.
కంటే, తర్వాత మూలకం ఒక పాయింటర్ కలిగి
మేము ఒక ఎడమ బాల మరియు కుడి చైల్డ్ ఒక పాయింటర్ చూడాలని.
>> యొక్క వాస్తవానికి కనిపించే చూడటానికి చిత్రాన్ని డ్రా లెట్.
మళ్ళీ, నేను ఈ బాక్సులను మరియు బాణాలు ఉపయోగించండి వెళుతున్న.
ఒక బైనరీ చెట్టు నోడ్ కేవలం బాక్స్ తో కాకుండా ప్రారంభమవుతుంది.
ఇది విలువ కొరకు ఖాళీ వెళుతున్న
మరియు తర్వాత ఇది ఎడమ బాల మరియు కుడి పిల్లలకు ఒక ఖాళీ చెప్పారు.
నేను వాటిని ఇక్కడ లేబుల్ వెళుతున్న.
మేము ఎడమ చైల్డ్ చూడాలని, మరియు అప్పుడు మేము చైల్డ్ చూడాలని.
ఇలా అనేక రకాలుగా ఉంటాయి.
కొన్నిసార్లు స్పేస్ మరియు సౌకర్యం కోసం,
నేను అడుగున ఇక్కడ చేయడం ఉంటాను అని నేను దీన్ని డ్రా చేస్తాము
నేను ఎగువన విలువ వెళుతున్న పేరు,
తరువాత కుడి దిగువ కుడి బాల,
ఎడమ మరియు ఎడమ బాల.
ఈ టాప్ రేఖాచిత్రం కు వెళుతున్నారు,
మేము, అగ్రభాగాన విలువ
అప్పుడు మేము ఎడమ చైల్డ్ పాయింటర్ కలిగి, మరియు అప్పుడు మేము కుడి బాల పాయింటర్ ఉంది.
>> సమస్య సెట్ వివరణలో,
మేము, ఒక విలువ 7 కలిగి నోడ్ గీయడం గురించి మాట్లాడేందుకు
ఆపై శూన్య ఒక ఎడమ చైల్డ్ పాయింటర్, మరియు కుడి బాల పాయింటర్ శూన్య అని.
మేము గాని స్థలాన్ని లో రాజధాని NULL రాయడం
ఎడమ బాల మరియు కుడి బాల, లేదా మేము రెండు ఈ వికర్ణంగా స్లాష్ డ్రా చేయవచ్చు
బాక్సులను ప్రతి ద్వారా శూన్య అని సూచించడానికి.
నేను ఆ సులభమైన యొక్క కనుక అలా వెళుతున్న.
చాలా సులభమైన బైనరీ చెట్టు నోడ్ రేఖాచిత్రం గీయడం రెండు విధాలుగా ఇక్కడ చూడండి
మేము విలువ 7 మరియు శూన్య చైల్డ్ గమనికలు ఉంటుంది.
>> ఎలా లింక్ జాబితాలు తో మా వివరణ చర్చలు రెండవ భాగం -
గుర్తుంచుకోండి, మేము మాత్రమే జాబితాలో మొట్టమొదటి మూలకం పట్టు వచ్చింది
మొత్తం జాబితా గుర్తుంచుకోవడానికి -
మరియు అలాగే, ఒక బైనరీ చెట్టు తో, మేము మాత్రమే చెట్టు ఒక పాయింటర్ ని పట్టి కలిగి
మొత్తం డేటా నిర్మాణం నియంత్రణ కొనసాగించడానికి గాను.
చెట్టు యొక్క ఈ ప్రత్యేక మూలకం చెట్టు యొక్క రూట్ నోడ్ అంటారు.
ఉదాహరణకు, ఈ ఒక నోడ్ - విలువ 7 కలిగిన ఈ నోడ్
- శూన్య ఎడమ మరియు కుడి బాల గమనికలు తో
, మా చెట్టు మాత్రమే విలువ ఉన్నాయి
ఈ మా రూట్ నోడ్ ఉంటుంది.
ఇది మా చెట్టు ప్రారంభం ఉంది.
మేము మా చెట్టు కు ఎక్కువ నోడ్స్ జోడించడం ప్రారంభించిన తర్వాత మేము మరింత స్పష్టంగా ఈ చిన్న చూడగలరు.
నాకు ఒక క్రొత్త పేజీ పుల్ అప్ లెట్.
>> ఇప్పుడు మేము, మూల 7 కలిగి చెట్టు డ్రా చూడాలని
మరియు ఎడమ బాల, మరియు కుడి బిడ్డ 9 లోపల యొక్క 3 లోపల.
మళ్ళీ, ఈ అందంగా సులభం.
మేము 7 పొందారు, 3 కోసం ఒక నోడ్, 9 కోసం ఒక నోడ్, డ్రా
మరియు నేను, 3 కలిగిన నోడ్ సూచించడానికి 7 యొక్క ఎడమ చైల్డ్ పాయింటర్ సెట్ వెళుతున్న
మరియు 9 కలిగి నోడ్కు 7 కలిగిన నోడ్ యొక్క కుడి బాల పాయింటర్.
ఇప్పుడు, 3 నుండి మరియు 9, పిల్లల లేదు
మేము శూన్య వారి పిల్లల గమనికలు అన్ని సెట్ చూడాలని.
ఇక్కడ, మా చెట్టు యొక్క root సంఖ్య 7 కలిగిన నోడ్ సూచించదు.
మనం ఆ రూట్ నోడ్ ఒక పాయింటర్ మీరు, ఆ చూడగలరు
మేము అప్పుడు మా చెట్టు నడవడానికి మరియు పిల్లల నోడ్స్ రెండు యాక్సెస్ చేయవచ్చు -
3 మరియు 9 రెండు.
కాదు చెట్టు మీద ప్రతి నోడ్ కు గమనికలు నిర్వహించవల్సిన అవసరం.
సరే. ఇప్పుడు మేము ఈ చిత్రంలో మరొక నోడ్ జోడించండి చూడాలని.
మేము, 6 కలిగిన నోడ్ జోడించండి చూడాలని
మరియు మేము 3 కలిగిన నోడ్ యొక్క కుడి బాల ఈ జోడించండి చూడాలని.
ఆ చేయుటకు నేను 3-నోడ్ లో ఆ నల్ పాయింటర్ వేయండి వెళుతున్న
మరియు 6 కలిగి నోడ్ సూచించడానికి దానిని వైర్. సరే.
>> ఈ సమయంలో, యొక్క పరిభాష యొక్క కొద్దిగా వెళ్ళి తెలపండి.
, ఈ ముఖ్యంగా ఒక బైనరీ చెట్టు అని పిలుస్తారు కారణం ప్రారంభించడానికి
ఇది రెండు చైల్డ్ గమనికలు కలిగి ఉంది.
మరింత చైల్డ్ గమనికలు కలిగి చెట్లు ఇతర రకాలు ఉన్నాయి.
ముఖ్యంగా, మీరు ఒక సమస్య సెట్ 5 లో 'ప్రయత్నించండి' చేశాడు.
ఆ ప్రయత్నంలోనే ఆ మీరు గమనించవచ్చు, మీరు వివిధ పిల్లలకు 27 వివిధ గమనికలు కలిగి -
ఆంగ్ల అక్షరమాల లో 26 అక్షరాలు ప్రతి ఒకటి,
ఆపై అపాస్టిఫియర్ కోసం 27 -
కాబట్టి, ఆ చెట్టు యొక్క ఒక రకం మాదిరిగా ఉంది.
కానీ ఇక్కడ, అది యొక్క బైనరీ నుండి, మేము కేవలం రెండు చైల్డ్ గమనికలు ఉన్నాయి.
>> మేము గురించి చర్చిస్తామని ఈ రూట్ నోడ్ పాటు,
మేము కూడా ఈ పదం రాలేదని చేసిన 'బాల.'
ఒక నోడ్ మరొక నోడ్ యొక్క పిల్లలు ఇది అర్థం ఏమిటి?
ఇది అక్షరాలా పిల్లల నోడ్ మరొక నోడ్ యొక్క పిల్లల అర్థం
ఇతర నోడ్ ఆ నోడ్ సూచించడానికి సెట్ దాని చైల్డ్ గమనికలు ఒకటి ఉంటే.
ఇది మరింత కాంక్రీటు నిబంధనలు ఉంచారు కు
3 7 యొక్క బాల గమనికలు ఒకటి చూపారు, అప్పుడు 3 7 యొక్క ఒక సంతానం.
- మేము 7 పిల్లలు ఏమిటో దొరుకుతుందని ఉంటే
అలాగే, మేము, 7 3 ఒక పాయింటర్ మరియు 9 ఒక పాయింటర్ కలిగి చూడండి
కాబట్టి 9 మరియు 3 7 పిల్లలు.
తొమ్మిది దాని చైల్డ్ గమనికలు శూన్య ఎందుకంటే పిల్లలు లేరు,
మరియు 3 ఒకే బిడ్డ, 6 కలిగి ఉంది.
దాని గమనికలు రెండు మేము ఇప్పుడు డ్రా మేము శూన్య, ఎందుకంటే ఆరు కూడా పిల్లలు లేరు.
>> అదనంగా, మేము కూడా, ఒక నిర్దిష్ట నోడ్ యొక్క తల్లిదండ్రులు గురించి మాట్లాడేందుకు
మీరు ఆశించిన పెంచండి మరియు ఈ, ఈ పిల్లలు వివరణ వెనుక ఉంది.
బదులుగా రెండు యొక్క మీరు మనుషులు భావిస్తున్న వంటి - ప్రతి నోడ్ మాత్రమే తల్లిదండ్రులలో ఒకరు కలిగి ఉంది.
ఉదాహరణకు, 3 యొక్క మాతృ 7.
9 యొక్క మాతృ కూడా 7, మరియు 6 యొక్క మాతృ 3. ఇది చాలా లేదు.
మేము కూడా, తాతలు మరియు మునుమనవళ్లను మాట్లాడటానికి నియమాలను కలిగి
మరియు సాధారణంగా మేము పూర్వీకులు గురించి మాట్లాడేందుకు
మరియు ఒక నిర్దిష్ట నోడ్ యొక్క వారసులు.
ఒక నోడ్ యొక్క బదులుగా లేదా పూర్వీకులు,, - ఒక నోడ్ యొక్క పూర్వీకుడు -
మూలం నుండి నోడ్ మార్గంలో ఉన్నాయి ఆ నోడ్స్ అన్ని.
ఉదాహరణకు, నేను నోడ్ 6 వద్ద చూస్తున్నాను ఉంటే,
అప్పుడు పూర్వీకులు 3 మరియు 7 రెండూ వెళ్తున్నారు.
9 యొక్క పూర్వీకులు, ఉదాహరణకు ఉన్నాయి - నేను నోడ్ 9 వద్ద చూస్తున్నాను ఉంటే -
అప్పుడు 9 యొక్క పూర్వీకుడు కేవలం 7.
మరియు వారసులు సరిగ్గా రివర్స్ ఉంటాయి.
నేను 7 వారసులు అన్ని చూడండి చేయాలనుకుంటే,
అప్పుడు నేను దాని కింద నోడ్స్ అన్ని కు ఉంది.
కనుక, నేను 7 వారసులు వంటి 3, 9, మరియు 6 అన్ని.
>> మనం మాట్లాడదాము అంతిమ పదం ఒక తోబుట్టువు గా ఈ భావన ఉంది.
తోబుట్టువుల - ఈ కుటుంబం పదాలు వెంట తరువాత రకం -
చెట్టు అదే స్థాయిలో నోడ్స్ ఉంటాయి.
వారు చెట్టు అదే స్థాయిలో కనుక అలా, 3 మరియు 9 తోబుట్టువుల ఉంటాయి.
వారు ఒకే మాతృ, 7 ఉంటాయి.
9 ఏ పిల్లలు లేవు 6 తోబుట్టువుల సంఖ్య ఉంది.
అది మా చెట్టు యొక్క root ఎందుకంటే మరియు 7, ఏ తోబుట్టువుల లేదు
మరియు మాత్రమే ఎప్పుడూ 1 root ఉంది.
7 తోబుట్టువుల కలిగి ఉన్నాయి 7 పై ఒక నోడ్ ఉండాలి.
ఇకపై చెట్టు యొక్క root అవుతుంది కేసు 7 7 యొక్క మాతృ, ఉన్నట్లు ఉంటుంది.
అప్పుడు, 7 యొక్క కొత్త మాతృ కూడా, బిడ్డ వుంటుంది
మరియు ఆ బాలుడికి తరువాత 7 యొక్క తోబుట్టువు ఉంటుంది.
>> సరే. న మూవింగ్.
మేము బైనరీ చెట్ల మా చర్చ ప్రారంభమైనప్పుడు,
మేము వాటిని ఉపయోగించడానికి ఉండేవి ఎలా గురించి మాట్లాడారు
శ్రేణుల మరియు అనుసంధాన జాబితాలు రెండు కంటే అధిక ప్రయోజనం పొందుతారు.
మరియు మేము ఆ చేయబోతున్నామని విధంగా ఈ క్రమాన్ని ఆస్తి తో ఉంది.
మేము, వివరాల ప్రకారం, ఒక బైనరీ చెట్టు ఆదేశించారు చెబుతారు
మా వృక్షంలో ఉండే ప్రతి కణుపు కోసం ఉంటే, ఎడమ దాని వారసులు అన్ని -
ఎడమ బాల మరియు ఎడమ పిల్లల వారసులు అన్ని -
తక్కువ విలువలు, మరియు కుడి నోడ్స్ అన్ని -
కుడివైపు చైల్డ్ మరియు కుడి పిల్లల వారసులు అన్ని -
మేము శోధిస్తున్న ప్రస్తుత నోడ్ యొక్క విలువ కంటే ఎక్కువ నోడ్స్ ఉన్నాయి.
జస్ట్ సరళత కోసం, మేము మా చెట్టు ఏ నకిలీ నోడ్ లేవు అని ఊహించుకోవటం వెళుతున్న.
ఉదాహరణకు, ఈ చెట్టు లో మేము కేసు వ్యవహరించే వెళ్ళి లేదు
మేము root వద్ద విలువ 7 కలిగి పేరు
మరియు తర్వాత మేము కూడా విలువ మరెక్కడా చెట్టు లో 7 ఉంటాయి.
ఈ సందర్భంలో, మీరు ఈ చెట్టు నిజంగానే ఆదేశించారు ఆ మీరు గమనించవచ్చు.
మేము root వద్ద విలువ 7 ఉంటాయి.
7 యొక్క ఎడమ ప్రతిదీ -
నేను ఇక్కడ ఈ చిన్న మార్కులు అన్ని దిద్దుబాటు రద్దుచెయ్యి ఉంటే -
7 యొక్క ఎడమ ప్రతిదీ - 3 మరియు 6 -
ఆ విలువలు రెండూ 7 కంటే తక్కువ, మరియు కుడి ప్రతిదీ - ఈ 9 ఇది -
7 కంటే ఎక్కువగా ఉంటుంది.
>> ఈ ఈ విలువలను కలిగి మాత్రమే ఆదేశించింది చెట్టు కాదు,
కానీ వారి యొక్క కొన్ని డ్రా తెలియజేయండి.
మేము చేయవచ్చు మార్గాలు మొత్తం బంచ్ నిజానికి ఉంది.
నేను ఎక్కడ విషయాలు సాధారణ ఉంచడానికి కుదింపు ఉపయోగించడానికి వెళుతున్న -
బదులుగా బాక్సులను మరియు బాణాలు మొత్తానని గీయడం కంటే -
నేను సంఖ్యలు డ్రా మరియు వాటిని కలిపే బాణాలు జోడించండి వెళుతున్న.
, ఒక 3 అప్పుడు, ప్రారంభించడానికి మేము 7 ఉండటంతో మేము మళ్ళీ మా అసలు చెట్టు వ్రాయండి చేస్తాము, మరియు
మరియు తర్వాత 3, 6 హక్కు తిరిగి చూపారు
మరియు 7 9 అని హక్కు సంతానం.
సరే. మేము ఈ చెట్టు రాస్తుంది మరో మార్గం ఏమిటి?
3 కలిగి, 7 యొక్క ఎడమ బిడ్డ బదులుగా
మేము కూడా 6, 7 యొక్క ఎడమ బిడ్డ కలిగి
మరియు తర్వాత 3 6 యొక్క ఎడమ బిడ్డ.
నేను 7 పొందారు పేర్కొంది ఇక్కడే ఈ చెట్టు వంటి చూస్తారు
అప్పుడు 6, 3, మరియు కుడి ఒక 9.
మేము కూడా మా రూట్ నోడ్ వంటి 7 కలిగి లేదు.
మేము కూడా మా రూట్ నోడ్ 6 చూపుతుంది.
వాట్ లాగా అని?
మేము ఈ ఆదేశించారు ఆస్తి నిర్వహించడానికి వెళ్ళి ఉంటే,
6 యొక్క ఎడమ ప్రతిదీ కంటే తక్కువ ఉండాలి.
అక్కడ ఒకే ఒక అవకాశం, మరియు ఆ 3 యొక్క.
కానీ 6 కుడి చిన్నతనంలో, మేము రెండు అవకాశాలను కలిగి ఉంటాయి.
మొదటి, మేము, 9 అప్పుడు 7 కలిగి మరియు కాలేదు
లేదా మేము వాటిని డ్రా చేయవచ్చు - నేను ఇక్కడ ఏమి ఉంటాను -
మేము 6 కుడి చిన్నతనంలో 9 కలిగి ఉన్న,
మరియు తర్వాత 9 యొక్క ఎడమ చిన్నప్పుడు 7.
>> ఇప్పుడు, 7 మరియు 6 root మాత్రమే సాధ్యమయ్యే విలువలను కాదు.
మేము కూడా 3 root వద్ద ఉన్నాయి.
3 root వద్ద ఉంటే ఏమవుతుంది?
ఇక్కడ, విషయాలు కొంత ఆసక్తికరమైన పొందండి.
మూడు, అది కంటే తక్కువగా ఉంటాయి, అంటే ఏ విలువలు లేదు
కాబట్టి చెట్టు యొక్క మొత్తం ఎడమవైపు నిరర్థక అని అన్నారు.
అక్కడ ఏమీ ఉన్నట్లు మాత్రం కాదు.
కుడికి, మేము క్రమంలో విషయాలు జాబితా కాలేదు.
మేము అప్పుడు 3, అప్పుడు 6, 7, 9 చూపుతుంది.
లేదా, మేము అప్పుడు 7, అప్పుడు, అప్పుడు, 9 6 3 పని చేయడు.
లేదా, మేము అప్పుడు 9, అప్పుడు, అప్పుడు, 6 7 3 పని చేయడు.
లేదా, 3, 7 - నిజానికి, మేము ఇకపై ఒక 7 చెయ్యలేరు.
ఆ అక్కడ మా ఒక విషయం.
మేము 9 చేయవచ్చు, మరియు అప్పుడు 9 నుండి మేము 7 అప్పుడు 6 చేయండి మరియు చేయవచ్చు.
లేదా, మేము అప్పుడు, అప్పుడు, 7 9 3 చేయండి, తరువాత 6 చేయవచ్చు.
>> ఇక్కడ మీ దృష్టిని ఆకర్షించింది ఒక విషయం
ఈ చెట్లు కొద్దిగా అసహజ కనిపించే అని.
ముఖ్యంగా, మేము కుడి వైపున 4 చెట్లు చూడండి -
నేను ఇక్కడ, వాటిని సర్కిల్ ఉంటుంది -
ఈ చెట్లు అనుబంధ జాబితా వంటి దాదాపుగా చూడండి.
ప్రతి కణుపు, ఒకే బిడ్డ ఉంది
అందువలన మేము, ఉదాహరణకు, చూడండి ఈ చెట్టు లాంటి నిర్మాణం ఏ లేదు
దిగువన ఎడమవైపు ఇక్కడ ఈ ఒక ఒంటరి చెట్టు లో.
ఈ చెట్లు వాస్తవానికి, బైనరీ చెట్లు చెడిపోవు అంటారు
మరియు మేము భవిష్యత్తులో ఈ మరింత గురించి మాట్లాడదాము -
మీరు ఇతర కంప్యూటర్ సైన్స్ కోర్సులు వెళ్లే ముఖ్యంగా.
ఈ చెట్లు చెడిపోవు ఉంటాయి.
నిజానికి, ఈ నిర్మాణం కూడా ఇస్తుంది ఎందుకంటే వారు చాలా ఉపయోగకరంగా లేదు
ఒక లింక్ జాబితా పోలి సార్లు వెతికే కు.
మేము అదనపు మెమరీ ప్రయోజనాన్ని పొందుతారు లేదు - ఈ అదనపు పాయింటర్ -
ఎందుకంటే మా నిర్మాణం యొక్క ఈ విధంగా చెడు ఉంటుంది.
న వెళ్ళి root వద్ద 9 కలిగి బైనరీ చెట్లు అవుట్ డ్రా కాకుండా,
మేము ఉందని ఆఖరి వ్యాజ్యం, ఇది
మేము ఈ పదం ఇతర గురించి కొద్దిగా మాట్లాడాలని వెళ్ళి ఈ సమయంలో, బదులుగా ఉన్నారు
ఎత్తు అని పిలుస్తారు చెట్లు, గురించి మాట్లాడటం మేము ఉపయోగించే.
>> ఒక చెట్టు యొక్క ఎత్తు, మూలం నుండి అత్యంత సుదూర నోడ్కు దూరం
లేదా బదులుగా మీరు చేయడానికి చేయడానికి అవకాశం హాప్ సంఖ్య
మూలం నుండి ప్రారంభించి తర్వాత చెట్టు అత్యంత-సుదూర నోడ్ వద్ద ముగుస్తుంది.
మేము ఇక్కడే డ్రా చేసిన ఈ చెట్లు కొన్ని వద్ద, చూస్తే
మేము, 3 వద్ద మేము తెరుచుకుంటుంది ఈ చెట్టు తీసుకొని ఉంటే మేము ప్రారంభించండి చూడగలరు
అప్పుడు మేము 1 హాప్ 6 చెయ్యడానికి, 7 ను రెండో హాప్, తయారు చేసుకోవాలి
మరియు ఒక మూడవ హాప్ 9 చెయ్యడానికి.
కాబట్టి, ఈ చెట్టు యొక్క ఎత్తు 3.
మేము, ఈ ఆకుపచ్చ చెప్పిన ఇతర చెట్లు ఒకే వ్యాయామం చేయవచ్చు
మరియు మేము ఈ చెట్లు అన్ని యొక్క ఎత్తు నిజానికి కూడా 3 ఉందని.
వారికి చెడిపోవు చేస్తుంది ఏమి భాగంగా -
వారి ఎత్తు మొత్తం చెట్టు లో నోడ్ ల సంఖ్య కంటే కేవలం ఒక తక్కువ అని.
మేము మరోవైపు ఎరుపు తో చుట్టి ఉండే ఈ చెట్టు ఇతర, కేసి చూసినట్లయితే
మేము అత్యంత సుదూర ఆకు నోడ్స్ 6 మరియు 9 అని చూడండి -
పిల్లలు లేరు ఆ నోడ్స్ ఉండటం వెళ్లిపోతాడు.
కాబట్టి, రూట్ నోడ్ నుండి 6 లేదా 9 కానీ పొందడానికి,
మేము, 7 ను ఒక హాప్ తయారు చేసుకోవాలి మరియు తరువాత 9 చెయ్యడానికి రెండవ హాప్
మరియు అలాగే, 7 నుండి మాత్రమే రెండవ హాప్ 6 చెయ్యడానికి.
కాబట్టి, ఇక్కడ ఈ చెట్టు యొక్క ఎత్తు మాత్రమే 2.
మీరు తిరిగి వెళ్లి మేము ముందు చర్చించినట్లు ఇతర చెట్లు అన్ని ఆ చేయవచ్చు
7 మరియు 6 ప్రారంభించి,
మరియు మీరు ఆ చెట్లు అన్ని యొక్క ఎత్తు కూడా 2 అని చూడగలరు.
>> మేము గురించి ఆలోచిస్తున్నాము కారణం బైనరీ చెట్లు ఆదేశించింది
మీరు వాటిని ద్వారా శోధించవచ్చు ఎందుకంటే మరియు ఎందుకు అవి కూల్గా ఉన్నారు ఉంది
ఒక క్రమబద్ధీకరించబడతాయి శ్రేణి సెర్చింగ్ మాదిరిగా మార్గం.
ఈ మేము ఆ మెరుగైన లుక్అప్ సమయం పొందడానికి మాట్లాడటానికి ఎక్కడ ఉంది
సాధారణ లింక్ జాబితా పై.
ఒక లింక్ జాబితా తో - మీరు ఒక నిర్దిష్ట మూలకం కావలసిన వారికి -
మీరు ఉత్తమ సరళ శోధన విధమైన చేయబోవడం వద్ద ఉన్నారు
మీరు జాబితా హాప్ ఒకటి ఒక ప్రారంభంలో ప్రారంభం -
ఒక కణుపు ఒక నోడ్ -
మీరు శోధిస్తున్న ఏ కనుగొనేందుకు వరకు మొత్తం జాబితా ద్వారా.
, మీరు ఈ nice ఫార్మాట్ లో నిల్వ ఒక బైనరీ చెట్టు ఉంటే, అయితే
మీరు నిజంగా జరుగుతున్నాయి బైనరీ శోధన మరింత పొందవచ్చు
మీరు విభజించి జయించటానికి పేరు
ప్రతి దశ వద్ద చెట్టు యొక్క సరైన సగంలో శోధన.
యొక్క పనులను ఎలా చెప్పండి.
>> మేము కలిగి ఉంటే - మళ్ళీ, మా అసలు చెట్టు కు వెళుతున్నారు -
మేము, కుడివైపున, మేము ఎడమవైపు 3 కలిగి, 7 వద్ద 9 ప్రారంభం
మరియు 3 కింద మేము 6 ఉన్నాయి.
మేము ఈ చెట్టు లో 6 శోధించడానికి మీరు అనుకుంటే, మేము root వద్ద మొదలు కావలసిన.
మేము, 6 సే, చూస్తున్న విలువ పోల్చి చేస్తుంది
మేము ప్రస్తుతం 7, శోధిస్తున్న నోడ్ నిల్వ విలువ,
6 నిజానికి కంటే తక్కువ 7, కాబట్టి మేము ఎడమ తరలించడానికి మీరు తెలుసుకుంటారు.
6 విలువ 7 కంటే అధికంగా ఉంటే, మేము బదులుగా కుడి తరలించబడింది ఉండేది.
మేము తెలిసిన కనుక - మా ఆదేశించారు బైనరీ చెట్టు యొక్క నిర్మాణం కారణంగా -
7 కంటే తక్కువ విలువలు అన్ని 7 యొక్క ఎడమ వరకు నిలువ వెళ్తున్నారు
కూడా చెట్టు యొక్క కుడివైపు ద్వారా చూడటం ఇబ్బంది కు లేదు.
, ఒకసారి మేము ఎడమ తరలించడానికి మరియు మేము 3 కలిగిన నోడ్ వద్ద ఉన్నారు
మేము 3 మరియు 6 పోల్చి పేరు మేము మళ్ళీ అదే పోలిక చేయవచ్చు.
, 3 కంటే ఎక్కువ - మేము చూస్తున్న విలువ - మరియు మేము అయితే 6 తెలుసుకుంటారు
మేము 3 కలిగిన నోడ్ యొక్క కుడివైపు వెళ్ళవచ్చు.
ఎవరూ ఎడమవైపు ఇక్కడ, కనుక మేము ఆ నిర్లక్ష్యం కావచ్చు.
కానీ మేము మాత్రమే, మేము చెట్టు మాత్రం వద్ద చూస్తున్న ఎందుకంటే తెలుసు
మరియు మేము చెట్టు పిల్లలు లేరు ఆ చూడగలరు.
>> ఇది మనం మానవులు దానిని మేము చేస్తున్నా ఈ చెట్టు లో 6 చూసేందుకు కూడా అందంగా సులభం
కానీ అని యొక్క ఒక కంప్యూటర్ వంటి యాంత్రికంగా ఈ ప్రక్రియ అనుసరించడానికి వీలు కల్పించండి
నిజంగా అల్గోరిథం అర్థం.
ఈ సమయంలో, మేము ఇప్పుడు, 6 కలిగి ఒక కణుపు వద్ద చూస్తున్న
మరియు మేము, విలువ 6 చూస్తున్న
కాబట్టి, నిజానికి, మేము తగిన నోడ్ అనిపిస్తే.
మేము మా చెట్టు విలువ 6 దొరకలేదు, మరియు మేము మా శోధన మానివేయవచ్చు.
ఈ సమయంలో, ఏమి ఆధారపడి,
మేము చెప్పగలదు, అవును, మేము విలువ 6 కనుగొన్నారు, అది మా చెట్టు ఉంది.
మేము ఏదో ఒక నోడ్ ఇన్సర్ట్ లేదా చేయడానికి ప్లాన్ చేస్తున్నారు ఉంటే లేదా, మేము ఈ సమయంలో ఆ చేయవచ్చు.
>> ఎంత ఈ చిత్రాలను చూడడానికి రెండు మరింత చూచుకోగలదు తెలియజేసేలా యొక్క.
యొక్క మేము ప్రయత్నించండి మరియు విలువ 10 చూసేందుకు అయితే ఏమి చూద్దాం.
మేము విలువ 10 చూసేందుకు ఉంటే, మేము root వద్ద ప్రారంభిస్తుంది.
మేము 10 7 కంటే ఎక్కువ ఉందని భావిస్తే, కాబట్టి మేము తరలించడానికి మీరు.
మేము 9 ను మరియు 10 9 పోల్చి మరియు 9 నిజానికి కంటే తక్కువ 10 ఉందని భావిస్తున్న.
మరలా, మేము తరలించడానికి ప్రయత్నించాలి.
కానీ ఈ సమయంలో, మేము ఒక శూన్య నోడ్ వద్ద ఉన్నట్లు గమనించి కావలసిన.
ఏమీ లేదు ఉంది. 10 ఎక్కడ ఏదీ లేదు.
చెట్టు ఏ 10 నిజానికి ఉంది - మేము విఫలం నివేదించవచ్చు ఇది ఉంది.
చివరకు, మేము యొక్క చెట్టు లో 1 చూసేందుకు ప్రయత్నిస్తున్న సందర్భంలో వీలు.
ఈ, మేము 10 చూసేందుకు ఏమి బదులుగా కుడి వెళుతున్న తప్ప, జరిగినప్పుడు పోలి ఉంటుంది
మేము ఎడమ వెళ్ళండి చూడాలని.
మేము 7 వద్ద మొదలు మరియు 1 7 కంటే తక్కువ ఉందని, కాబట్టి మేము ఎడమ వెళతారు.
మేము 3 ను మరియు 1 3 కంటే తక్కువ ఉందని, మరలా మేము ఎడమ తరలించడానికి ప్రయత్నించండి.
ఈ సమయంలో మేము ఒక శూన్య నోడ్ కలిగి ఉంటాయి, కాబట్టి మళ్ళీ మేము విఫలం నివేదించవచ్చు.
>> మీరు, బైనరీ చెట్లు గురించి మరింత తెలుసుకోవడానికి అనుకుంటున్నారు ఉంటే
మీరు వారితో చేసే సరదా చిన్న సమస్యలను మొత్తం అక్కడ చాలా ఉన్నాయి.
నేను ఈ చిత్రాలు ఒకటి ఒకటి డ్రాయింగ్ ఔట్ సాధన సిఫార్సు
మరియు వివిధ దశలను ద్వారా తరువాత
ఈ సూపర్ ఉపయోగకరంగా ఉండగలదో ఎందుకంటే
మీరు హఫ్ఫ్మన్ ఎన్కోడింగ్ సమస్య సెట్ చేస్తున్నా లేదు మాత్రమే
కానీ భవిష్యత్తు విద్యా కోర్సులు -
కేవలం ఈ డేటా నిర్మాణశైలి గీయండి సమస్యలపై అనుకుంటున్నాను నేర్చుకోవడమే
తో కలం మరియు కాగితం లేదా, ఈ సందర్భంలో, ఐప్యాడ్ మరియు స్టైలస్.
>> అయితే ఈ సమయంలో, మేము కొన్ని కోడింగ్ విధానం చేయడానికి ముందుకు వెళుతున్నాం
మరియు వాస్తవానికి ఈ బైనరీ చెట్లతో ప్లే మరియు చూడండి.
నా కంప్యూటర్ కు మారడానికి వెళుతున్న.
బదులుగా CS50 రన్ లేదా CS50 Spaces ఉపయోగించి యొక్క విభాగం, ఈ భాగం,
నేను ఉపకరణం ఉపయోగించడానికి వెళుతున్న.
>> సమస్య సెట్ వివరణ తో పాటు తర్వాత,
నేను ఉపకరణం ప్రారంభం కోరుకుంటున్నాము కాబట్టి చూడండి
నా డ్రాప్బాక్స్ ఫోల్డర్కు వెళ్ళండి, విభాగం 7 అనే ఫోల్డర్ సృష్టించడం
ఆపై binary_tree.c అనే ఫైలు సృష్టించవచ్చు.
ఇక్కడ మేము వెళ్ళండి. నేను ఉపకరణం ఇప్పటికే ఓపెన్ పొందారు.
నేను టెర్మినల్ పుల్ అప్ వెళుతున్న.
నేను డ్రాప్బాక్స్ ఫోల్డర్కు వెళ్ళండి వెళుతున్న, section7 అనే డైరెక్టరీ తయారు,
మరియు అది పూర్తిగా ఖాళీ చూడండి.
ఇప్పుడు నేను binary_tree.c ప్రారంభం వెళుతున్న.
సరే. ఇక్కడ మేము వెళ్ళి - ఖాళీ ఫైల్.
>> యొక్క వివరణకు తిరిగి వెళ్ళి తెలపండి.
వివరణ ఒక కొత్త రకం నిర్వచనం సృష్టించడానికి అడుగుతుంది
Int విలువలు కలిగిన ఒక బైనరీ చెట్టు నోడ్సుకోసం -
కేవలం మా ముందు రేఖాచిత్రం గీయడం లో తీసుకున్న విలువలు ఇష్టపడుతున్నారు.
మేము ఇక్కడే చేసిన ఈ బాయిలర్ ప్లేట్ typedef ఉపయోగించడానికి వెళుతున్న
మీరు సమస్య సెట్ 5 నుండి గుర్తించాలి ఆ -
మీరు ఆక్రమించుకోనే స్పెల్లర్ కార్యక్రమం హాష్ పట్టిక విధంగా చేస్తే.
మీరు గత వారం యొక్క విభాగం నుండి గుర్తించాలి
మేము లింక్ జాబితాలు గురించి మాట్లాడారు.
మేము, ఒక struct నోడ్ యొక్క ఈ typedef పొందారు
మరియు మేము ఈ struct నోడ్ ముందుగానే struct నోడ్ యొక్క ఈ పేరు ఇచ్చాను
మేము struct నోడ్ గమనికలు కావాలి కాబట్టి మేము అప్పుడు చూడండి తద్వారా
మా struct భాగంగా, కాని మేము ఈ చుట్టుముట్టారు చేసిన -
లేదా, ఈ నడుమ - ఒక typedef లో
కాబట్టి, తర్వాత కోడ్, మేము బదులుగా ఒక struct నోడ్ యొక్క ఒక నోడ్ ఈ struct సూచించవచ్చు.
>> ఈ మేము గత వారం చూసిన ఒక్కొక్కటిగా లింక్డ్ జాబితా నిర్వచనం చాలా సమానంగా అన్నారు.
ఇది చేయుటకు, కేవలం యొక్క బాయిలర్ ప్లేట్ రాసిన ద్వారా ప్రారంభిద్దాం.
మేము, మేము ఒక పూర్ణాంకం విలువను కలిగి ఉందని మీకు
కాబట్టి మేము Int విలువ ఉంచారు, మరియు బదులుగా తరువాత మూలకం కేవలం ఒక పాయింటర్ కలిగి ఉంటుంది -
మేము ఒక్కొక్కటిగా లింక్డ్ జాబితాలు వలె -
మేము ఎడమ మరియు కుడి బాల గమనికలు చూడాలని.
అది చాలా అందంగా సులభం - struct నోడ్ * ఎడమ చైల్డ్;
మరియు struct నోడ్ * కుడివైపు చైల్డ్;. కూల్.
ఒక అందమైన మంచి ప్రారంభం కనిపిస్తోంది.
యొక్క వివరణకు తిరిగి వెళ్ళి తెలపండి.
>> ఇప్పుడు మేము ఒక చెట్టు యొక్క root ప్రపంచ నోడ్ * వేరియబుల్ ప్రకటించాలని అవసరం.
మేము కూడా ప్రపంచ మా లింక్ జాబితాలో మొదటి పాయింటర్ చేసి వలె ఈ ప్రపంచ సిధ్ధంగా చేస్తున్నారు.
ఈ విధంగా ఆ మేము వ్రాసే పనులను లో
మేము ఈ root చుట్టూ ప్రయాణిస్తున్న ఉంచడానికి లేదు -
మేము, మీరు లేకపోతే పునరావృతంగా ఈ విధులు రాయడానికి కావలసిన చూస్తారు అయితే
అది మొదటి స్థానంలో కూడా ఒక ప్రపంచ దానిని చుట్టూ పాస్ లేదు మెరుగైన కావచ్చు
మరియు బదులుగా మీ ప్రధాన విధి స్థానికంగా ఇది ప్రారంభించడం.
కానీ, మేము ప్రారంభించడానికి ప్రపంచవ్యాప్తంగా చేయును.
మళ్లీ, మేము ప్రాంతాల యొక్క జంట ఇస్తాము, మరియు నేను నోడ్ * root డిక్లేర్ వెళుతున్న.
జస్ట్ నేను ఈ అవినియోగిత విడిచి నిర్ధారించాలి, నేను శూన్యం సమానంగా సెట్ వెళుతున్న.
ఇప్పుడు, ప్రధాన ఫంక్షన్ - మేము ఇక్కడే నిజంగా త్వరగా వ్రాయడానికి మేము -
Int ప్రధాన (Int argc, కాన్స్ట్ చార్ * argv []) -
మరియు నేను నేను తెలిసిన కాన్స్ట్ నా argv శ్రేణి ప్రకటించారు ప్రారంభం వెళుతున్న
ఆ వాదనలు నేను బహుశా మీరు సవరించాలని అనుకుంటున్నారా లేని వాదనలు ఆ.
నేను వాటిని సవరించాలని అనుకుంటున్నారా ఉంటే నేను వారి యొక్క కాపీలు తయారు చేయాలి.
మీరు ఈ కోడ్ లో చాలా చూస్తారు.
ఇది జరిమానా గాని మార్గం. మీరు కావాలనుకుంటే కాన్స్ట్ వదిలివేయు - ఇది దానిని విడిచి మంచిది.
నేను సాధారణంగా నేను గుర్తు మాత్రమే కాబట్టి ఇది ఉంచారు
నేను బహుశా ఆ వాదనలు సవరించాలని అనుకుంటున్నారా లేని.
>> ఎప్పటిలాగే, నేను ప్రధాన చివరిలో ఈ తిరిగి 0 లైన్ ఉన్నాయి వెళుతున్న.
ఇక్కడ, నేను నా రూట్ నోడ్ ప్రారంభించడం కనిపిస్తుంది.
అది ప్రస్తుతం ఉంది, నేను, శూన్యం సెట్ ఒక పాయింటర్ పొందారు
కాబట్టి ఇది ఏమీ వద్ద గురిపెట్టి ఉంది.
క్రమంలో వాస్తవానికి, నోడ్ నిర్మించడం మొదలు
నేను మొదట కోసం మెమరీని కేటాయించాల్సిన అవసరం.
నేను malloc ఉపయోగించి కుప్ప మెమరీ ద్వారా అలా వెళుతున్న.
నేను, malloc యొక్క ఫలితంగా సమానంగా root సెట్ వెళుతున్న
మరియు నేను నోడ్ యొక్క పరిమాణం లెక్కించేందుకు sizeof ఆపరేటర్లు ఉపయోగించడానికి వెళుతున్న.
వ్యతిరేకంగా నేను sizeof నోడ్ ఉపయోగించే కారణం, సే,
malloc (4 + 4 +4) లేదా malloc 12 - ఈ వంటి ఏదో ఒక పని చేస్తూ -
నా కోడ్ వీలైనంత అనుకూలంగా ఉండాలనుకుంటున్నాను ఎందుకంటే ఉంది.
నేను ఈ. సి ఫైలు బృందం ఉండాలనుకుంటున్నాను, ఉపకరణంపై ఇది కంపైల్
అప్పుడు నా 64-bit Mac లో అది కంపైల్ -
లేదా పూర్తిగా భిన్నంగా నిర్మాణం మీద -
మరియు నేను ఈ ఒకే పని.
>> నేను వేరియబుల్స్ యొక్క పరిమాణం గురించి అంచనాలు తయారు చేస్తున్నాను ఉంటే -
ఒక పూర్ణాంకానికి లేదా ఒక పాయింటర్ యొక్క పరిమాణం పరిమాణం -
అప్పుడు నేను కూడా నిర్మాణాల రకాల గురించి అంచనాలకు దిగడం నేను
అమలు చేసినప్పుడు ఇది నా కోడ్ విజయవంతంగా కంపైల్ చేయవచ్చు.
మానవీయంగా struct ఖాళీలను వ్యతిరేకంగా ఎల్లప్పుడూ sizeof ఉపయోగించండి.
ఇతర కారణము కూడా కంపైలర్ struct లోకి తలదించుకునేలా padding ఉండవచ్చు అని.
కొంచం వ్యక్తిగత ఖాళీలను, మీరు సాధారణంగా చేయాలనుకుంటున్నారా విషయం కాదు
కాబట్టి, ఆ లైన్ తొలగించండి.
ఇప్పుడు, నిజంగా, ఈ రూట్ నోడ్ ప్రారంభించడం
నేను వివిధ రంగాలలో ప్రతి విలువలు లో ప్లగ్ అవసరం వెళుతున్న.
ఉదాహరణకు, విలువ కోసం నేను 7 ప్రారంభించడం మీరు తెలుసు,
మరియు ఇప్పుడు నేను ఎడమ చైల్డ్ శూన్య సెట్ వెళుతున్న
మరియు కుడి బాల కూడా శూన్య అని. గ్రేట్!
మేము వివరాల భాగాన్ని చేసిన.
>> పేజీ 3 దిగువన వివరణ క్రింది మూడు నోడ్స్ సృష్టించడానికి నాకు అడుగుతుంది -
9 3, 6 కలిగి, మరియు ఒక కలిగి -
మరియు ఆ విధంగా అది ఖచ్చితంగా మా చెట్టు చిత్రంలో కనిపిస్తోంది వాటిని WIRE
మేము గతంలో గురించి మాట్లాడుతూ ఆ.
లెట్ యొక్క ఇక్కడ చాలా త్వరగా చేయండి.
మీరు నేను నకిలీ కోడ్ కొంత వ్రాసి వెళుతున్న ఆ నిజంగా త్వరగా చూస్తారు.
నేను ఒక నోడ్ * సృష్టించడానికి వెళుతున్న మరియు నేను మూడు కాల్ వెళుతున్న.
నేను malloc (sizeof (నోడ్)) కు సమానమైన సెట్ వెళుతున్న.
నేను మూడు> విలువ = 3 సెట్ వెళుతున్న.
మూడు -> left_child = NULL; మూడు -> కుడి _child = NULL; అదే.
ఆ రూట్ ప్రారంభించడం కు అందంగా పోలి ఉంది, మరియు ఖచ్చితంగా ఏమి
నేను అలాగే 6 మరియు 9 ప్రారంభించడం మొదలు ఉంటే లేదు వెళుతున్న.
నేను నిజంగా త్వరగా ఇక్కడ చేస్తాను - నిజానికి, నేను చిన్న కాపీ మరియు పేస్ట్ చేయ బోతున్నాను,
ఆల్రైట్ - మరియు ఆ నేను నిర్ధారించుకోండి.
ఇప్పుడు, నేను కాపీ గాట్ మరియు నేను ముందుకు వెళ్లి 6 ఈ సమాన సెట్ చేయవచ్చు.
మీరు ఈ కొంచంసేపు తీసుకుని సూపర్ సమర్థవంతంగా కాదని చూడగలరు.
కేవలం కొద్దిగా, మేము ఇలా ఒక ఫంక్షన్ వ్రాయండి చేస్తాము.
నేను 9 ఈ భర్తీ చేయాలని మీరు అనుకుంటున్నారా, ఒక 6 ఆ స్థానంలో.
>> ఇప్పుడు మేము మా నోడ్స్ అన్ని రూపొందించినవారు మరియు initialized పొందారు.
మేము, మా root 7 సమానంగా సెట్ వచ్చింది, లేదా విలువ 7 కలిగిన చేసిన
3 కలిగిన మా నోడ్, 9 కలిగిన 6 కలిగిన మా నోడ్, మరియు మా నోడ్.
ఈ సమయంలో, మేము లేదు మొత్తం వైర్ ప్రతిదీ ఉంది.
నేను శూన్యం అన్ని గమనికలు initialized కారణం నేను ఖచ్చితంగా ఆ తయారు కేవలం ఉంది
నేను అనుకోకుండా అక్కడ ఏదైనా అవినియోగిత గమనికలు లేదు.
మరియు కూడా నుండి, ఈ సమయంలో, నేను మాత్రమే వాస్తవానికి ప్రతి ఇతర నోడ్స్ కనెక్ట్ కలిగి -
వారు వాస్తవానికి కనెక్ట్ వాటికి - నేను ద్వారా వెళ్ళి చేయడానికి లేదు
అన్ని nulls తగిన స్థలాలను లో ఉన్నాయి అని మీరు.
>> మూలం వద్ద ప్రారంభించి, నేను root యొక్క ఎడమ బాల 3 అని తెలుసు.
నేను root యొక్క కుడి బాల 9 అని తెలుసు.
ఆ తరువాత, నేను గురించి ఆందోళన వదలి మాత్రమే ఇతర చైల్డ్
6 ఇది 3 యొక్క కుడి బాల, ఉంది.
ఈ సమయంలో, అన్ని అందంగా బాగుంది.
ఈ పంక్తులు కొన్ని తొలగిస్తాము.
ఇప్పుడు ప్రతిదీ అందంగా బాగుంది.
యొక్క మా వివరణకు తిరిగి వెళ్లి మేము తర్వాత ఏమి చెప్పాలనుకుంటున్నారో చూడండి లెట్.
>> ఈ సమయంలో, మేము అనే ఫంక్షన్ 'ఉంది' రాయడానికి కలిగి
'bool కలిగి (Int విలువ)' యొక్క ఒక నమూనా తో.
మరియు ఈ చర్య నిజమైన తిరిగి అన్నారు కలిగి
చెట్టు మా గ్లోబల్ root వేరియబుల్ ద్వారా చూపారు ఉంటే
ఫంక్షన్ మరియు తప్పుడు లేకపోతే జారీ విలువ కలిగి ఉంది.
యొక్క కొనసాగి, ఆ తెలియజేసేలా.
ఈ ఖచ్చితంగా మేము కొద్దిగా క్రితం ఐప్యాడ్ న చేతితో అని వెతకడం లాగా అన్నారు.
లెట్స్ కొద్దిగా తిరిగి జూమ్ మరియు స్క్రోల్.
మేము మా ప్రధాన విధి పై ఈ ఫంక్షన్ పెట్టి చూడాలని
కాబట్టి మేము నమూనా ఏ విధమైన చేయడానికి లేదు.
కాబట్టి, bool (Int విలువ) ఉంది.
అక్కడ మేము వెళ్ళి. మా బాయిలెర్ప్లేట్ ప్రకటన ఉంది.
జస్ట్, ఈ సంకలనం అని నిర్ధారించడానికి
నేను ముందుకు వెళ్లి కేవలం తప్పుడు తిరిగి సమానంగా సెట్ వెళుతున్న.
ప్రస్తుతం ఈ ఫంక్షన్ కేవలం ఏదైనా చేయరు మరియు ఎల్లప్పుడూ పేర్కొన్నారు
మేము వెతికే విలువ చెట్టు లేదు.
>> ఈ సమయంలో, బహుశా అది మంచి ఆలోచన -
మేము కోడ్ యొక్క మొత్తం బంచ్ వ్రాయలేదు మరియు మేము కూడా ఇంకా అది పరీక్షా ప్రయత్నించారు కాబట్టి -
అన్ని కూర్చింది నిర్ధారించాలి.
మేము ఈ వాస్తవానికి కంపైల్ అని నిర్ధారించడానికి లేదు విషయముల యొక్క ఉన్నాయి.
మేము ఇంకా చేర్చబడలేదు ఏదైనా గ్రంథాలయాల్లో ఏ విధులు ఉపయోగించి అయితే మేము మొదటి, చూడండి.
మేము ఇప్పటివరకు ఉపయోగించి పనిచేస్తుంది, malloc ఉంటాయి
మరియు తర్వాత మేము కూడా ఈ రకం ఉపయోగించి చేసిన - 'bool' అని ఈ అప్రమాణిక రకం -
ఇది ప్రామాణిక bool శీర్షికా ఫైలును చేర్చారు.
మేము ఖచ్చితంగా bool రకం కోసం ప్రామాణిక bool.h, చేర్చాలనుకుంటే
మరియు మేము కూడా ప్రామాణిక గ్రంథాలయాలు ప్రామాణిక lib.h చేర్చాలనుకుంటే
ఆ malloc, మరియు ఉచిత మరియు అన్ని ఉన్నాయి.
కాబట్టి, దూరంగా, మేము విడిచి చూడాలని.
యొక్క ప్రయత్నించండి మరియు ఈ నిజంగా కంపైల్ అని ఖచ్చితంగా తయారు చేద్దాము.
మేము అది ఆ చూడండి, అలా మేము ట్రాక్ లో ఉన్నారు.
>> యొక్క మళ్లీ binary_tree.c ప్రారంభం లెట్.
ఇది కూర్చింది. యొక్క డౌన్ వెళ్ళి మా కలిగి పనిచేసేందుకు కొంత కాల్స్ ఇన్సర్ట్ నిర్ధారించుకోండి లెట్ -
ఆ అన్ని బాగా మరియు మంచి నిర్థారించడానికి.
ఉదాహరణకు, ప్రారంభ మా చెట్టు కొన్ని చూచుకోగలదు చేసుకుంది,
, మేము విలువలు 6, 10, మరియు 1 చూసేందుకు ప్రయత్నించింది, మరియు మేము 6 చెట్టు ఉంది అని తెలుసు
10 చెట్టు లేదు, మరియు 1 గాని చెట్టు లేదు.
యొక్క గుర్తించడానికి ఒక మార్గంగా ఆ నమూనా కాల్స్ ఉపయోగించడానికి మీరు లేదో
మా కలిగి ఫంక్షన్ పనిచేస్తోంది.
అలా చేయడానికి, నేను, printf క్రియాశీలతను ఉపయోగించదు వెళుతున్న
మరియు మేము కలిగి పిలుపు ఫలితంగా ముద్రించాలా వెళుతున్న.
నేను ఒక స్ట్రింగ్ లో పెట్టే వెళుతున్న "కలిగి (% d) = ఎందుకంటే
మేము కోసం చూడండి చూడాలని ఉద్దేశ్యంతో విలువ ప్లగ్ చూడాలని,
మరియు =% s \ n "మరియు ఆ ఉపయోగించడానికి మా ఫార్మాట్ స్ట్రింగ్ వంటి.
సాహిత్యపరంగా తెరపై ముద్రించాలా - మేము చూడండి చూడాలని -
ఏ ఒక ఫంక్షన్ కాల్ కనిపిస్తోంది.
ఈ నిజానికి ఫంక్షన్ కాల్ కాదు.
ఇది ఒక ఫంక్షన్ కాల్ వలె కనిపించే విధంగా రూపకల్పన సమూహము.
>> ఇప్పుడు మేము విలువలు ప్లగ్ చూడాలని.
మేము, 6 న కలిగి ప్రయత్నించండి చూడాలని
మరియు తర్వాత మేము ఇక్కడ చేయబోతున్నామని దాన్ని టెర్నరీ ఆపరేటర్లు ఉపయోగిస్తారు.
6 కలిగి - - లెట్ యొక్క కాబట్టి, ఇప్పుడు నేను 6 కలిగి చేసిన మరియు 6 కలిగి ఉంటే నిజం,
మేము% s ఫార్మాట్ పాత్ర పంపు చూడాలని ఉద్దేశ్యంతో స్ట్రింగ్
స్ట్రింగ్ "నిజమైన" అని అన్నారు.
లెట్ యొక్క కొద్దిగా మీద స్క్రోల్.
లేకపోతే, మేము తప్పుడు 6 తిరిగి కలిగి ఉంటే స్ట్రింగ్ "FALSE" పంపాలనుకుంటున్నారా.
ఈ చిన్న గూఫీ కనిపించే, కానీ నేను అదే వర్ణించేందుకు ఉండవచ్చు దొరుకుతుందని
ఏ టెర్నరీ ఆపరేటర్లు మేము కొంతకాలానికి అది చూడలేదు నుండి కనిపిస్తోంది.
ఈ మా కలిగి ఫంక్షన్ పని ఉంటే గుర్తించడానికి ఒక nice, సులభ మార్గం.
నేను, ఎడమ కి తిరిగి స్క్రోల్ వెళుతున్న
మరియు నేను కొన్ని సార్లు కాపీ మరియు ఈ లైన్ అతికించండి వెళుతున్న.
ఇది సుమారు ఈ విలువలు కొన్ని మార్పులు
ఈ 1 అన్నారు, మరియు ఈ 10 అని అన్నారు.
>> ఈ సమయంలో మేము ఒక మంచి కలిగి ఫంక్షన్ పొందారు.
మేము కొన్ని పరీక్షలు పొందారు, మరియు ఈ అన్ని పనులు మేము చూస్తారు.
ఈ సమయంలో మేము కొన్ని మరింత కోడ్ వ్రాయలేదు.
నుండి నిష్క్రమించినప్పుడు మరియు ప్రతిదీ కూడా కూర్చింది నిర్ధారించుకోండి సమయం.
నుండి నిష్క్రమించినప్పుడు, మరియు ఇప్పుడు యొక్క మళ్లీ బైనరీ చెట్టు రూపొందించడానికి ప్రయత్నించండి తెలియజేయండి.
మేము తప్పు పొందారు వంటి సరే,, కనిపిస్తోంది
మరియు మేము ఈ స్పష్టంగా printf లైబ్రరీ ఫంక్షన్ ప్రకటించారు పొందారు.
మేము లో వెళ్ళి # standardio.h ఉన్నాయి అవసరం కనిపిస్తుంది.
మరియు ఆ, ప్రతిదీ కంపైల్ చేయాలి. మేము అన్ని సిద్ధం.
ఇప్పుడు యొక్క బైనరీ చెట్టు నడుస్తున్న ప్రయత్నించండి మరియు ఏమి చూడటానికి.
ఇక్కడ మేము. / Binary_tree, ఉన్నాయి
మరియు మేము అనుకున్న, చూడండి -
మేము అమలు కారణంగా, ఇంకా కలిగి
లేదా, మేము తప్పుడు తిరిగి ఉంచాము -
మేము, అది వాటిని అన్ని తప్పుడు తిరిగి చేసే చూడండి
కాబట్టి అన్ని బాగా ఎక్కువ భాగం కోసం మేము.
>> యొక్క ఈ సమయంలో కలిగి తిరిగి వెళ్లి మరియు వాస్తవానికి అమలు లెట్.
నేను, స్క్రోల్ డౌన్ లో జూమ్ కు వెళ్ళి మరియు వెబ్ -
గుర్తుంచుకోండి, మేము ఉపయోగించే అల్గారిథమ్ మేము రూట్ నోడ్ వద్ద ప్రారంభించారు ఉంది
మరియు తర్వాత మేము ఎదుర్కొనే ప్రతి కణుపు వద్ద, మేము, ఒక పోలిక లేదు
మరియు ఆ పోలిక ఆధారంగా మేము గాని ఎడమ చైల్డ్ లేదా కుడి బాల వెళతారు.
ఈ మేము ముందుగా పదం ఈ విధంగా రాశాడు, బైనరీ శోధన కోడ్ కు సమానమైన చూడండి అన్నారు.
మేము ఆఫ్ చేయడం, మనం ప్రస్తుత నోడ్ కాపాడుకోవడానికి కావలసిన తెలిసిన
మేము వద్ద చూస్తున్న, మరియు ప్రస్తుత నోడ్ రూట్ నోడ్ కు initialized కావడం అని.
ఇప్పుడు, మేము, చెట్టు ద్వారా కొనసాగించడాన్ని వెళుతున్న
మరియు మా ఆపటం పరిస్థితి గుర్తుంచుకోవాలి -
మేము నిజంగా చేతితో ఉదాహరణ ద్వారా పనిచేసినప్పుడు -
మేము ఒక శూన్య నోడ్ ఎదుర్కొన్నప్పుడు, ఉంది
మేము ఒక శూన్య చైల్డ్ వద్ద చూచినప్పుడు,
కానీ మేము వాస్తవానికి చెట్ల ఒక నోడ్ కి వెళ్ళినప్పుడు
మరియు మేము ఒక శూన్య నోడ్ వద్ద ఉన్నట్లు కనుగొన్నారు.
ప్రస్తుత శూన్యం సమానం కాదు వరకు మేము iterate చూడాలని.
మరియు మేము వెళ్తున్నారు?
మేము పరీక్షించడానికి వెళ్ళడం మీరు (ప్రస్తుత -> విలువ == విలువ),
అప్పుడు మనం నిజంగా మేము వెతికే నోడ్ కనుగొనబడలేదు చేసిన తెలుసు.
ఇక్కడ, మేము నిజమైన తిరిగి రావచ్చు.
లేకపోతే, మేము విలువ విలువ కంటే తక్కువగా ఉంది లేదో చూడాలనుకుంటే.
ప్రస్తుత నోడ్ యొక్క విలువ విలువ కంటే తక్కువ ఉంటే మేము, వెతుకుతున్న
మేము తరలించడానికి వెళుతున్న.
కాబట్టి, ప్రస్తుత = ప్రస్తుత -> right_child; లేకపోతే, మేము ఎడమ తరలించడానికి వెళుతున్న.
ప్రస్తుత = ప్రస్తుత -> left_child;. ప్రెట్టీ సాధారణ.
>> బహుశా మీరు ఈ కు సమానమైన కనిపించే లూప్ గుర్తించి
మునుపటి పదం లో బైనరీ శోధన, అప్పుడు తప్ప మేము తక్కువ, మధ్య, మరియు అధిక వ్యవహరించే జరిగింది.
ఇక్కడ, మనం కేవలం ఒక ప్రస్తుత విలువ కు కలిగి
కాబట్టి ఇది నీస్ మరియు సులభం.
లెట్ యొక్క ఈ కోడ్ పని చేస్తుందని నిర్ధారించడానికి.
మొదటి, ఇది కూర్చింది నిర్ధారించుకోండి. అది కనిపిస్తోంది.
ఇది అమలు ప్రయత్నించండి లెట్.
నిజానికి, ఇది మేము అంచనా ప్రతిదీ ఔట్ ముద్రిస్తుంది.
10 చెట్టు లేదు ఎందుకంటే ఇది చెట్టు లో 6 గుర్తిస్తాడు, 10 కనుగొనేందుకు లేదు
1 చెట్టు కూడా లేదు ఎందుకంటే మరియు గాని 1 కనుగొనేందుకు లేదు.
కూల్ స్టఫ్.
>> సరే. యొక్క మా వివరణకు తిరిగి వెళ్లి తర్వాత ఏమి చూసేలా.
ఇప్పుడు, మా చెట్టు కొంత నోడ్స్ జోడించాలనుకుంటున్నారు!.
ఇది 5, 2, మరియు 8 జోడించడానికి, మరియు మా కోడ్ కలిగి నిర్ధారించుకోండి కోరుకుంటున్నారు
ఇంకా ఊహించిన పనిచేస్తుంది.
లెట్ యొక్క అలా వెళ్ళండి.
ఈ సమయంలో, బదులుగా మళ్ళీ ఆ బాధించే కాపీ మరియు పేస్ట్ చేయడం కంటే,
యొక్క అసలైన నోడ్ సృష్టించడానికి ఒక ఫంక్షన్ వ్రాయుటకు అనుమతి.
మేము ప్రధాన వరకు స్క్రోల్ డౌన్ ఉంటే, మేము ఈ చేస్తోంది చేసిన చూడండి
మేము ఒక నోడ్ సృష్టించడానికి కావలసిన ప్రతి సమయం ఓవర్ అండ్ ఓవర్ అగైన్ సమానమైన కోడ్.
>> యొక్క వాస్తవానికి మాకు నోడ్ నిర్మించడానికి మరియు తిరిగి ఒక ఫంక్షన్ వ్రాయుటకు అనుమతి.
నేను build_node కాల్ వెళుతున్న.
నేను ఒక ప్రత్యేక విలువతో ఒక నోడ్ నిర్మించడానికి వెళుతున్న.
ఇక్కడ జూమ్ చెయ్యండి.
నేను వెళుతున్న మొదటి విషయం వాస్తవానికి కుప్ప మీద నోడ్ స్థలాన్ని సృష్టించడానికి ఉంది.
కాబట్టి, నోడ్ * n = malloc (sizeof (నోడ్)); n -> విలువ = విలువ;
మరియు ఇక్కడ, నేను సరైన విలువలు అని రంగాలలో అన్ని ప్రారంభించడం వెళుతున్న.
మరియు చివరిలో, మేము మా నోడ్ తిరిగి పొందుతారు.
సరే. గమనించదగ్గ విషయం ఒకటి ఈ పనితనం ఇక్కడ ఉంది
కుప్ప కేటాయించడం ఉంది ఆ స్మృతి ఒక పాయింటర్ తిరిగి అన్నారు.
ఈ గురించి మంచిది ఇప్పుడు ఈ కణుపు -
మేము మేము స్టాక్ న ప్రకటించింది ఎందుకంటే కుప్ప మీద ప్రకటించాలని కలిగి
మేము ఈ వంటి ఈ ఫంక్షన్ లో చేస్తామని కాదు.
ఆ స్మృతి పరిధిని నుండి వెళ్ళిపోతుంది
మేము తరువాత అది యాక్సెస్ చేసేందుకు ప్రయత్నించారు ఉంటే మరియు చెల్లని ఉంటుంది.
మేము కుప్ప-కేటాయించిన మెమొరీ ప్రకటించారు కాబట్టి,
మేము తరువాత విడుదల చేయటం గురించి శ్రద్ధ వహించడానికి పొందబోతున్నారు
మా కార్యక్రమం కోసం ఏ మెమొరీ లీక్ కాదు.
మేము కోడ్ అన్నిటికీ ఆ న punting చేసిన
కేవలం సమయంలో సరళత కోసమని,
కానీ మీరు ఎప్పుడూ ఈ వలె కనిపించే ఒక ఫంక్షన్ వ్రాస్తే
మీరు పొందారు పేరు - కొన్ని అది లోపల malloc లేదా realloc కాల్ -
మీరు, మీరు అని ఇక్కడ వ్యాఖ్య విధమైన ఏర్పాటు ఆ నిర్ధారించుకోవాలి
హేయ్, మీకు తెలిసిన, Passed ఇన్ విలువ initialized ఒక నిండుగా కేటాయించడం నోడ్ తిరిగి.
మరియు మీరు చెప్పింది గమనించండి విధమైన ఉంచే నిర్ధారించుకోవాలి
కాలర్ తిరిగి మెమరీ విడిపించేందుకు ఉండాలి.
ఆ విధంగా, ఎవరైనా ఎప్పుడైనా వెళ్లి, ఆ ఫంక్షన్ ఉపయోగిస్తుంది
వారు ఆ ఫంక్షన్ తిరిగి ఏ తెలుసు
ఏదో ఒక సమయంలో విముక్తి ఉంటుంది.
>> , ఇక్కడ బాగా మరియు మంచి ఊహిస్తే
మేము మా కోడ్ దిగి వెళ్ళి ఇక్కడే ఈ పంక్తులు అన్ని భర్తీ చేయవచ్చు
మా బిల్డ్ నోడ్ కు కాల్స్ తో.
యొక్క ఆ నిజంగా త్వరగా తెలియజేసేలా.
మేము స్థానంలో వెళ్ళడం లేదు చేస్తున్న ఒక భాగం డౌన్ ఇక్కడ ఈ భాగం
మేము నిజంగా ప్రతి ఇతర సూచించడానికి నోడ్స్ అప్ WIRE పేరు క్రింద,
ఆ ఎందుకంటే మేము మా ఫంక్షన్ లో చెయ్యలేరు.
కానీ, లెట్స్ చేయండి root = build_node (7); నోడ్ * మూడు = build_node (3);
నోడ్ * ఆరు = build_node (6); నోడ్ * తొమ్మిది = build_node (9);.
ఇప్పుడు, మేము కూడా కోసం నోడ్స్ చేర్చాలని కోరుతున్నాయి -
నోడ్ * ఐదు = build_node (5); నోడ్ * ఎనిమిది = build_node (8);
మరియు ఇతర నోడ్ ఏమిటి? ఇక్కడ చూద్దాం. మేము కూడా ఒక 2 చేర్చాలని కోరుతున్నాయి -
నోడ్ * రెండు = build_node (2);.
సరే. ఈ సమయంలో, మేము 7, 3, 9, మరియు 6 పొందారు తెలుసు
సక్రమంగానే అప్ వైర్డు, కానీ 5, 8, మరియు 2 గురించి?
సరైన క్రమంలో ప్రతిదీ ఉంచడానికి,
మేము మూడు యొక్క కుడి బాల 6 అని తెలుసు.
కాబట్టి, మేము 5 జోడించండి చూడాలని ఉంటే,
5 కూడా, 3 రూట్ ఉండే చెట్టు యొక్క కుడివైపు చెందిన
కాబట్టి 5 6 యొక్క ఎడమ చైల్డ్ వంటి చెందినది.
మేము, ఆరు చెప్పడం ద్వారా చేయవచ్చు -> left_child = ఐదు;
;> left_child = ఎనిమిది - మరియు తర్వాత 8 తొమ్మిది కాబట్టి, 9 ఎడమ చైల్డ్ వంటి చెందిన
ఆపై 2 3 యొక్క ఎడమ బాల, కాబట్టి మేము ఇక్కడ ఆ చేయవచ్చు - నిన్ను -> left_child = రెండు;.
మీరు చాలా పాటు అనుసరించని ఉంటే, నేను మీరు మీరే దాన్ని డ్రా సూచిస్తున్నాయి.
>> సరే. యొక్క ఈ సేవ్ చేసేలా. లెట్ యొక్క, బయటకు వెళ్లి అది కూర్చింది నిర్ధారించుకోండి
మరియు తర్వాత మేము మా కలిగి కాల్స్ లో జోడించవచ్చు.
ప్రతిదీ కూడా కూర్చింది కనిపిస్తోంది.
యొక్క వెళ్ళి కొన్ని కాల్స్ కలిగి లో జోడించడానికి అనుమతిస్తుంది.
మళ్ళీ, నేను కాపీ మరియు పేస్ట్ యొక్క కొద్దిగా చేయ బోతున్నాను.
ఇప్పుడు లెట్స్ 5 8, మరియు 2, అన్వేషణ. సరే.
లెట్ యొక్క ఈ అన్ని ఇప్పటికీ బాగుంది నిర్ధారించుకోండి. గ్రేట్! సేవ్ మరియు నిష్క్రమించాడు.
ఇప్పుడు కంపైల్, యొక్క తయారు చేద్దాము, మరియు ఇప్పుడు యొక్క అమలు అనుమతిస్తాయి.
ప్రతిది చక్కగా nice మరియు పని ఉన్నట్లు ఫలితాల నుండి, కనిపిస్తోంది.
గ్రేట్! కాబట్టి ఇప్పుడు మేము మా కలిగి రాసిన పనిచేస్తున్నాయి పొందారు.
లెట్ యొక్క వెళ్లి చెట్టు లోకి నోడ్స్ ఇన్సర్ట్ ఎలా పని ప్రారంభించలేదు
మేము ఇప్పుడు చేయుచున్నారు వంటి నుండి, విషయాలు చాలా అందంగా కాదు.
>> మేము వివరణ తిరిగి వెళ్ళడానికి ఉంటే,
ఒక bool తిరిగి, తిరిగి - ఇది ఇన్సర్ట్ అనే ఫంక్షన్ రాయడానికి మాకు అడుగుతుంది
లేదో కోసం మేము వాస్తవానికి చెట్ల లోకి నోడ్ ఇన్సర్ట్ చేయవచ్చు -
ఆపై చెట్టు ఇన్సర్ట్ చెయ్యడానికి విలువ తెలిపిన
మా చొప్పించు కు మాత్రమే వాదన.
మేము నిజంగా చెట్టు లోకి నోడ్ కలిగి విలువ ఇన్సర్ట్ అని మేము నిజమైన తిరిగి
ఇది మేము, ఒక, తగినంత శక్తి ఉండేది అంటే
తరువాత రెండు, ఆ నోడ్ ఇప్పటికే నుండి చెట్టు ఉండేది కాదు -
గుర్తుంచుకోండి, మేము విషయాలు సాధారణ చేయడానికి, చెట్టు లో నకిలీ విలువలను కలిగి వెళ్ళడం లేదు.
సరే. కోడ్ తిరిగి.
దానిని తెరవండి. ఒక బిట్ జూమ్, అప్పుడు క్రిందికి స్క్రోల్ చేయండి.
యొక్క కుడి కలిగి పైన ఇన్సర్ట్ ఫంక్షన్ ఉంచారు లెట్.
మళ్లీ, అది (Int విలువ) bool చొప్పించు అని చెప్పారు.
డిఫాల్ట్ గా, అది కొంచెం ఖాళీ ఇవ్వండి, మరియు,
యొక్క ముగింపులో తప్పుడు తిరిగి ప్రవేశపెట్టింది తెలియజేయండి.
ఇప్పుడు క్రింద, యొక్క ముందుకు మరియు బదులుగా మానవీయంగా నోడ్స్ నిర్మించే వీలు
ప్రధాన లో మేమే మరియు వైరింగ్ వాటిని మేము చేస్తున్నా వంటి ప్రతి ఇతర సూచించడానికి,
మేము అలా మా చొప్పించు ఫంక్షన్ ఆధారపడి ఉంటుంది.
మేము, ఇంకా ప్రారంభం నుండి మొత్తం చెట్టు నిర్మించడానికి మా చొప్పించు ఫంక్షన్ నమ్మలేని కనిపిస్తుంది
కానీ మేము ఈ పంక్తులు విమోచనం పొందుతారు - we'll ఈ మార్గాల వ్యాఖ్య -
ఆ నోడ్స్ 5, 8, మరియు 2 నిర్మించడానికి.
మరియు బదులుగా, మేము మా చొప్పించు కు కాల్స్ ఇన్సర్ట్ చేస్తాము
వాస్తవానికి పనిచేస్తుంది నిర్ధారించాలి.
ఇక్కడ మేము వెళ్ళండి.
>> ఇప్పుడు మేము ఈ మార్గాల వ్యాఖ్యానించారు చేసిన.
మేము ఈ సమయంలో మా చెట్టు లో 7, 3, 9, మరియు 6 ఉన్నాయి.
ఈ అన్ని పనిచేస్తుందని ఖచ్చితంగా చేయడానికి,
మేము, మా బైనరీ చెట్టు తయారు, అవ్ట్ జూమ్ చేయవచ్చు
దీన్ని అమలు, మరియు మేము ఇప్పుడు మేము పూర్తిగా కుడి మాకు చెప్తుంటాడు కలిగి చూడగలరు -
5 8, మరియు 2, చెట్టు లో లేదు.
కోడ్ తిరిగి వెళ్ళు,
మరియు మేము ఎలా ఇన్సర్ట్ చెయ్యడానికి వెళ్తున్నారు?
మేము నిజంగా గతంలో, 8, మరియు 2 5 ఇన్సర్ట్ మేము ఏమి గుర్తుంచుకో.
మేము root వద్ద ప్రారంభించారు మేము, ఆ Plinko క్రీడా
ఒకరి ద్వారా చెట్టు ఒక మరణించింది
మేము తగిన ఖాళీ దొరకలేదు వరకు,
మరియు తర్వాత మేము తగిన స్థానంలో నోడ్ లో వైర్డు.
మేము కూడా అదే చేయబోతున్నామని.
ఈ లో మేము ఉపయోగించే కోడ్ అడగాలని రప్పించింది ఫంక్షన్ కలిగి
నోడ్ ఉండాలి ప్రదేశానికి కనుగొనేందుకు,
మరియు తర్వాత మేము అక్కడే నోడ్ ఇన్సర్ట్ చూడాలని.
లెట్ యొక్క చేసే విధంగా ప్రారంభించండి.
>> కాబట్టి మేము ఒక నోడ్ * ప్రస్తుత = root ఉన్నాయి; మేము కోడ్ కలిగి అనుసరించండి చూడాలని
మేము చాలా మాకు పని లేదు క్లిక్ చెయ్యండి.
ప్రస్తుత మూలకం శూన్య కాదు మేము చెట్టు ద్వారా వెళ్ళడానికి వెళుతున్న,
మేము భావిస్తే మరియు ప్రస్తుత యొక్క విలువ మేము ఇన్సర్ట్ చెయ్యడానికి ప్రయత్నిస్తున్న విలువకు సమానము -
అలాగే, ఈ మేము నిజంగా నోడ్ ఇన్సర్ట్ కొన్ని సందర్భాలలో ఒకటి
చెట్టు ఈ మేము ఒక నకిలీ విలువ కలిగివుంటాయి ఎందుకంటే.
ఇక్కడ మేము నిజంగా తప్పు తిరిగి చూడాలని.
ఇప్పుడు, ప్రస్తుత యొక్క విలువ, విలువ కంటే తక్కువగా ఉంది ఇంకా ఉంటే
ఇప్పుడు మనం కుడి తరలించిన తెలుసు
విలువ ప్రస్తుత చెట్టు యొక్క కుడి భాగంలో చెందిన.
లేకపోతే, మేము ఎడమ తరలించడానికి వెళుతున్న.
ప్రాథమికంగా మా కలిగి అక్కడే పని ఉంది.
>> ఈ సమయంలో, మేము, ఈ సమయంలో లూప్ పూర్తి చేసారు
మా ప్రస్తుత పాయింటర్ శూన్యం ను సూచిస్తాయి అన్నారు
ఫంక్షన్ ఇప్పటికే తిరిగి లేకపోతే.
మేము కొత్త నోడ్ ఇన్సర్ట్ చోట కనుక మేము స్థానంలో ప్రస్తుత సమస్య.
ఏది చేయవలసి ఉంది, వాస్తవానికి కొత్త నోడ్ నిర్మించడానికి ఉంది
ఇది మేము చాలా సులువుగా చెయ్యవచ్చు.
మేము, మా సూపర్ సులభ బిల్డ్ నోడ్ క్రియాశీలతను ఉపయోగించగలదు
మేము ముందు చేయకపోవడంతో మరియు ఏదో -
మేము కేవలం రకమైన మంజూరు కోసం తీసుకున్నప్పటికీ ఇప్పుడు మేము నిర్ధారించడానికి చేస్తాను -
మేము కొత్త నోడ్ తిరిగి విలువ వాస్తవానికి అని నిర్ధారించడానికి పరీక్షించడానికి చేస్తాము
శూన్య లేదు, మేము ఇది శూన్య ఉంటే ఆ స్మృతి యాక్సెస్ ప్రారంభం కావాలి లేదు.
మేము కొత్త నోడ్ శూన్య సమానం కాదు అని నిర్ధారించడానికి పరీక్షించవచ్చు.
నిజానికి శూన్య ఉంటే లేదా బదులుగా, మేము, చూడగలరు
అది శూన్య ఉంటే మరియు, అప్పుడు మేము ప్రారంభ తప్పుడు తిరిగి రావచ్చు.
>> ఈ సమయంలో, మేము చెట్టు దాని సరైన స్థానంలో నూతన నోడ్ WIRE ఉంటుంది.
మేము ప్రధాన తిరిగి చూడాలని మరియు మేము, ముందు వాస్తవానికి విలువలు లో వైరింగ్ ఉన్నాయి
మేము అది చేస్తున్న విధంగా మేము చెట్టు లో 3 ఉంచారు కోరుకున్నారు ఆ చూడండి
మేము root ఎడమ చైల్డ్ ప్రాప్తి.
మేము చెట్టు 9 ఉంచారు, మేము root కుడి బాల యాక్సెస్ వచ్చింది.
మేము చెట్టు ఒక కొత్త విలువ ఉంచేందుకు గాను మాతృ ఒక పాయింటర్ కలిగి ఉంది.
ఇన్సర్ట్ తిరిగి అప్ స్క్రోలింగ్, ఇక్కడ చాలా పని మాత్రం కాదు
మేము ఒక పేరెంట్ పాయింటర్ లేదు ఎందుకంటే.
మనం చేస్తామని మీరు, ఈ సమయంలో, ఉంది
తల్లిదండ్రుల విలువ తనిఖీ మరియు చూడండి - అదే, గోష్,
తల్లిదండ్రుల విలువ ప్రస్తుత విలువ కంటే తక్కువ ఉంటే,
అప్పుడు తల్లిదండ్రుల హక్కు చైల్డ్ కొత్త నోడ్ ఉండాలి;
లేకపోతే, తల్లిదండ్రుల ఎడమ చైల్డ్ కొత్త నోడ్ ఉండాలి.
కానీ, మేము చాలా ఇంకా ఈ మాతృ పాయింటర్ లేదు.
>> మేము చెట్టు ద్వారా వెళ్లినప్పుడు పొందడానికి, మేము దీన్ని ట్రాక్ చూడాలని
మరియు పైన మా లూప్ తగిన స్థానాన్ని చూడండి.
మేము మా చొప్పించు ఫంక్షన్ ఎగువ తిరిగి అప్ స్క్రోలింగ్ ద్వారా చేయవచ్చు
మరియు మరొక పాయింటర్ వేరియబుల్ ట్రాకింగ్ మాతృ అని.
మేము, ప్రారంభంలో శూన్యం సమానంగా సెట్ చూడాలని
తర్వాత ప్రతి సమయం మేము, చెట్టు ద్వారా వెళ్ళి
మేము ప్రస్తుత పాయింటర్ మ్యాచ్ ఆధార పాయింటర్ సెట్ చూడాలని.
ప్రస్తుత సమానంగా మాతృ సెట్ చెయ్యండి.
ఈ విధంగా, మేము ద్వారా వెళ్ళి ప్రతిసారీ,
మేము ప్రస్తుత పాయింటర్ చూసారు పెంచే హామీ చూడాలని
మాతృ పాయింటర్ అది క్రింది - చెట్టు ప్రస్తుత పాయింటర్ కంటే కేవలం ఒక స్థాయి.
అన్ని అందంగా బాగుంది.
>> మనం సర్దుబాటు చెయ్యవచ్చును ఒక్క విషయము ఈ నోడ్ తిరిగి శూన్య నిర్మించడానికి అనుకుంటాను.
వాస్తవానికి విజయవంతంగా శూన్య తిరిగి నోడ్ నిర్మించడానికి పొందటానికి,
మేము, ఆ కోడ్ సవరించడానికి ఉంటుంది
ఇక్కడ ఎందుకంటే, మేము malloc చెల్లుబాటు అయ్యే పాయింటర్ తిరిగి నిర్ధారించాలి పరీక్షించారు ఎప్పుడూ.
కాబట్టి, ఒకవేళ (n = NULL!), అప్పుడు -
malloc చెల్లుబాటు అయ్యే పాయింటర్ తిరిగి, అప్పుడు మేము దాన్ని ప్రారంభించడం తెలీదు;
లేకపోతే, మేము తిరిగి ఉంటాం మరియు మాకు శూన్య తిరిగి అప్ ముగుస్తుంది.
ఇప్పుడు అన్ని అందంగా బాగుంది. యొక్క ఈ వాస్తవానికి కూర్చింది నిర్ధారించుకోండి లెట్.
బైనరీ చెట్టు చేయండి, మరియు, OH మేము ఇక్కడ జరగబోతోంది కొన్ని అంశాలను పొందారు.
>> మేము చర్య యొక్క అవ్యక్త ప్రకటన నోడ్ నిర్మించడానికి పొందారు.
మళ్ళీ, ఈ సంకలనం తో, మేము ఎగువన ఆరంభమవుతుంది చేస్తున్నారు.
ఏం అర్థం ఉండాలి నిజానికి ప్రకటించింది చేసిన ముందు నేను నోడ్ నిర్మించడానికి కాల్ చేస్తున్నాను అని.
యొక్క నిజంగా త్వరగా కోడ్ తిరిగి వెళ్ళి తెలపండి.
స్క్రోల్ డౌన్ మరియు ఖచ్చితంగా తగినంత, నా చొప్పించు ఫంక్షన్ ప్రకటిస్తారు
బిల్డ్ నోడ్ ఫంక్షన్ పై,
కానీ నేను చొప్పించు లోపలి నోడ్ నిర్మించడానికి ఉపయోగించే ప్రయత్నిస్తున్నాను.
నేను మరియు కాపీ లో వెళ్ళి వెళుతున్న - మరియు తర్వాత ఎగువ భాగంలో ఇక్కడ బిల్డ్ నోడ్ ఫంక్షన్ మార్గం అతికించండి.
ఆ విధంగా, ఆశాజనక ఆ పని చేస్తుంది. ఈ మళ్లీ యొక్క కల్పించడానికి అనుమతిస్తాయి.
ఇప్పుడు అది కూర్చింది. అన్ని మంచి ఉంది.
>> కానీ ఈ సమయంలో, మేము నిజంగా మా చొప్పించు ఫంక్షన్ అని లేదు.
మేము దానిని కూర్చింది తెలుసు, కాబట్టి యొక్క వెళ్ళి కొన్ని కాల్స్ సైన్ ఉంచారు తెలియజేయండి
మా ప్రధాన ఫంక్షన్ అలా లెట్స్.
ఇక్కడ, మనం, 5 8, మరియు 2, అవ్ట్ వ్యాఖ్యానించారు
మరియు తర్వాత మేము డౌన్ వాటిని ఇక్కడ అప్ WIRE లేదు.
యొక్క కొన్ని కాల్స్ ఇన్సర్ట్ చెయ్యడానికి తయారు చేద్దాము,
మరియు కూడా మేము ఉపయోగించే విషయం రకమైన ఉపయోగించడానికి అనుమతిస్తున్నట్లు
మేము ప్రతిదీ సరిగ్గా చేర్చబడుతుంది అని నిర్ధారించడానికి ఈ printf కాల్స్ చేశారు.
నేను, కాపీ మరియు పేస్ట్ వెళుతున్న
మరియు మేము చొప్పించు చేయబోతున్నామని బదులుగా కలిగి ఉంది.
మరియు బదులుగా 6, 10, మరియు 1 యొక్క, మేము 5 8, మరియు 2 ఉపయోగించడానికి వెళుతున్న.
ఈ ఆశాజనక చెట్టు లోకి 5 8, మరియు 2, ఇన్సర్ట్ చేయాలి.
కూర్పు. అన్ని మంచి ఉంది. ఇప్పుడు మేము నిజంగా మా ప్రోగ్రామ్ రన్ చేస్తాము.
>> అంతా తప్పుడు తిరిగి.
కాబట్టి, 5, 8, మరియు 2 వెళ్ళలేదు, మరియు కలిగి వాటిని కనుగొనడానికి లేదు అనిపిస్తుంది.
ఏం జరగబోతోంది? యొక్క దూరంగా లెట్.
మొదటి సమస్య, చొప్పించు తప్పుడు తిరిగి అనిపించింది ఉంది
మరియు మా తిరిగి తప్పుడు కాల్ మిగిలి ఎందుకంటే ఆ వంటి కనిపిస్తోంది
మరియు మేము నిజంగా నిజమైన రాలేదు.
మేము ఆ సెటప్ చేయవచ్చు.
మేము కూడా రెండవ సమస్య ఇప్పుడు ఉంది - ఈ సేవ్, ఈ విడిచి
మళ్ళీ తయారు అమలు, అది అమలు తర్వాత, కంపైల్ చేసిన -
మేము ఏదో ఇక్కడ జరిగిన చూడండి.
5, 8, మరియు 2 ఇప్పటికీ చెట్టు లో గుర్తించలేకపోయారు.
కాబట్టి, ఏం జరగబోతోంది?
>> యొక్క కోడ్ లో ఈ పరిశీలించి చూద్దాం.
మేము ఈ గుర్తించడానికి లేదో యొక్క చూసేలా.
మేము మాతృ శూన్య లేదని ప్రారంభం.
మేము, root పాయింటర్ సమానంగా ప్రస్తుత పాయింటర్ సెట్
మరియు మేము చెట్టు ద్వారా మా మార్గం డౌన్ వెళ్లాలని చేస్తున్నారు.
ప్రస్తుత నోడ్ శూన్య కాదు, అప్పుడు మనం కొద్దిగా క్రిందికి తరలించడానికి మీకు.
మేము, ప్రస్తుత పాయింటర్ సమానంగా మా మాతృ పాయింటర్ సెట్
విలువ తనిఖీ - విలువలు అదే ఉంటే మేము తప్పుడు తిరిగి.
విలువలు తక్కువ ఉంటే మేము మారారు;
లేకపోతే, మేము ఎడమ తరలించబడింది.
అప్పుడు మేము ఒక నోడ్ నిర్మించడానికి. నేను కొద్దిగా దగ్గరికి జూమ్ చేస్తాము.
మరియు ఇక్కడ, మేము అదే అని విలువలు అప్ WIRE ప్రయత్నించండి చూడాలని.
ఏం జరగబోతోంది? బహుశా Valgrind మాకు సూచనను ఇస్తుంది లేదో యొక్క చూసేలా.
>> నేను ఎందుకంటే నిజంగా త్వరగా పరుగులు Valgrind Valgrind ఉపయోగించాలనుకుంటున్న
ఏ మెమరీ లోపాలు ఉంటే మరియు మీరు చెబుతుంది.
మేము, కోడ్ న Valgrind అమలు చేసినప్పుడు
మీరు చూడగలరు సరైన here--Valgrind./binary_tree--and హిట్ నమోదు.
మీరు మేము ఏ మెమరీ లోపం లేని చూడండి, తద్వారా అన్నీ ఇప్పటివరకు సరైందే కనిపిస్తుంది.
మేము లేదు ఎందుకంటే మేము, మేము తెలిసిన కొన్ని మెమరీ లీకేజ్, లేదు
మా నోడ్స్ యొక్క ఏ విముక్తికై సంభవించే.
యొక్క నిజానికి ఏమి చూడటానికి GDB నడుస్తున్న ప్రయత్నించండి లెట్.
మేము GDB చేస్తాను. / Binary_tree. ఇది బాగా అప్ బూట్.
యొక్క ఇన్సర్ట్ ఒక బ్రేక్ పాయింట్ సెట్ లెట్.
యొక్క అమలు అయ్యేలా అనుమతించండి.
మేము నిజంగా చొప్పించు అని ఎప్పుడూ అనిపిస్తుంది.
సమస్య కేవలం నేను ప్రధాన ఇక్కడ డౌన్ మార్చుకున్న తరువాత ఆ కనిపిస్తుంది -
కలిగి నుండి ఈ printf కాల్స్ అన్ని -
నిజానికి చొప్పించు కాల్ ఈ మార్పు ఎప్పుడూ.
ఇప్పుడు దీనిని ఒకసారి ప్రయత్నించండి తెలియజేయండి. యొక్క కంపైల్ లెట్.
అక్కడ మంచి ఉంది. ఇప్పుడు అది అమలు ప్రయత్నించండి తెలపండి, ఏమి చూడండి.
సరే! అంతా అక్కడ చాలా బాగుంది.
>> గురించి ఆలోచించటం చివరి విషయం, ఈ ఇన్సర్ట్ చెయ్యడానికి ఏ అంచు సందర్భాలలో ఉన్నాయి?
మరియు అది అవుతుంది ఎల్లప్పుడూ గురించి ఆలోచించటం ఆసక్తికరమైన అని ఒక అంచున కేసు కూడా, ఆ
, మీ చెట్టు ఖాళీగా ఉంది ఏమవుతుంది మరియు మీరు ఈ ఇన్సర్ట్ ఫంక్షన్ కాల్?
ఇది పని చేస్తుంది? సరే, ఒకసారి ప్రయత్నించండి తెలియజేయండి.
- Binary_tree సి. -
మేము ఈ పరీక్షించడానికి వెళుతున్న విధంగా, మేము, మా ప్రధాన కు డౌన్ వెళ్ళి చూడాలని ఉంది
మరియు బదులుగా దీన్ని ఇష్టపడుతున్నారు వైరింగ్ ఈ నోడ్స్ అప్ కంటే,
మేము మొత్తం విషయం బయటకు మీరే వెళుతున్న
మరియు బదులుగా నోడ్స్ మేమే అప్ వైరింగ్ యొక్క,
మేము నిజానికి ముందుకు వెళ్లి ఈ అన్ని తొలగించవచ్చు.
మేము ప్రతిదీ ఇన్సర్ట్ చెయ్యడానికి కాల్ చేయడానికి వెళుతున్న.
కాబట్టి, యొక్క తెలియజేసేలా - బదులుగా 5, 8, మరియు 2, మేము 3, 7 ఇన్సర్ట్, మరియు 9 చూడాలని.
మరియు తర్వాత మేము కూడా అలాగే 6 ఇన్సర్ట్ చెయ్యవచ్చును.
సేవ్. క్విట్. బైనరీ చెట్టు చేయండి.
అన్ని కూర్చింది.
మేము దాన్ని వంటి అమలు మరియు ఏమి చూడగలరు
కానీ ఇది నిర్ధారించుకోండి చాలా ముఖ్యమైనది చేస్తాడు
మేము ఏ మెమరీ లోపాలు లేదు
ఈ మనం తెలిసిన మా అంచు సందర్భాలలో ఒకటి నుండి.
>> లెట్ యొక్క, అది Valgrind కింద బాగా పనిచేస్తుంది నిర్ధారించుకోండి
మేము కేవలం Valgrind. / binary_tree అమలు చేసి చేస్తాను ఇది.
మేము నిజంగా ఒక సందర్భం నుండి ఒక లోపం కలిగి కనిపిస్తుంది -
మేము ఈ విభజన లోపంగా ఉంది.
ఏమి జరిగింది?
అది ఎక్కడ Valgrind వాస్తవానికి మాకు చెబుతుంది.
కొద్దిగా దూరంగా జూమ్ చెయ్యండి.
అది మా చొప్పించు ఫంక్షన్ లో ఏం జరుగుతున్నది వంటి ఇది కనిపిస్తుంది
మేము చొప్పించు వద్ద పరిమాణం 4 యొక్క చెల్లని చదివాను, అక్కడ లైన్ 60.
యొక్క తిరిగి వెళ్ళి, ఏమి చూసేలా.
నిజంగా శీఘ్ర దూరంగా జూమ్ చెయ్యండి.
మనం ప్రతిదీ చూడగలరు ఇది స్క్రీన్ యొక్క అంచు వరకు వెళ్ళి లేదు నిర్ధారించుకోవాలి.
కొద్దిగా ఆ పుల్. సరే.
స్క్రోల్ డౌన్ మరియు సమస్య ఇక్కడే ఉంది.
, మేము క్రిందికి ఏమవుతుంది మరియు మా ప్రస్తుత నోడ్ ఇప్పటికే శూన్య ఉంది
మేము చాలా టాప్ ఇక్కడే వద్ద చూసేందుకు అయితే మా మాతృ నోడ్, శూన్య ఉంది -
ఈ సమయంలో లూప్ వాస్తవానికి అమలు ఎప్పుడూ ఉంటే
మా ప్రస్తుత విలువ NULL ఎందుకంటే - ప్రస్తుత శూన్య కాబట్టి మా root శూన్య ఉంది -
అప్పుడు మా మాతృ, ప్రస్తుత లేదా ఒక చెల్లుబాటు అయ్యే విలువ సెట్ అవుతుంది ఎప్పుడూ
కాబట్టి, మాతృ కూడా శూన్య ఉంటుంది.
మేము ఆ తనిఖీ గుర్తుంచుకోవాల్సిన అవసరం
సమయానికి మేము ఇక్కడ క్రిందికి, మరియు మేము తల్లిదండ్రుల విలువ చేరుకోండి.
కాబట్టి, ఏమి జరుగుతుంది? Well, ఉంటే మాతృ శూన్య ఉంది -
(మాతృ == NULL) ఉంటే - అప్పుడు మేము తెలిసిన
చెట్టు లో ఏదైనా అక్కడ ఉండకూడదు.
మేము root వద్ద ఇన్సర్ట్ చెయ్యడానికి ప్రయత్నిస్తున్నారు ఉండాలి.
మేము కొత్త నోడ్ సమానంగా root అమర్చుట ద్వారా ఆ చేయవచ్చు.
ఈ సమయంలో, మేము నిజంగా ఈ ఇతర విషయాలు ద్వారా వెళ్ళడానికి లేదు.
బదులుగా, ఇక్కడే, మేము, ఒక else-ఉంటే-else గాని చేయగలరు
లేదా మేము, ఒక else ఇక్కడ ప్రతిదీ అప్ కలవచ్చు
కానీ ఇక్కడ మేము వేరే ఉపయోగించడానికి మరియు ఆ విధంగా చేస్తాను.
ఇప్పుడు, మేము మా తల్లిదండ్రుల శూన్య కాదు నిర్ధారించుకోండి పరీక్ష చేయడానికి వెళుతున్న
అప్పుడు ముందు నిజంగానే దాని ఖాళీలను యాక్సెస్ చేయడానికి ప్రయత్నిస్తున్న.
ఈ మాకు విభజన లోపంగా నివారించడానికి సహాయం చేస్తుంది.
కాబట్టి, మేము విడిచి, దూరంగా కంపైల్, అమలు.
>> లోపాలు, కాని మేము ఇంకా మెమరీ లీకేజ్ కొంత కలిగి
మేము మా నోడ్స్ యొక్క ఏ రహిత ఎందుకంటే.
మేము ఇక్కడ వెళ్ళి ఉంటే, మేము, మా ప్రింటవుట్ చూడండి
మేము మంచి ఇది, నిజమైన తిరిగి, అదే, మా ఇన్సర్ట్ అన్ని కనిపించే చూడండి.
ఇన్సర్ట్ అన్ని నిజమైన,
మరియు తర్వాత తగిన కలిగి కాల్స్ కూడా నిజమైన.
>> ఉద్యోగం గుడ్! మేము విజయవంతంగా చొప్పించు రాసిన అనిపిస్తున్నది.
అంటే ఈ వారం యొక్క సమస్య సెట్ వివరణ కోసం కలిగి అంతే.
గురించి ఆలోచించటం ఒక సరదా సవాలు మీరు నిజంగా వెళ్లి ఎలా ఉంది
మరియు ఈ చెట్టు లో నోడ్స్ అన్ని ఉచిత.
మేము, అందుచే వేర్వేరు రకాలుగా చేయవచ్చు
కానీ నేను, ప్రయోగం వరకు ఆ అప్ చెప్పను
మరియు ఒక ఆహ్లాదకరమైన సవాలుగా, ప్రయత్నించండి మరియు మీరు నిర్ధారించుకోండి నిర్ధారించండి
ఈ Valgrind నివేదిక లోపాలు మరియు లీకేజ్ ఏ తిరిగి ఆ.
>> అదృష్టం ఈ వారం యొక్క హఫ్ఫ్మన్ కోడింగ్ సమస్య సెట్లో,
మరియు మేము వచ్చే వారం మీరు చూస్తారు!
[CS50.TV]