>> [సంగీతాన్ని]
>> డౌ LLOYD: OK, కాబట్టి కోర్సు లో ఈ సమయంలో,
మేము C. పునాదులను చాలా కవర్ చేసిన మేము వేరియబుల్స్ శ్రేణుల గురించి చాలా తెలుసు
గమనికలు, అన్ని మంచి విషయం.
ఆ అన్ని విధమైన నిర్మించబడ్డాయి లో, ఫండమెంటల్స్ చూడటానికి
కానీ మేము కుడి, ఎక్కువ చేయవచ్చు?
మేము విషయాలు మిళితం చేయవచ్చు కలిసి ఆసక్తికరమైన మార్గాలలో.
>> అందువలన ప్రారంభిద్దాం, యొక్క ఆ తెలియజేసేలా సి మాకు లభిస్తుంది విడిపోవాలని,
మరియు మా స్వంత డేటా సృష్టించడానికి ప్రారంభించండి ఈ బిల్డింగ్ ఉపయోగించి నిర్మాణాలు
కలిసి బ్లాక్స్ ఏదో చేయాలని ఉపయోగకరమైన నిజంగా విలువైన.
మేము దీన్ని ఒక మార్గం ఉంది సేకరణలు గురించి మాట్లాడటానికి.
కాబట్టి ఇప్పటివరకు మేము డేటా యొక్క ఒక రకం కలిగింది సేకరణలు ప్రాతినిధ్యం నిర్మాణం
విలువలు పోలి విలువలు ఇష్టం.
ఆ వ్యూహంలో ఉంటుంది.
మేము పూర్ణాంకాల సేకరణలు, లేదా అందువలన న అక్షరాలు మరియు సేకరణలు.
>> నిర్మాణాలు కూడా ఒక డేటా యొక్క క్రమం ఉంటాయి సమాచారాన్ని సేకరించడం కోసం నిర్మాణం,
కానీ అది విలువలు వంటి సేకరించటం కోసం కాదు.
ఇది సాధారణంగా వివిధ రకాల డేటా జోడించింది కలిసి ఒకే బాక్స్ లోపల.
కానీ అది కూడా కాదు కలిసి గొలుసు ఉపయోగిస్తారు
లేదా కలిసి ఇలాంటి కనెక్ట్ వ్యూహం వంటి అంశాలను.
శ్రేణుల కోసం గొప్ప ఉన్నాయి మూలకం చూసేందుకు కానీ రీకాల్
ఇది చాలా కష్టం అని వ్యూహం లోకి ఇన్సర్ట్,
మేము ఇన్సర్ట్ తప్ప ఆ అర్రే ముగింపు.
>> మరియు ఉత్తమ ఉదాహరణకు నేను కలిగి ఆ కోసం చొప్పించడం విధమైన ఉంది.
మీరు మా వీడియో గుర్తు ఉంటే చొప్పించడం విధమైన,
చాలా ఉంది ఖర్చు కలిగి చేరి
అంశాలు ఎంచుకొని, మరియు వాటిని మార్చేందుకు ఏదో సరిపోయే విధంగా బయటకు
మీ శ్రేణి యొక్క మధ్యలో.
వ్యూహాలను కూడా మరొక బాధపడుతున్నారు సమస్య, ఇది inflexibility ఉంది.
మేము ఒక అర్రే డిక్లేర్ చేసినప్పుడు, మేము దాన్ని ఒక షాట్ పొందడానికి.
మేము నేను కావలసిన, చెప్పడానికి పొందండి ఈ అనేక అంశాలు.
100 కావచ్చు, అది బలం 1,000, అది బలం
x యూజర్ ఒక సంఖ్య x ఉంటుంది ఒక ప్రాంప్ట్ వద్ద లేదా కమాండ్ వద్ద మాకు ఇచ్చింది
లైన్.
>> కానీ మేము మాత్రమే అది ఒక షాట్ పొందడానికి, మేము నేను నిజానికి, అప్పుడు ఓహ్ చెప్పటానికి పొందలేము
101 అవసరమైన, లేదా నేను x ప్లస్ 20 అవసరమైన.
చాలా ఆలస్యం, మేము ఇప్పటికే డిక్లేర్డ్ చేసిన అర్రే, మరియు మేము 101 లేదా పొందడానికి అనుకుంటే x
ప్లస్ 20, మేము డిక్లేర్ కలిగి ఒక పూర్తిగా భిన్నంగా శ్రేణి,
శ్రేణి యొక్క అన్ని మూలకాలను కాపీ పైగా, మరియు అప్పుడు మేము తగినంత ఉంది.
మరియు మేము మళ్ళీ తప్పు ఉంటే ఏమి, ఏమి మేము నిజానికి 102, లేదా x ప్లస్ 40 అవసరం ఉంటే,
మేము మళ్ళీ దీన్ని కలిగి.
కాబట్టి వారు చాలా కఠినమైన ఉన్నాము మా డేటా పునఃపరిమాణం,
కానీ మేము కలిసి కొన్ని మిళితం ఉంటే మేము ఇప్పటికే చేసిన బేసిక్స్
గమనికలు మరియు నిర్మాణాలు గురించి నేర్చుకున్నాడు, ముఖ్యంగా డైనమిక్ మెమరీ ఉపయోగించడం
malloc తో కేటాయింపు, మేము కలిసి ఈ ముక్కలు ఉంచవచ్చు
ఒక కొత్త డేటా నిర్మాణం ఒక సృష్టించడానికి ఒక్కొక్కటిగా మేము చెప్పడానికి ఉండవచ్చు లింక్డ్ జాబితా
మాకు పెరుగుతాయి అనుమతిస్తుంది మరియు విలువలు సమాహారం కుదించే
మరియు మేము ఏ వృధా స్పేస్ ఉండదు.
>> మరలా, మేము ఈ ఆలోచన కాల్, ఈ భావన, ఒక లింక్ జాబితా.
ముఖ్యంగా, ఈ వీడియో లో మేము ఉన్నాము ఒక్కొక్కటిగా లింక్ జాబితా గురించి మాట్లాడటం,
ఆపై మరొక వీడియో మేము మాట్లాడదాము గురించి రెట్టింపైన అనుసంధాన జాబితాలు ఇది
ఇక్కడ ఒక అంశం కేవలం ఒక వైవిధ్యం.
కానీ ఒక ఒక్కొక్కటిగా లింక్ జాబితా నోడ్స్ యొక్క భాగంగా ఉండేవారు ఉంది
నోడ్స్ కేవలం ఒక నైరూప్య term-- ఉండటం నేను కాల్ చేస్తున్నాను కేవలం ఏదో
ఆ రకంగా నిర్మాణం, సాధారణంగా, నేను ఉన్నాను?
జస్ట్ ఒక నోడ్ మరియు ఈ కాల్ వెళుతున్న నోడ్ రెండు సభ్యులు, లేదా రెండు విభాగాలున్నాయి.
ఇది సాధారణంగా ఒక డేటా ఉంది పూర్ణాంక, ఒక పాత్ర ఫ్లోట్,
లేదా కొన్ని ఇతర డేటా రకం కావచ్చు మీరు ఒక రకం డెఫ్ తో నిర్వచించిన చేసిన.
మరియు అది ఒక పాయింటర్ కలిగి ఒకే రకమైన మరొక నోడ్.
>> కాబట్టి మేము లోపల రెండు విషయాల్లో ఈ నోడ్ డేటా మరియు ఒక పాయింటర్
మరొక నోడ్.
మరియు మీరు ఊహించడానికి మొదలు ఉంటే ఈ మీరు దాని గురించి ఆలోచించవచ్చు
నోడ్స్ యొక్క గొలుసు వంటి కలిసి కనెక్ట్.
మేము మొదటి నోడ్ కలిగి, అది డేటా, మరియు ఒక పాయింటర్ కలిగి
కలిగి రెండవ నోడ్ కు డేటా, మరియు మూడవ నోడ్ ఒక పాయింటర్.
అందువలన, మేము అది ఒక కాల్ ఎందుకు లింక్ జాబితా, వారు కలిసి లింక్ చేయబడతాయి.
>> ఈ ప్రత్యేక వేటికి నోడ్ నిర్మాణం కనిపిస్తుంది?
సరే, మీరు మా వీడియో నుండి గుర్తు ఉంటే రకం డెఫ్ తో, కస్టమ్ రకాల నిర్వచించు
మేము ఒక నిర్మాణం నిర్వచించే మరియు ఈ వంటి నిర్మాణం నిర్వచించే టైప్ చేయండి.
struct sllist tyepdef, ఆపై నేను ఉన్నాను ఏకపక్ష ఇక్కడ పదం విలువ ఉపయోగించి
నిజంగా ఏ డేటా రకం సూచించడానికి.
మీరు, ఒక పూర్ణాంకం లేదా ఫ్లోట్ మోపుతారు మీరు మీకు కావలసిన సంసార కలిగి కాలేదు.
ఇది కేవలం పరిమితం కాదు పూర్ణ, లేదా అలాంటిదే ఏదైనా.
కాబట్టి విలువ కేవలం ఏకపక్ష ఉంది అప్పుడు డేటా రకం, మరియు ఒక పాయింటర్
ఒకే రకమైన మరొక నోడ్.
>> ఇప్పుడు, కొద్దిగా క్యాచ్ ఉంది ఇక్కడ ఒక నిర్మాణం నిర్వచించు
అది ఒక స్వీయ నిర్దేశకం నిర్మాణ.
నేను ఒక తాత్కాలిక కలిగి నా నిర్మాణం కోసం పేరు.
రోజు నేను ముగింపులో స్పష్టంగా కాల్ మీరు
SLL నోడ్, చివరికి కొత్తది నా రకము నిర్వచనము భాగంగా పేరు,
కానీ నేను SLL నోడ్ ఉపయోగించలేరు ఈ మధ్యలో.
కారణం ఉండటం, నేను కలిగి ఒక టైపు అని SLL నోడ్ రూపొందించినవారు
నేను ఇక్కడ ఈ చివరి పాయింట్ హిట్ వరకు.
అప్పటివరకు, నేను కలిగి మరొక మార్గం ఈ డేటా రకం పిలిచేది.
>> మరియు ఈ ఒక స్వీయ నిర్దేశకం డేటా రకం.
ఇది; ఒక ఒక డేటా రకం ఏమిటి ఒక డేటా కలిగి నిర్మాణం,
మరియు మరొక ఒక పాయింటర్ ఒకే రకమైన నిర్మాణం.
నేను సూచించడానికి ఉండాలి ఈ డేటాను రకం కనీసం తాత్కాలికంగా,
కాబట్టి అది ఒక తాత్కాలిక ఇవ్వడం struct sllist పేరు
నాకు అప్పుడు నేను ఒక అనుకుందాం అనుమతిస్తుంది మరొక struct sllist పాయింటర్,
ఒక struct sllist స్టార్, మరియు అప్పుడు నేను నిర్వచనం పూర్తి చేసిన తర్వాత,
నేను ఇప్పుడు ఈ రకం ఒక SLL నోడ్ కాల్ చేయవచ్చు.
>> మీరు అక్కడ చూడండి వై తద్వారా ఇక్కడ ఒక తాత్కాలిక పేరు,
కానీ ఇక్కడ శాశ్వత పేరు.
కొన్నిసార్లు మీరు చూడవచ్చు నిర్మాణం నిర్వచనాలు
ఉదాహరణకు, ఆ కాదు స్వీయ నిర్దేశకం, ఆ
ఇక్కడ ఒక నిర్దేశకాన్ని పేరు లేదు.
ఇది కేవలం, typedef struct చెబుతా వంకర కలుపు తెరిచి, ఆపై నిర్వచించారు.
మీరు అయితే struct నేనే ఉంది నిర్దేశకం, ఈ ఒకటి గా,
మీరు ఒక పేర్కొనాలి తాత్కాలిక రకం పేరు.
కానీ చివరికి, ఇప్పుడు మేము ఈ పని చేసిన
మేము కేవలం సూచించవచ్చు ఈ నోడ్స్, ఈ యూనిట్లు,
ప్రయోజనాల కోసం SLL నోడ్స్ గా ఈ వీడియో మిగిలిన.
>> All right, కాబట్టి మేము ఎలా తెలుసు ఒక లింక్ జాబితా నోడ్ సృష్టించడానికి.
మేము ఎలా నిర్వచించాలి తెలుసు ఒక లింక్ జాబితా నోడ్.
ఇప్పుడు, మేము ఆరంభమవుతుంది చేస్తున్నారు ఉంటే సమాచారం సేకరించడానికి వాటిని ఉపయోగించి,
కార్యకలాపాల ఒక జంట ఉంది మేము అర్థం మరియు పని అవసరం.
మేము ఎలా సృష్టించాలో తెలుసుకోవాలి సన్నని గాలి బయటకు ఒక లింక్ జాబితా.
ఏ జాబితా ఇప్పటికే ఉంది ఉంటే, మేము ఒక ప్రారంభం కావాలి.
కాబట్టి మేము సామర్థ్యం ఉండాలి ఒక లింక్ జాబితా సృష్టించడానికి,
మేము బహుశా అన్వేషణ అవసరం లింక్ జాబితా ద్వారా
మేము చూస్తున్న ఒక మూలకం కనుగొనేందుకు.
మేము ఇన్సర్ట్ చెయ్యలేరు అవసరం జాబితాలో కొత్త విషయాలు,
మేము మా జాబితాలో పెరుగుతాయి చెయ్యగలరు అనుకుంటున్నారా.
మరియు అలాగే, మేము సామర్థ్యం ఉండాలనుకుంటున్నాను మా జాబితా నుండి విషయాలు తొలగించడానికి,
మేము మా జాబితాలో కుదించే చెయ్యగలరు అనుకుంటున్నారా.
మరియు చివరలో మా కార్యక్రమాలు, ముఖ్యంగా
మీరు మేము ఉన్నాము గుర్తుకు డైనమిక్ మెమరీ పెడుతోంది
సాధారణంగా ఈ జాబితాలు నిర్మించడానికి, మేము ఆ మెమరీ అన్ని ఉచిత మీరు
మేము అది పని పూర్తి చేసినప్పుడు.
కాబట్టి మేము ఒక తొలగిస్తే ఉండాలి ఒక మొత్తం లింక్ జాబితా మారండి విఫలం.
కాబట్టి యొక్క వీలు ఈ కార్యకలాపాలను కొన్ని
మరియు మేము వాటిని ఊహించడానికి ఎంతమేరకు, ప్రత్యేకంగా pseudocode కోడ్ లో మాట్లాడటం.
కాబట్టి మేము ఒక సృష్టించడానికి కావలసిన లింక్ జాబితా, కాబట్టి బహుశా మేము
ఒక ఫంక్షన్ నిర్వచించే అనుకుంటుంది ఈ నమూనా తో.
SLL నోడ్ స్టార్, సృష్టించడానికి, మరియు నేను ప్రయాణిస్తున్న నేను ఒక వాదన, కొన్ని ఏకపక్ష డేటా
కొన్ని ఏకపక్ష డేటా రకం, మళ్ళీ టైప్ చేయండి.
కానీ నేను ఈ ఫంక్షన్ ఉండాలి returning-- చేస్తున్నాను ఒక ఒక్కొక్కటిగా, నాకు ఒక పాయింటర్ తిరిగి
లింక్ జాబితా నోడ్.
మళ్లీ, మేము సృష్టించడానికి ప్రయత్నిస్తున్న సన్నని గాలి బయటకు ఒక లింక్ జాబితా
కాబట్టి నేను ఒక పాయింటర్ చేయాలి నేను పూర్తయింది ఉన్నప్పుడు జాబితా.
>> ఇక్కడ చేరి దశలు ఏవి?
Well, నేను మొదటి విషయం ఉన్నాను చేయబోవడం డైనమిక్ ఉంది
ఒక కొత్త నోడ్ స్థలాన్ని కేటాయించాలని.
మళ్లీ, మేము సన్నని దాన్ని సృష్టిస్తున్నారు గాలి, కాబట్టి మేము అది కోసం malloc స్పేస్ అవసరం.
మరియు కోర్సు యొక్క, వెంటనే మేము malloc తర్వాత,
మేము ఎల్లప్పుడూ నిర్ధారించుకోండి తనిఖీ మా పాయింటర్ మేము తిరిగి శూన్య రాలేదు.
మేము ప్రయత్నించండి ఉంటే ఎందుకంటే ఒక నల్ పాయింటర్ గౌరవం,
మేము ఒక బాధలు చూడాలని segfault మరియు మేము ఆ వద్దు.
>> అప్పుడు మేము రంగంలో పూరించడానికి కావలసిన మేము విలువ రంగంలో ప్రారంభించడం కావలసిన
మరియు తదుపరి రంగంలో ప్రారంభించడం.
మరియు తర్వాత మేము చివరికి అనుకుంటే మేము కావలసిన indicates-- చర్య నమూనా
ఒక SLL నోడ్ ఒక పాయింటర్ తిరిగి.
సో వాట్ ఈ దృష్టి కనిపిస్తుంది చేయడానికి?
బాగా, మొదటి మేము డైనమిక్ చూడాలని ఒక కొత్త SLL నోడ్ స్థలాన్ని కేటాయించాలని,
కాబట్టి మేము ఆ malloc-- ఒక దృశ్య ప్రాతినిధ్యం
నోడ్ యొక్క మనం కేవలం సృష్టించింది.
మరియు మేము నిర్ధారించుకోండి అది ఈ సందర్భంలో శూన్య కాదు
చిత్రాన్ని ఉండదనే అది శూన్య ఉంటే అప్ చూపిన,
మేము మెమరీ రన్నవుట్ ఉండేది కాబట్టి మేము అక్కడ అన్నిటికి ఉన్నాము.
కాబట్టి ఇప్పుడు మేము సి అడుగు లో ఉన్నారు, నోడ్స్ విలువ రంగంలో ప్రారంభించడం.
Well, ఈ ఫంక్షన్ ఆధారంగా నేను ఇక్కడ ఉపయోగించి వెబ్ కాల్
నేను 6 లో పాస్ కావలసిన కనిపిస్తోంది, నేను విలువ రంగంలో 6 చేస్తాము.
ఇప్పుడు, తదుపరి రంగంలో ప్రారంభించడం.
బాగా, నేను అక్కడ వెళ్ళిపోతున్నాను, ఏమీ కుడి, తదుపరి ఉంది,
ఈ జాబితాలో మాత్రమే విషయం.
కాబట్టి జాబితా తదుపరి విషయం ఏమిటి?
>> ఇది కుడి, ఏదైనా పాయింటు ఉండకూడదు.
ఏమీ కాబట్టి ఏమిటి, వేరే అక్కడ మనకు తెలుసు భావన ఏమీ వార్తలు
ఏమీ గమనికలు?
ఇది బహుశా మేము కావలసిన ఉండాలి అక్కడ ఒక నల్ పాయింటర్ చాలు,
మరియు నేను శూన్య ప్రాతినిధ్యం చేస్తాము , అంతే ఎరుపు బాక్స్ గణితానికి
మేము ఏ మరింత వెళ్ళి కాదు.
మేము తరువాత కొద్దిగా చూస్తారు వంటి, మేము చివరికి అలిస్ ఉంటుంది
బాణాలు యొక్క కనెక్ట్ కలిసి ఈ నోడ్స్,
కానీ మీరు కొట్టాడు ఎరుపు బాక్స్, ఆ శూన్య
మేము ఏ మరింత వెళ్ళి కాదు ఆ జాబితాలో ముగింపు ఉంది.
>> చివరికి, మేము కేవలం కావలసిన ఈ నోడ్ ఒక పాయింటర్ తిరిగి.
కాబట్టి మేము కొత్త కాల్ చేస్తాము మరియు కొత్త చేరుకుంటాయి
కాబట్టి అది ఉపయోగించవచ్చు సంసార ఫంక్షన్ రూపొందించినవారు.
సో అక్కడ మేము వెళ్ళి, మేము ఒక ఒక్కొక్కటిగా సృష్టించాను సన్నని గాలి బయటకు లింక్ జాబితా నోడ్,
మరియు ఇప్పుడు మేము పని చేయవచ్చు జాబితా.
>> ఇప్పుడు, ఆల్రెడీ మేము చెప్పటానికి వీలు ఒక పెద్ద గొలుసు కలిగి,
మరియు మేము అది ఏదో కావలసిన.
మరియు మేము వెళుతున్న ఒక ఫంక్షన్ అనుకుంటున్నారా నిజమైన లేదా తప్పుడు తిరిగి బట్టి
ఒక విలువ ఆ జాబితాలో ఉందో లేదో న.
ఒక ఫంక్షన్ నమూనా, లేదా ఆ ఫంక్షన్ కోసం డిక్లరేషన్,
దీన్ని కనుగొనేందుకు bool కనిపిస్తుంది, మరియు ఉండవచ్చు అప్పుడు మేము రెండు వాదనలు లో పాస్ కావలసిన.
>> మొదటి, ఒక పాయింటర్ ఉంది లింక్ జాబితా యొక్క మొదటి మూలకం.
ఈ మీరు చేస్తాము నిజానికి ఏదో ఉంది ఎల్లప్పుడూ ట్రాక్ ఉంచాలని,
మరియు నిజానికి ఏదో కావచ్చు మీరు కూడా ఒక ప్రపంచ వేరియబుల్ చాలు.
మీరు జాబితా సృష్టించడానికి, ఎల్లప్పుడూ ఎల్లప్పుడూ మీరు,
చాలా ట్రాక్ కావలసిన జాబితా యొక్క మొదటి మూలకం.
మీరు అన్ని ఇతర సూచించడానికి ఆ విధంగా కేవలం గొలుసు అనుసరించడం ద్వారా అంశాలు,
గమనికలు ఉంచడానికి చేయకుండా ప్రతి మూలకం చెక్కుచెదరకుండా.
మీరు మాత్రమే మొదటి ట్రాక్ అవసరం ఒక వారందరూ కలసి బంధించబడి ఉంటే.
>> ఆపై రెండో విషయం మేము మళ్ళీ అక్కడ చేస్తున్నారు
ఏకపక్ష some-- ఉంది సంసార డేటా రకం మనం ఉన్నాము
అక్కడ వెతుకుతున్న లోపల ఆశాజనక జాబితాలో నోడ్లు ఒకటి.
కాబట్టి దశలను ఏవి?
Well, మేము మొదటి విషయం ఉంది మేము ఒక దిక్కుకు ఫిరంగిని త్రిప్పుట పాయింటర్ సృష్టించడానికి
జాబితాలు తల ఎత్తి చూపుతుంది.
Well, ఎందుకు ఆ, మేము ఇప్పటికే మేము చేస్తారు జాబితాలు తల వద్ద ఒక పాయింటర్ కలిగి,
ఎందుకు మేము చుట్టూ ఒక తరలించడానికి లేదు?
Well, నేను కేవలం అన్నారు, ఇది మాకు నిజంగా ముఖ్యం
ఎల్లప్పుడూ ట్రాక్ జాబితాలో మొట్టమొదటి మూలకం.
మరియు కనుక ఇది నిజానికి ఉత్తమం ఆ నకిలీ సృష్టించడానికి,
అందువలన మేము ఎప్పుడూ చుట్టూ తరలించడానికి ఆ ఉపయోగించడానికి అనుకోకుండా దూరంగా తరలించడానికి, లేదా ఎల్లప్పుడూ మేము
అని కొన్ని పాయింట్ వద్ద ఒక పాయింటర్ కలిగి కుడివైపు జాబితా యొక్క మొదటి మూలకం.
కనుక ఇది ఒక సృష్టించడానికి ఉత్తమం మేము తరలించడానికి ఉపయోగించే రెండవది.
>> అప్పుడు మేము కేవలం లేదో సరిపోల్చండి ఆ నోడ్ వద్ద విలువ రంగంలో
అది ఉంటే మేము వెతుకుతున్న, మరియు ఏమి ఉంది లేదు, మేము కేవలం తదుపరి నోడ్ తరలించడానికి.
మరియు మేము ఆ పనిని పైగా, మరియు పైగా మరియు పైగా,
మేము గాని కనుగొనేందుకు వరకు మూలకం, లేదా మేము హిట్
శూన్య మేము ముగింపు చేరుకున్నారు మరియు జాబితాలో లేదు.
ఈ ఆశాజనక ఒక గంట మోగించిన ఉండాలి మీరు కేవలం సరళ శోధన,
మేము కేవలం అది పునరావృత్తం చేస్తున్నారు ఒక ఒక్కొక్కటిగా లింక్ జాబితా నిర్మాణం
బదులుగా దీన్ని వ్యూహం ఉపయోగించి.
>> ఇక్కడ ఒక ఉదాహరణ ఉంది ఒక ఒక్కొక్కటిగా లింక్ జాబితా.
ఈ ఒక కలిగి అయిదు శోషగ్రంధులు, మరియు మేము కలిగి
యొక్క తల ఒక పాయింటర్ జాబితా అని పిలుస్తారు జాబితా.
మేము చేయాలనుకుంటున్నారా మొదటి విషయం మళ్ళీ, ఆ ట్రావెర్సల్ పాయింటర్ సృష్టించడానికి.
కాబట్టి మేము ఇప్పుడు రెండు పాయింటర్లు కలిగి అదే విషయం ఆ పాయింట్.
>> ఇప్పుడు, కూడా ఇక్కడ గమనించవచ్చు నేను కాదు trav కోసం ఖాళీ malloc ఉంటుంది.
నేను trav malloc సమానం అనలేదు ఏదో, ఆ నోడ్ ఇప్పటికే ఉనికిలో
మెమరీ ఆ స్థలం ఇప్పటికే ఉనికిలో ఉంది.
నేను నిజానికి అంతా చేసేది ఉంది అది మరొక పాయింటర్ సృష్టిస్తుంది.
నేను ఒక అదనపు mallocing కాదు స్పేస్, ఇప్పుడు రెండు పాయింటర్లు కలిగి
ఇదే సూచించే.
>> సో 2 నేను చూస్తున్నాను ఏమి ఉంది?
ఏ, బాగా, కాబట్టి బదులుగా నేను ఉన్నాను తదుపరి తరలించడానికి వెళుతున్న.
కాబట్టి ప్రాథమికంగా నేను చెబుతా trav తదుపరి trav సమానం.
నాకు, చూస్తున్నాను ఏమి 3.
నేను వెళ్ళడానికి కొనసాగుతుంది ద్వారా, చివరికి వరకు
నేను చూస్తున్నాను ఏమి ఉంది 6 చెయ్యడానికి ఫంక్షన్ కాల్ ఆధారంగా కోసం
నేను పైన అక్కడ, మరియు నేను పూర్తయింది.
>> ఇప్పుడు, మూలకం నేను ఏమి ఉన్నాను ఉంటే కోసం చూస్తూ, జాబితాలో లేరు
ఇది ఇప్పటికీ పని అన్నారు?
Well, జాబితా గమనించవచ్చు ఇక్కడ, మార్మికంగా భిన్నంగా ఉంటుంది
మరియు ఈ మరొక విషయం లింక్ జాబితాలు ముఖ్యమైన,
మీరు సంరక్షించేందుకు లేదు వాటిని ఏ నిర్దిష్ట క్రమంలో.
మీరు అనుకుంటే మీరు, కాని మీరు ఇప్పటికే గమనించి ఉండవచ్చు
మేము పర్యవేక్షించడం చేస్తున్నట్లు మేము ఏ నెంబర్ మూలకం వద్ద ఉన్నాయి.
>> మరియు ఒక వాణిజ్యం విధమైన అని మేము శ్రేణుల శ్లోకాలు లింక్ జాబితాను కలిగి,
మేము కలిగి లేదు ఇకపై రాండమ్ యాక్సెస్.
మేము కేవలం నేను కావలసిన, చెప్పలేను 0th మూలకం వెళ్ళడానికి,
లేదా నా శ్రేణి యొక్క 6 వ మూలకం, ఇది నేను ఒక అర్రే లో చేయవచ్చు.
నేను వెళ్ళడానికి అనుకుందాం కాదు 0th మూలకం, లేక 6 మూలకం,
లేదా నా లింక్ జాబితా 25th మూలకం, వాటికి సంబంధించిన ఏ ఇండెక్స్ ఉంది.
మరియు కనుక ఇది నిజంగా ప్రాధాన్యత లేదు మేము మా జాబితా సంరక్షించేందుకు ఉంటే.
మీరు అనుకొంటే ఖచ్చితంగా, కానీ ఉంది
వారు అవసరం ఎందుకు ఎటువంటి కారణం ఏ క్రమంలో సంరక్షించవచ్చు.
మరలా, యొక్క ప్రయత్నించండి తెలియజేయండి మరియు ఈ జాబితాలో 6 కనుగొనేందుకు.
Well, మేము వద్ద మొదలు ప్రారంభంలో, మేము, 6 కనుగొనేందుకు లేదు
ఆపై మేము కనుగొనడంలో కాదు కొనసాగిస్తాయి 6, మేము చివరికి ఇక్కడ వచ్చేవరకు.
నోడ్ కాబట్టి ప్రస్తుతం trav పాయింట్లు 8 కలిగి, మరియు ఆరు అక్కడ లేదు.
>> సో తదుపరి అడుగు తదుపరి పాయింటర్ వెళ్ళడానికి,
కాబట్టి trav తదుపరి trav సమానం చెప్పడానికి.
Well, trav తదుపరి ద్వారా సూచించిన అక్కడ ఎరుపు బాక్స్, NULL.
కాబట్టి ఇంకెక్కడా ఉంది ఈ సమయంలో అలా వెళ్ళి, మరియు
మేము చేరుకున్నారు నిర్ధారించారు చేయవచ్చు లింక్ జాబితా ముగింపు,
మరియు 6 అక్కడ లేదు.
మరియు అది తిరిగి అవుతుంది ఈ సందర్భంలో తప్పుడు.
>> OK, ఎలా మేము ఒక కొత్త ఇన్సర్ట్ చెయ్యాలి లింక్ జాబితా నోడ్?
కాబట్టి మేము సృష్టించడానికి చేయగలిగారు చేసిన ఎక్కడా నుండి ఒక లింక్ జాబితా
కానీ మేము బహుశా కావలసిన ఒక గొలుసు నిర్మించడానికి మరియు లేదు
విభిన్న జాబితాలు ఒక సమూహం సృష్టించడానికి.
మేము ఒక జాబితా కలిగి కావలసిన అది నోడ్స్ యొక్క బంచ్ ఉంది
ఒకే నోడ్ తో జాబితాలు ఒక సమూహం.
కాబట్టి మేము కేవలం సృష్టించు ఉపయోగించి ఉంచకూడదు ఫంక్షన్ మేము ఇప్పుడు ముందు నిర్వచించబడిన మేము
ఒక ఇన్సర్ట్ మీరు ఇప్పటికే ఉనికిలో జాబితా.
>> ఈ కేసు కాబట్టి, మేము వెళుతున్న రెండు వాదనలు లో పాస్,
ఆ తల పాయింటర్ మేము జోడించండి కావలసిన లింక్ జాబితా.
అది అలా ఎందుకు తిరిగి, ఆ ముఖ్యమైన ఎల్లప్పుడూ మేము ఆ
ఎందుకంటే, అది ట్రాక్ ఇది నిజంగా మాత్రమే మార్గం మేము వార్తలు
మొత్తం జాబితా సూచించడానికి కలిగి కేవలం మొదటి మూలకం ఒక పాయింటర్.
కాబట్టి మేము ఒక లో పాస్ కావలసిన మొదటి అంశానికి పాయింటర్,
మరియు సంసార విలువ మేము జాబితాకు జోడించడానికి అనుకుంటున్నారా.
చివరకు ఈ ఫంక్షన్ ఒక పాయింటర్ తిరిగి అన్నారు
ఒక లింక్ జాబితా కొత్త తల.
>> ఇక్కడ చేరి దశలు ఏమిటి?
అయితే, నువ్వు సృష్టించడానికి తో వంటి, మేము డైనమిక్ కేటాయించాల్సిన అవసరం
ఒక కొత్త నోడ్ స్థలాన్ని, మరియు చేయడానికి తనిఖీ ఖచ్చితంగా మేము మెమరీ రన్నవుట్ లేదు, మళ్ళీ,
మేము malloc ఉపయోగించి ఉన్నందున.
అప్పుడు మేము జనసాంద్రత కావలసిన మరియు, నోడ్ ఇన్సర్ట్
కాబట్టి జగిత్యాల, సంసార Val నోడ్ లోకి, ఉంది.
మేము వద్ద నోడ్ ఇన్సర్ట్ లింక్ జాబితా ప్రారంభం.
>> ఒక కారణం ఉంది అని నేను దీన్ని చేయాలనుకుంటున్నారా, మరియు అది
ఒక రెండవ తీసుకొని విలువ కావచ్చు ఇక్కడ వీడియోకు విరామము,
మరియు నేను ఎందుకు కావాలో గురించి ఆలోచించడం ఒక లింక్ ప్రారంభంలో ఇన్సర్ట్
జాబితా.
మళ్ళీ, నేను ముందు పేర్కొన్న అది నిజంగా కాదు ఆ
మేము ఏ లో దానిని పరిరక్షించడం ఉంటే పట్టింపు ఆర్డర్, కాబట్టి బహుశా ఒక క్లూ ఉంది.
మరియు మీరు మేము ఉంటే జరుగుతుంది ఏమి చూసిన కావలెను ఆలోచన లేదా కేవలం ఒక రెండవ నుండి
క్రితం మేము ఉండేవి శోధన ద్వారా మీరు
ఏమి కావచ్చు చూడగలిగారు మేము ప్రయత్నిస్తున్న ఉంటే జరిగే
జాబితా చివరిలో ఇన్సర్ట్ చెయ్యడానికి.
మేము ఒక కలిగి లేదు ఎందుకంటే జాబితా చివర పాయింటర్.
>> సో కారణం నేను సాహసించరు ప్రారంభంలో ఇన్సర్ట్,
నేను వెంటనే దీన్ని ఎందుకంటే ఉంది.
నేను ప్రారంభంలో ఒక పాయింటర్ కలిగి, మరియు మేము రెండవ లో ఒక దృశ్య లో ఈ చూస్తారు.
కానీ నేను చివరిలో ఇన్సర్ట్ అనుకుంటే, నేను ప్రారంభంలో ప్రారంభించడానికి కలిగి
అన్ని మార్గం సంచరిస్తారు ముగింపు, మరియు అప్పుడు దానిపై టాక్.
కాబట్టి ఆ అర్థం జాబితా చివరిలో ఇన్సర్ట్
n యొక్క O అవుతాడని ఆపరేషన్, వెళుతున్నారు
మా చర్చ గణన సంక్లిష్టత.
అది n ఆపరేషన్ పేరు ఒక O మారింది కావలసిన జాబితా కంటే పెద్దది, మరియు పెద్ద వచ్చింది,
మరియు పెద్ద, అది మరింత మారింది చేస్తాము మరియు ఏదో టాక్ మరింత కష్టం
చివరిలో.
కానీ ఎప్పుడూ నిజంగా సులభం ప్రారంభంలో ఏదో టాక్,
మీరు ప్రారంభంలో ఎప్పుడూ ఉన్నాము.
>> మరియు మేము మళ్ళీ ఈ ఒక దృశ్య చూస్తారు.
ఆపై మేము ఒకసారి పూర్తి చేసిన తర్వాత మేము కొత్త నోడ్ చేర్చబడ్డ చేసిన,
మేము మా పాయింటర్ తిరిగి అనుకుంటున్నారా ఒక లింక్ జాబితా కొత్త తల, ఇది
మేము వద్ద ఇన్సర్ట్ ఉన్నందున ప్రారంభించి, నిజానికి ఉంటుంది
మేము కేవలం రూపొందించినవారు నోడ్ ఒక పాయింటర్.
, యొక్క ఈ ఊహించడానికి లెట్ ఎందుకంటే నేను సహాయం నేను భావిస్తున్నాను.
>> కాబట్టి ఇక్కడ మా జాబితాలో, అది కలిగి నాలుగు మూలకాలను ఒక నోడ్, 15 కలిగి
ఇది ఒక నోడ్ పాయింట్లు , 9 కలిగి దీనిలో
13 కలిగిన నోడ్ పాయింట్లు, ఇది కలిగిన నోడ్ పాయింట్లు
శూన్య కలిగిన 10, దాని తదుపరి పాయింటర్ వంటి పాయింటర్
కాబట్టి ఆ జాబితాలో ముగింపు ఉంది.
కాబట్టి మేము ఒక ఇన్సర్ట్ అనుకుంటే విలువ 12 తో కొత్త నోడ్
ఈ ప్రారంభంలో జాబితా మేము ఏమి చేస్తారు?
Well, మొదటి మేము స్థలాన్ని malloc నోడ్, మరియు అప్పుడు మేము అక్కడ 12 చాలు.
>> కాబట్టి ఇప్పుడు మేము చేరుకున్న నిర్ణయం పాయింట్, కుడి?
మేము ఒక జంట కలిగి గమనికలు మేము అని
మేము మొదటి ఒక కదలాలని తరలించడానికి?
మేము 12 పాయింట్ చేయాలి జాబితా యొక్క కొత్త తల
లేదా నాకు మన్నించు, మేము 12 చేయాలి జాబితా యొక్క పాత తల అభిప్రాయపడుతున్నారు?
లేదా మేము అని చెప్పాలి జాబితా ఇప్పుడు 12 వద్ద ప్రారంభమవుతుంది.
ఒక తేడా ఉంది అక్కడ, మరియు మేము పరిశీలిస్తాము
రెండు రెండవ లో ఏమి వద్ద.
>> కానీ ఈ ఒక దారితీస్తుంది సైడ్బార్ కోసం గొప్ప విషయం,
సదరు ఒకటి లింక్ జాబితాలు trickiest విషయాలు
గమనికలు ఏర్పాట్లు ఉంది సరైన క్రమంలో.
మీరు క్రమంలో విషయాలు బయటకు తరలిస్తే, మీరు అనుకోకుండా అవుతుంది
జాబితా మిగిలిన అనాధల.
మరియు ఇక్కడ ఒక ఉదాహరణ ఉంది.
కాబట్టి యొక్క ఆలోచన వీడలేదు of-- బాగా, మేము 12 సృష్టించాను.
మేము 12 అవతరిస్తుంది తెలుసు జాబితా కొత్త తల,
కాబట్టి మనం కేవలం తరలించడానికి లేదు జాబితా పాయింటర్ అభిప్రాయపడుతున్నారు.
>> OK, కాబట్టి బావుంటుంది.
కాబట్టి ఇప్పుడు ఇక్కడ 12 తదుపరి పాయింట్ ఉందా?
నేను దృష్టి మేము చూడగలరు ఉద్దేశ్యం అది 15 కు ఆకర్షిస్తాయి,
మానవులు దానిని నిజంగా మాకు స్పష్టమైన ఉంది.
కంప్యూటర్ తెలుసు?
మేము ఏదైనా కలిగి లేదు ఇకపై 15 గురిపెట్టి, కుడి?
>> మేము 15 సూచించడానికి ఏ సామర్థ్యం కోల్పోయి.
మేము కొత్త బాణం తర్వాత సమానం చెప్పలేను ఏదో, అక్కడ ఏమీ లేదు.
నిజానికి, మేము అనాథ చేసిన జాబితా మిగిలిన
ఇలా చేయడం వలన, మేము చేసిన అనుకోకుండా గొలుసు అనువదించబడింది.
మరియు మేము ఖచ్చితంగా ఆ చేయాలనుకుంటున్నారా లేదు.
>> కాబట్టి యొక్క తిరిగి వెళ్ళి మళ్ళీ ఈ ప్రయత్నించండి తెలియజేయండి.
బహుశా కుడి పనిని చేయడానికి 12 యొక్క తదుపరి పాయింటర్ సెట్ ఉంటుంది
మొదటి జాబితాలో పాత తల, అప్పుడు మేము జాబితా పై తరలించవచ్చు.
నిజానికి, ఆ సరైన క్రమంలో మేము ఆ
మేము ఉన్నప్పుడు అనుసరించండి అవసరం ఒక్కొక్కటిగా లింక్ జాబితాను పని.
మేము ఎల్లప్పుడూ కనెక్ట్ అనుకుంటున్నారా జాబితాలో కొత్త మూలకం
మేము ఆ రకమైన పడుతుంది ముందు మారుతున్న ముఖ్యమైన దశ
పేరు లింక్ జాబితా అధినేత.
మళ్ళీ, అలాంటి ఒక ప్రాథమిక విషయం, మేము అది ట్రాక్ కోల్పోతారు చెయ్యకూడదని.
>> కాబట్టి మేము ఆ నిర్ధారించుకోవాలి ప్రతిదీ కలిసి బంధించబడి ఉంది
ఆ పాయింటర్ తరలించడానికి ముందు.
కాబట్టి ఈ సరైన క్రమంలో ఉంటుంది, ఇది జాబితాకు 12 కనెక్ట్,
ఆపై జాబితా 12 మొదలవుతుంది చెప్తారు.
మేము జాబితా 12 వద్ద మొదలవుతుంది అన్నారు మరియు అప్పుడు జాబితాకు 12 కనెక్ట్ ప్రయత్నించారు
మేము ఇప్పటికే ఏమి చూసిన.
మేము పొరపాటున జాబితా కోల్పోతారు.
>> OK, కాబట్టి ఒక మరింత విషయం గురించి మాట్లాడటానికి.
మనం వదిలించుకోవటం కావాలా మొత్తం ఒకేసారి జాబితా లింక్?
మళ్లీ, మేము mallocing చేస్తున్నారు అన్ని ఈ స్థలం, అందువలన మేము
మేము పూర్తి చేసినప్పుడు ఇది ఉచితం చేయాలి.
కాబట్టి ఇప్పుడు మేము తొలగించాలనుకుంటున్నారా మొత్తం లింక్ జాబితా.
Well, మేము ఏమి అనుకుంటున్నారు?
>> మేము నల్ పాయింటర్ చేరుకున్నారు ఉంటే, మేము లేకపోత కేవలం తొలగించండి, మీరనుకుంటున్నారు
అప్పుడు జాబితా మిగిలిన మరియు నాకు విముక్తికై.
జాబితా మిగిలిన తొలగించండి ఆపై ప్రస్తుత నోడ్ విడిపించేందుకు.
వంటి ధ్వని చేస్తుంది ఏమిటి, ఱేపట్నుంచీ మేము మాట్లాడారు
గురించి గతంలో వంటి ధ్వని చేస్తుంది?
అప్పుడు, ప్రతి ఒక్కరినీ తొలగించు తిరిగి వచ్చి నన్ను తొలగించండి.
>> ఆ సూత్రం వార్తలు, మేము చేసిన కొద్దిగా చిన్న సమస్య,
మేము ప్రతి ఒక్కరి తొలగించడానికి చెబుతున్న ఎల్స్, అప్పుడు మీరు నాకు తొలగించవచ్చు.
మరియు మరింత రోడ్ డౌన్, ఆ నోడ్ ప్రతి ఒక్కరినీ తొలగించండి చెబుతాను.
కానీ చివరికి మేము పొందుతారు జాబితా శూన్య బిందువు,
మరియు మా బేస్ కేస్.
>> కాబట్టి యొక్క ఈ పరిశీలించి తీసుకుందాం, మరియు ఈ పని ఎలా.
ఇక్కడ మా జాబితా, ఇది సేమ్ మేము కేవలం గురించి మాట్లాడుతూ జాబితా
మరియు దశలను ఉంది.
టెక్స్ట్ చాలా ఇక్కడ ఉంది, కానీ ఆశాజనక విజువలైజేషన్ సహాయం చేస్తుంది.
>> కాబట్టి మేము మనం మరియు నేను కూడా లాగి మా స్టాక్ ఫ్రేములు దృష్టాంతం అప్
కాల్ స్టాక్స్ మా వీడియో నుండి మరియు ఆశాజనక ఈ అన్ని
కలిసి జరగబోతోంది ఏమి మీరు చూపిస్తుంది.
ఇక్కడ మా pseudocode కోడ్ ఉంది.
మేము ఒక శూన్య చేరుకోవడానికి ఉంటే పాయింటర్, లేకపోతే, ఆపడానికి
జాబితా మిగిలిన తొలగించండి అప్పుడు ప్రస్తుత నోడ్ విడిపించేందుకు.
సో ఇప్పుడు, జాబితా మేము ఉన్నాము ఆ పాయింటర్
లో ప్రయాణిస్తున్న 12 పాయింట్లు నాశనం.
12 ఒక నల్ పాయింటర్ కాదు, కాబట్టి మేము ఉన్నాము జాబితా మిగిలిన తొలగించండి వెళుతున్న.
>> ఏం తొలగించడం ఉంది మాకు మిగిలిన చేరి?
సరే, ఒక తయారు అర్థం మాట్లాడుతూ, నాశనం కాల్
15 ఆ యొక్క ప్రారంభం మేము నాశనం కావలసిన జాబితా మిగిలిన.
కాబట్టి కాల్ నాశనం 12 హోల్డ్ న రకమైన ఉంది.
ఇది వేచి ఉన్నాయి స్తంభింప ఉంది దాని పని పూర్తి, 15 నాశనం కాల్.
>> Well, 15 ఒక నల్ పాయింటర్ కాదు, మరియు కాబట్టి అది చెప్పడానికి జరగబోతోంది, అన్ని కుడి,
బాగా, జాబితా మిగిలిన తొలగించండి.
జాబితా మిగిలిన మొదలవుతుంది 9, అందువలన మేము కేవలం చేస్తాము
మీరు అన్ని తొలగించే వరకు వేచి stuff, అప్పుడు తిరిగి వచ్చి నన్ను తొలగించండి.
బాగా 9 బాగా చెప్పడానికి జరగబోతోంది, నేను ఒక నల్ పాయింటర్ కాదు
కాబట్టి ఇక్కడ నుండి మిగిలిన జాబితా తొలగించండి.
కాబట్టి ప్రయత్నించండి మరియు 13 నాశనం.
13 నేను నల్ పాయింటర్ కాదు, చెప్పారు అదే విషయం, ఇది బక్ వెళుతుంది.
10, 10 నల్ పాయింటర్ కాదు ఒక నల్ పాయింటర్ కలిగి,
కానీ 10 స్వయంగా ఒక ఉంది శూన్య ప్రస్తుతం గణితానికి,
మరియు కనుక ఇది చాలా బక్ వెళుతుంది.
>> మరియు ఇప్పుడు, అక్కడ అది పాయింట్లు జాబితా నిజంగా some-- సూచించడానికి చేస్తుంది
నేను చిత్రం లో ఎక్కువ ఖాళీని కలిగి ఉంటే, ఇది కొన్ని యాదృచ్ఛిక స్పేస్ సూచించడానికి చేస్తుంది
మేము అది ఏమిటో తెలియదు.
ఇది అయితే నల్ పాయింటర్ వార్తలు, జాబితా అక్షరాలా ఇప్పుడు అది శూన్య విలువలు సెట్.
ఇది కుడి ఆ ఎర్ర బాక్స్ లోపల గురిపెట్టి ఉంది.
మేము అలా ఒక నల్ పాయింటర్ చేరుకుంది మేము ఆపడానికి, మరియు మేము పూర్తి చేసిన.
>> అందువలన, ఊదా ఫ్రేమ్ వద్ద ఇప్పుడు ఉంది క్రియాశీల ఫ్రేమ్ అని stack-- పైన,
కానీ అది పూర్తి అయిన.
మేము ఒక నల్ పాయింటర్ చేరుకున్నారు ఉంటే, ఆపడానికి.
మేము ఏదైనా చెయ్యమని మేము ఒక నల్ పాయింటర్ విడిపించేందుకు కాదు,
మేము ఏ malloc లేదు స్పేస్, మరియు కాబట్టి మేము పూర్తి చేసిన.
ఆ ఫంక్షన్ ఫ్రేమ్ కాబట్టి నాశనం, మరియు మేము ఉంది
మేము వదిలి పేరు resume-- మనం ఎంచుకొని తరువాత అత్యధిక ఒకటి, తో ఇది
ఇక్కడ ఈ ముదురు నీలం ఫ్రేమ్.
కనుక మేము వదిలి పేరు కుడి తీయటానికి.
మేము మిగిలిన తొలగించారు జాబితా ఇప్పటికే, కాబట్టి ఇప్పుడు మేము ఉన్నాము
ప్రస్తుత నోడ్స్ విముక్తికై జరగబోతోంది.
కాబట్టి ఇప్పుడు మేము ఇప్పుడు ఈ నోడ్ విడిపించేందుకు, మరియు మనం ఫంక్షన్ ముగింపు చేరుకున్నారు.
కాబట్టి ఆ ఫంక్షన్ ఫ్రేమ్, నాశనమవుతుంది మరియు మేము కాంతి నీలం ఒక వద్ద తీయటానికి.
>> కనుక ఇది నేను ఇప్పటికే సమయానికి చేసిన says-- , జాబితా మిగిలిన తొలగించడం కాబట్టి
ప్రస్తుత నోడ్ విడిపించేందుకు.
ఇప్పుడు పసుపు ఫ్రేమ్ తిరిగి స్టాక్ పైన.
మీరు చూడండి మరియు అందువలన మేము ఇప్పుడు ఉన్నాము కుడి నుండి జాబితా నాశనం ఎడమ.
>> ఏమి, అయితే, జరిగిన ఉండేది మేము విషయాలు తప్పు మార్గంలో చేసిన ఉంటే?
జస్ట్ మేము ప్రయత్నించినప్పుడు వంటి ఒక మూలకం జోడించడానికి.
మనం ఉంటే గొలుసు, గందరగోళంలో ఉంటే మేము గమనికలు కనెక్ట్ లేదు
సరైన క్రమంలో, మేము ఉంటే కేవలం మొదటి మూలకం విముక్తి
మేము కేవలం విముక్తి ఉంటే జాబితా యొక్క తల, ఇప్పుడు మేము
సూచించడానికి ఎటువంటి మార్గం లేని జాబితా మిగిలిన.
కాబట్టి మేము వుంటుంది అనాథ ప్రతిదీ
మేము ఏమి వచ్చేది మెమొరీ లీక్ అని.
మీరు మా వీడియో నుండి గుర్తు ఉంటే డైనమిక్ మెమరీ కేటాయింపు,
చాలా మంచి విషయం కాదు.
>> కాబట్టి నేను అక్కడ చెప్పారు అనేక కార్యకలాపాలు ఉంటాయి
మేము పని ఉపయోగించడానికి అవసరమైన సమర్థవంతంగా లింక్ జాబితా.
మరియు మీరు, నేను ఒక తొలగించిన గమనించి ఉండవచ్చు ఒక లింక్ నుండి ఒకే మూలకం తొలగించడం
జాబితా.
నేను చేసినవి కారణం నిజానికి రకంగా ఉంది
తొలగించడానికి ఎలా గురించి ఆలోచించడం గమ్మత్తైన ఒక ఒక్కొక్కటిగా నుండి ఒకే మూలకం
లింక్ జాబితా.
మేము పైగా దాటవేయడానికి ఉండాలి జాబితాలో ఏదో
మేము ఒక పాయింట్ మేము ను అర్థం ఈ నోడ్ తొలగించాలనుకుంటున్నారా
కానీ క్రమంలో మేము అది చేయడానికి ఏ సమాచారం కోల్పోతారు లేదు,
మేము ఈ కనెక్ట్ అవసరం ఇక్కడ పైగా నోడ్.
>> నేను బహుశా ఆ తప్పు చేసాడు ఒక దృశ్య కోణం నుండి.
కాబట్టి మేము ప్రారంభంలో ఉన్నారు మా జాబితా మేము ద్వారా సాగుతున్నాయి చేస్తున్నారు
మేము ఈ నోడ్ తొలగించాలనుకుంటున్నారా.
మేము దానిని తొలగిస్తే మేము గొలుసు విచ్ఛిన్నం చేసిన.
ఇక్కడే ఈ నోడ్ అన్నిటికీ సూచిస్తుంది,
అది ఇక్కడే నుండి గొలుసు కలిగి.
>> కాబట్టి మేము నిజానికి ఏమి చెయ్యాలో మేము ఈ పాయింట్ ను తర్వాత,
మేము ఒక తిరిగి అడుగు అవసరం, మరియు ఈ నోడ్ ఈ నోడ్ పైగా కనెక్ట్,
అందువలన మేము అప్పుడు తొలగించవచ్చు మధ్యలో ఒకటి.
కానీ ఒక్కొక్కటిగా లింక్ జాబితాలు లేదు మాకు వెనుకకు వెళ్ళడానికి ఒక మార్గాన్ని అందిస్తాయి.
కాబట్టి మేము గాని ఉంచడానికి అవసరం రెండు పాయింటర్లు, మరియు వాటిని తరలించడానికి
ఆఫ్ అడుగు విధమైన వెనుక ఒక ఇతర మేము వెళ్ళి, లేదా ఒక స్థానం పొందేవరకు
ఆపై ద్వారా మరొక పాయింటర్ పంపండి.
మరియు మీరు, అది చూడగలరు గా కొద్దిగా దారుణంగా పొందవచ్చు.
అదృష్టవశాత్తూ, మేము కలిగి మరొక మార్గం పరిష్కరించడానికి,
మేము ఎన్నటికీ లింక్ జాబితాలు గురించి మాట్లాడటానికి.
>> నేను డౌ లాయిడ్ ఉన్నాను, ఈ CS50 ఉంది.