>> [MUSIC ప్లే]
>> రాబ్ బౌడెన్: ఎక్కువ.
నేను రాబ్ ఉన్నాను.
మరియు యొక్క ఈ పరిష్కారం బయట.
కాబట్టి ఇక్కడ అమలు చూడాలని ఒక సాధారణ పట్టిక.
మేము చూడండి మా Struct నోడ్ పట్టిక ఇలా అన్నారు.
కనుక ఇది ఒక చార్ పదం కలిగి జరగబోతోంది పరిమాణం పొడవు + 1 శ్రేణి.
, + 1 మరువకండి నుండి గరిష్ట నిఘంటువులో పదాన్ని 45 ఉంది
అక్షరాలు.
మరియు తర్వాత మేము ఒక అదనపు అవసరం చూడాలని బాక్ స్లాష్ సున్నా పాత్ర.
>> ఆపై ప్రతి మా hashtable బకెట్ నిల్వ అన్నారు ఒక
ల లింక్ జాబితా.
మేము ఇక్కడ పరిశీలించకుండా సరళ చేయడం లేదు.
అందువలన క్రమంలో తదుపరి లింక్ బకెట్ లో మూలకం, మేము ఒక అవసరం
struct నోడ్ * తదుపరి.
OK.
కాబట్టి ఒక నోడ్ కనిపిస్తోంది ఉంది.
>> ఇప్పుడు ఇక్కడ ప్రకటన మా hashtable యొక్క.
ఇది 16.834 బకెట్లు కలిగి జరగబోతోంది.
కానీ ఆ సంఖ్య నిజంగా పట్టింపు లేదు.
చివరకు, మేము చూడాలని ప్రపంచ వేరియబుల్ hashtable పరిమాణం, ఇది
జీరోగా ఆఫ్ ఆరంభమవుతుంది.
మరియు అది ఎలా ట్రాక్ వెళుతున్న చాలా పదాలు మా నిఘంటువులో లో ఉన్నాయి.
>> కాబట్టి యొక్క లోడ్ పరిశీలించి వీలు.
లోడ్ గమనించండి, ఇది ఒక bool తిరిగి.
ఇది విజయవంతంగా ఉంటే మీరు నిజమైన తిరిగి లోడ్, మరియు తప్పుడు లేకపోతే.
మరియు అది, ఒక కాన్స్ట్ చార్ * నిఘంటువు పడుతుంది నిఘంటువు ఇది
మేము తెరవడానికి కావలసిన.
కాబట్టి ఆ మొదటి విషయం మేము చేయబోతున్నామని.
>> మేము fopen చూడాలని పఠనం కోసం నిఘంటువు.
మరియు మేము కలిగి చూడాలని విజయవంతమైంది నిర్ధారించుకోండి.
ఇది NULL తిరిగి కాబట్టి, అప్పుడు మేము కాదు విజయవంతంగా నిఘంటువు తెరవండి.
మరియు మేము తప్పుడు తిరిగి.
కానీ విజయవంతంగా అని ఊహిస్తూ ఓపెన్, అప్పుడు మేము చదవాలనుకుంటున్న
నిఘంటువు.
మేము కొన్ని కనుగొనేందుకు వరకు మళ్ళీ వెతికినా ఉంచడానికి ఈ లూప్ నుండి బ్రేక్ కారణం,
మేము చూస్తారు ఇది.
కాబట్టి మళ్ళీ వెతికినా ఉంచడానికి.
>> ఇప్పుడు మేము చూడాలని ఒక నోడ్ malloc.
మరియు కోర్సు యొక్క మేము అవసరం ప్రసారం చేయడానికి మళ్ళీ తనిఖీ.
కాబట్టి mallocing విజయవంతం కాలేదు, అప్పుడు మనం ఏ నోడ్ దించుతున్న మీరు
ముందు malloc జరిగింది, దగ్గరగా నిఘంటువు మరియు తప్పుడు తిరిగి.
కానీ ఆ విస్మరించి, ఊహిస్తూ మేము విజయం, అప్పుడు మేము fscanf ఉపయోగించడానికి
నుండి ఒకే పదం చదవడానికి మా మా నోడ్ నిఘంటువు.
కాబట్టి ఆ ప్రవేశం> పదం గుర్తు చార్ + 1 పరిమాణం LENGHTH మాట బఫర్
మేము సైన్ పదాన్ని నిల్వ చూడాలని
>> కాబట్టి fscanf కాలం, 1 తిరిగి అన్నారు ఇది వీలు విజయవంతంగా గా
ఫైలునుండి తెలియజేయండి.
లోపం గాని జరిగితే, లేదా మేము ఫైలు ముగింపు చేరుకోవడానికి, ఇది
1 తిరిగి కనిపిస్తుంది.
ఇది, 1 తిరిగి లేని సందర్భంలో మేము చివరకు బయటకు చూడాలని
ఈ సమయంలో లూప్.
కాబట్టి మేము, మేము విజయవంతంగా ఉంటాయి ఒక పదాన్ని చదవడానికి
ఎంట్రీ> పదం, తర్వాత ఆ చూడాలని మా హాష్ ఫంక్షన్ను ఉపయోగించి పదం.
>> యొక్క పరిశీలించి లెట్ హాష్ ఫంక్షన్ను.
కాబట్టి మీరు నిజంగా అవసరం లేదు ఈ అర్థం.
మరియు వాస్తవానికి మేము ఈ హాష్ లాగి ఇంటర్నెట్ నుండి పని.
మీరు గుర్తించడానికి అవసరం మాత్రమే విషయం ఈ ఒక కాన్స్ట్ చార్ * పదం పడుతుంది.
ఇది ఇన్పుట్ వంటి స్ట్రింగ్ తీసుకొని, మరియు అవుట్పుట్ ఒక Int సైన్ చేయని తిరిగి.
కాబట్టి అన్ని హాష్ విధి ఉంది, ఇది ఒక ఇన్పుట్ లో పడుతుంది మరియు మీరు ఒక ఇస్తుంది
hashtable సూచిక.
>> మేము NUM_BUCKETS ద్వారా Moding గమనించవచ్చు, కాబట్టి ఆ విలువ తిరిగి
నిజానికి hashtable ఒక సూచి ఉంది మరియు చేస్తుంది దాటి సూచిక
శ్రేణి యొక్క సరిహద్దులు.
కాబట్టి ఆ ఫంక్షన్, మేము చేయబోతున్నామని ఇచ్చిన మేము చదివే పదం హాష్తో
నిఘంటువు.
మరియు తర్వాత మేము ఉపయోగించడానికి వెళుతున్న ఇన్సర్ట్ హాష్
hashtable ప్రవేశం.
>> ఇప్పుడు hashtable హాష్ ప్రస్తుత ఉంది పట్టికలో లింక్ జాబితా.
మరియు అది చాలా అవకాశం ఇది కేవలం NULL అని.
మేము మా ఎంట్రీ ఇన్సర్ట్ ఈ లింక్ జాబితా ప్రారంభం.
కాబట్టి మేము మా ప్రస్తుత చూడాలని ఏమి hashtable ప్రపంచంలో ప్రవేశంగా
ప్రస్తుతం పాయింట్లు.
మరియు తర్వాత మేము, నిల్వ చూడాలని వద్ద hashtable లో
హాష్, ప్రస్తుత ఎంట్రీ.
కాబట్టి ఈ రెండు పంక్తులు విజయవంతంగా ఇన్సర్ట్ ప్రారంభంలో ఎంట్రీ
ఆ సూచిక వద్ద లింక్ జాబితా hashtable లో.
>> మేము పూర్తి చేసిన తర్వాత, మేము తెలుసు మేము మరొక పదం దొరకలేదు
నిఘంటువు, మరియు మేము తిరిగి పెంచడం.
కాబట్టి మేము చేస్తున్న కొనసాగించండి fscanf వరకు చివరకు వద్ద కాని 1 ఏదో తిరిగి
ఇది పాయింట్ గుర్తుంచుకోవాలి మేము ప్రవేశ అవసరం.
కాబట్టి ఇక్కడ మేము ఒక ఎంట్రీ malloced.
మరియు మేము ఏదో చదవడానికి ప్రయత్నించారని నిఘంటువు నుండి.
మరియు మేము విజయవంతంగా చదవలేదు లో నిఘంటువు నుండి ఏదో,
మేము ప్రవేశ విడిపించేందుకు అవసరం సందర్భంలో మేము నిజంగా ఉంచాలి ఎప్పుడూ
hashtable, మరియు చివరకు బ్రేక్.
>> మేము అధిగమిస్తే మేము చూడండి అవసరం, బాగా, మేము ఎందుకంటే అక్కడ పోగొట్టుకున్నారు
లోపం ఫైలు నుండి చదివిన?
లేదా మేము బయటకు ఎందుకంటే మేము ఫైల్ ముగింపు చేరుకున్నారు?
లోపం తరువాత, ఉంది ఉంటే మేము తప్పుడు తిరిగి అనుకుంటున్నారా.
లోడ్ విజయవంతం కాలేదు ఎందుకంటే.
ఈవిడ మేము దించుతున్న మీరు అన్ని మేము చదివే పదాలు, మరియు
నిఘంటువు ఫైలు దగ్గరగా.
>> మేము విజయం సాధించాడు ఊహించి తర్వాత మేము ఇప్పటికీ నిఘంటువు దగ్గరగా అవసరం
ఫైల్, మరియు చివరకు నిజమైన తిరిగి నుండి మేము విజయవంతంగా నిఘంటువు లోడ్.
మరియు ఆ లోడ్ కోసం ఇది.
కాబట్టి ఇప్పుడు, ఒక లోడ్ hashtable ఇచ్చిన, తనిఖీ ఇలా అన్నారు.
కాబట్టి ఇది, ఇది ఒక bool తిరిగి, తనిఖీ ఆమోదించింది అని సూచించడానికి అన్నారు
చార్ * పదం లో, లేదో జారీ స్ట్రింగ్ లో మా నిఘంటువులో లో ఉంది.
, నిఘంటువులో ఇది చేస్తే అది మా hashtable లో ఉంటే,
మేము నిజమైన తిరిగి ఉంటుంది.
ఇది కాదు ఉంటే, మేము తప్పుడు తిరిగి ఉంటుంది.
>> ఈ పదం జారీ ఇచ్చిన, మేము ఉన్నాము పదం హాష్ అన్నారు.
ఇప్పుడు గుర్తించడానికి ఒక ముఖ్యమైన విషయం లోడ్ మేము తెలుసు ఆ అన్ని
మేము తక్కువ కేసు మాత్రం పదాలు.
కానీ ఇక్కడ మేము ఖచ్చితంగా లేదు.
మేము మా హాష్ ఫంక్షన్ను పరిశీలించి ఉంటే, నిజానికి మా హాష్ ఫంక్షన్ను
తక్కువ పెట్ట ప్రతి పాత్ర పదం యొక్క.
కాబట్టి సంబంధం లేకుండా మూలధనీకరణ పదం, మా హాష్ ఫంక్షన్ను తిరిగి ఉంది
సంసార కోసం అదే ఇండెక్స్ క్యాపిటలైజేషన్ ఇది కలిగి ఉంటుంది, ఉంది
ఒక పూర్తిగా చిన్న కోసం తిరిగి పదం యొక్క ప్రతి.
ఆల్రైట్.
మా ఇండెక్స్ ఉంది ఈ పదం కోసం hashtable.
>> ఇప్పుడు లూప్ ఈ అన్నారు లింక్ జాబితా పై iterate
ఆ సూచిక వద్ద ఉంది.
కాబట్టి మేము ప్రవేశ ప్రారంభించడం గమనిస్తారు ఆ సూచిక సూచించడానికి.
మేము కొనసాగించడానికి వెళుతున్న ఎంట్రీ! = NULL అయితే.
మరియు గుర్తుంచుకోవాలి ఆ పాయింటర్ నవీకరించడాన్ని తదుపరి మా అనుబంధ జాబితా ఎంట్రీ = ఎంట్రీ>.
మా ప్రస్తుత ఎంట్రీ పాయింట్ ఉంటుంది లింక్ జాబితాలోని తదుపరి అంశాన్ని.
>> కాబట్టి లింక్ జాబితాలో ప్రతి ఎంట్రీ కోసం, మేము strcasecmp ఉపయోగించడానికి వెళుతున్న.
ఇది strcomp కాదు.
మరోసారి, మేము కావలసిన ఎందుకంటే insensitively విషయాలు కేసు చేయండి.
కాబట్టి మేము పోల్చడానికి strcasecmp ఉపయోగించడానికి ఈ గుండా ఆ పదం
పదం వ్యతిరేకంగా ఫంక్షన్ ఈ ఎంట్రీ లో ఉంది.
ఇది సున్నా తిరిగి, ఆ ఉంది అర్థం మేము కోరుకుంటున్న సందర్భంలో ఒక మ్యాచ్,
నిజమైన తిరిగి.
ఉలవపాడు దొరకలేదు మా hashtable లో పదం.
>> ఒక మ్యాచ్ లేదు, అప్పుడు మేము మళ్ళీ లూప్ వెళ్లి చూడండి
తదుపరి ఎంట్రీ.
మరియు మేము అయితే మళ్ళీ వెతికినా చేస్తాము ఈ లింక్ జాబితాలో ప్రవేశాలు.
మేము బ్రేక్ ఏమవుతుంది లూప్ ఈ బయటకు?
మేము ప్రవేశమును కనుగొనలేదు అంటే ఈ సందర్భంలో, ఈ పదం సరిపోలే
మేము సూచించడానికి తప్పుడు తిరిగి మా hashtable ఈ పదం కలిగి లేదు.
మరియు ఒక చెక్ ఉంది.
>> కాబట్టి యొక్క పరిమాణం పరిశీలించి వీలు.
ఇప్పుడు పరిమాణం అందంగా సాధారణ అన్నారు.
నుండి ప్రతి పదం కోసం, లోడ్ గుర్తు మేము ఒక ప్రపంచ పెరుగుదల, దొరకలేదు
వేరియబుల్ hashtable పరిమాణం.
కాబట్టి పరిమాణం ఫంక్షన్ కేవలం అన్నారు ప్రపంచ వేరియబుల్ తిరిగి.
అంతే.
>> ఇప్పుడు చివరకు, మేము దించుతున్న అవసరం నిఘంటువు ప్రతిదీ ఒకసారి.
కాబట్టి మేము ఎలా అలా వెళ్తున్నారు?
ఇక్కడే మేము పైగా మళ్ళీ వెతికినా మా పట్టిక అన్ని బకెట్లు.
కాబట్టి NUM_BUCKETS బకెట్లు ఉన్నాయి.
మరియు ప్రతి లింక్ జాబితా కోసం మా hashtable, మేము లూప్ చూడాలని
అనుబంధ జాబితా యొక్క మొత్తం, ప్రతి మూలకం ఉండండి.
>> ఇప్పుడు మేము జాగ్రత్తగా ఉండాలి.
కాబట్టి ఇక్కడ ఒక తాత్కాలిక వేరియబుల్ ఆ తర్వాత పాయింటర్ నిల్వ
లింక్ జాబితాలో మూలకం.
మరియు తర్వాత మేము ఉచిత చూడాలని ప్రస్తుత మూలకం.
మేము మేము నుండి దీన్ని ఖచ్చితంగా ఉండాలి కేవలం ప్రస్తుత మూలకం ఉచితం కాదు
తరువాత పాయింటర్ యాక్సెస్ ప్రయత్నించండి, ఒకసారి నుండి మేము అది విముక్తి,
మెమరీ చెల్లని అవుతుంది.
>> కాబట్టి మేము ఒక పాయింటర్ చుట్టూ ఉంచడానికి అవసరం తదుపరి మూలకం, అప్పుడు మేము పొందగలరు
ప్రస్తుత మూలకం, మరియు అప్పుడు మేము నవీకరించవచ్చు సూచించడానికి మా ప్రస్తుత మూలకం
తదుపరి మూలకం.
మేము అంశాలను లూప్ ఉన్నాయి ఉన్నప్పుడు ఈ లింక్ జాబితాలో.
మేము అన్ని లింక్ ఆ చేస్తాను hashtable లో జాబితాలు.
మేము పూర్తి మరియు ఒకసారి, మేము చేసిన పూర్తిగా hashtable గుళ్ళను, మరియు
మేము పూర్తి చేసిన.
కనుక ఇది దించుతున్న కోసం అసాధ్యం ఎప్పుడూ తప్పుడు తిరిగి.
మరియు మేము పూర్తి చేసినప్పుడు, మేము కేవలం నిజమైన తిరిగి.
>> యొక్క ఈ పరిష్కారం ఒకసారి ప్రయత్నించండి లెట్.
కాబట్టి యొక్క మా పరిశీలించి వీలు struct నోడ్ కనిపిస్తుంది.
ఇక్కడ మేము ఒక bool చూడాలని చూడండి పదం మరియు struct నోడ్ * పిల్లలు
బ్రాకెట్ ALPHABET.
మీరు కావచ్చు మొదటి విషయం wondering, ఎందుకు ALPHABET ఉంది
ed 27 నిర్వచించారు?
Well, మేము అవసరం చూడాలని గుర్తుంచుకోవాలి అపాస్టిఫియర్ నిర్వహించడానికి చేయడానికి.
కాబట్టి ఆ కొంతవరకు ఒక యొక్క చేస్తాడు ఈ కార్యక్రమం పొడవునా కేసు.
>> ఇప్పుడు గుర్తు ఎలా ఒక trie వాస్తవానికి పనిచేస్తుంది.
యొక్క మేము పదం ఇండెక్సింగ్ చేస్తున్నారు అనుకోండి "పిల్లులు." అప్పుడు trie యొక్క మూల నుండి,
మగపిల్లవాడు చూడండి చూడాలని శ్రేణి మరియు మేము చూడండి చూడాలని
అక్షరం అనుగుణంగా ఆ సూచిక 2 సూచించాలని చేస్తాము C. కాబట్టి.
కాబట్టి ఇచ్చిన, సంకల్ప మాకు ఒక కొత్త నోడ్ ఇవ్వాలని.
మరియు తర్వాత మేము ఆ నోడ్ నుండి పని చేస్తాము.
>> ఆ నోడ్ ఇచ్చిన, మేము మరోసారి ఉన్నారు పిల్లలు శ్రేణి చూడండి వెళుతున్న.
మరియు మేము ఇండెక్స్ సున్నా చూడండి చూడాలని క్యాట్లో అనుగుణంగా.
కాబట్టి అప్పుడు మేము ఆ నోడ్ వెళుతున్నాం, మరియు ఆ నోడ్ ఇచ్చిన మేము చేయబోతున్నామని
ముగింపు చూడండి ఇది ఒక సమంగా ఉంది టి మరియు ఆ నోడ్ వెళ్ళేముందు, కు
చివరకు, మేము పూర్తిగా చూసారు ద్వారా మా పదం "పిల్లి." ఇప్పుడు bool
పదం అని సూచించడానికి కోరుకుంటున్నాము ఈ ఇచ్చిన పదం వాస్తవానికి ఒక పదం ఉంది.
>> ఎందుకు మేము ఆ ప్రత్యేక సందర్భంలో చేయాలి?
Well ఏమి పదం యొక్క "విపత్తు" మా నిఘంటువులో లో ఉంది, కానీ
పదం "పిల్లి" కాదు?
కాబట్టి మరియు చూడండి చూస్తూ ఉంటే పదం "పిల్లి" మా నిఘంటువులో లో, మేము ఉంది
విజయవంతంగా ద్వారా చూడండి అన్నారు ప్రాంతం నోడ్ లో సూచీలు C-A-T.
కానీ ఏకైక ఎందుకంటే విపత్తు మార్గంలో నోడ్స్ సృష్టించడానికి జరిగిన
సి-A-T నుండి, అన్ని మార్గం పదం యొక్క చివరి.
కాబట్టి bool పదం అని సూచించడానికి ఉపయోగిస్తారు ఈ ప్రత్యేక స్థానాన్ని
వాస్తవానికి ఒక పదం సూచిస్తుంది.
>> అన్ని కుడి.
కాబట్టి ఇప్పుడు మేము ఇది trie ఏమి ఆ ఇలా అన్నారు, యొక్క చూద్దాం
ఫంక్షన్ లోడ్.
కాబట్టి లోడ్ ఒక bool తిరిగి అన్నారు అని మేము విజయవంతంగా లేదా కోసం
విఫల నిఘంటువు లోడ్.
మరియు ఈ నిఘంటువు అన్నారు మేము లోడ్ కావలసిన.
>> మేము ఉన్నాము కాబట్టి మొదటి విషయం తెరిచి ఉంది పఠనం కోసం ఆ నిఘంటువు అప్.
మరియు మేము నిర్ధారించడానికి కలిగి మేము విఫలం లేదు.
నిఘంటువు కాదు కాబట్టి ఉంటే విజయవంతంగా ప్రారంభించబడింది, ఇది చూపిస్తుంది
శూన్య కేసులో మేము తప్పుడు తిరిగి వెళుతున్న.
కానీ ఊహిస్తూ అది విజయవంతంగా తెరిచింది, అప్పుడు మేము నిజంగా చదువుకోవచ్చు
నిఘంటువు ద్వారా.
>> మేము చూడాలని కాబట్టి మొదటి విషయం చేయాలనుకుంటున్నారా మేము ఈ కలిగి ఉంది
ప్రపంచ వేరియబుల్ రూట్.
ఇప్పుడు రూట్ * ఒక నోడ్ అవతరిస్తుంది.
ఇది మేము మా trie పైన ఉంది ద్వారా iterating కావడం.
మేము వెళుతున్న తద్వారా మొదటి విషయం చేయాలనుకుంటున్నారా కేటాయించుటకు ఉంది
మా రూట్ కోసం మెమరీ.
మేము calloc ఉపయోగించి గమనించవచ్చు ప్రధానంగా ఉంటుంది కార్యక్రమం,
malloc విధిగా, తప్ప అది ఉంది అని ఏదో తిరిగి హామీ
పూర్తిగా జీరో.
మేము malloc ఉపయోగించే చేస్తే, మేము అవసరం లో గమనికలు అన్ని ద్వారా మా
నోడ్, మరియు నిర్ధారించుకోండి వారు అన్ని శూన్య ఉన్నారు.
కాబట్టి calloc మాకు ఆ చేస్తుంది.
>> ఇప్పుడు కేవలం malloc వంటి, మేము అవసరం కేటాయింపు వాస్తవానికి అని ఖచ్చితంగా
విజయవంతమైన.
ఈ శూన్య తిరిగి, అప్పుడు మేము దగ్గరగా లేదా నిఘంటువు అవసరం
ఫైల్ మరియు తప్పుడు తిరిగి.
కాబట్టి ఆ జి ఊహిస్తూ విజయవంతమైన, మేము ఒక నోడ్ * ఉపయోగించడానికి వెళుతున్న
మా trie ద్వారా iterate కర్సర్.
మా మూలాలు మార్చుకోబోతున్నారు ఎప్పుడూ, కానీ మేము కర్సర్ను ఉపయోగించడానికి వెళుతున్న
నిజానికి నోడ్ నుండి నోడ్ వెళ్ళండి.
>> కాబట్టి ఈ లో లూప్ మేము చదువుతున్నారని నిఘంటువు ఫైలు ద్వారా.
మరియు మేము fgetc ఉపయోగిస్తున్నారు.
Fgetc ఒక పట్టుకోడానికి అన్నారు ఫైలు నుండి పాత్ర.
మేము ఈడ్చడం కొనసాగించడానికి వెళుతున్న అక్షరాలు మేము చేరలేదు అయితే
ఫైలు చివర.
>> మేము నిర్వహించడానికి అవసరం రెండు కేసులు ఉన్నాయి.
మొదటి, ఉంటే పాత్ర ఒక కొత్త లైన్ కాదు.
కాబట్టి మేము అది, ఒక కొత్త లైన్ ఉంటే తెలుసు మేము ఒక కొత్త పదం వెళ్ళటానికి చేయబోతున్నారు.
కానీ, ఇది ఒక కొత్త లైన్ కాదు ఊహిస్తూ ఇక్కడ మేము గుర్తించడానికి కావలసిన
ఇండెక్స్ మేము ఇండెక్స్ చూడాలని పిల్లలు శ్రేణి ఆ
మేము ముందు చూశారు.
>> కాబట్టి, నేను ముందు చెప్పారు వంటి, మేము అవసరం ప్రత్యేక సందర్భంలో అపాస్టిఫియర్.
మేము టెర్నరీ ఉపయోగిస్తున్నట్లయితే గమనించండి ఇక్కడ ఆపరేటర్లు.
కాబట్టి మేము ఉంటే, ఈ చదవండి చూడాలని మేము చదవడానికి పాత్ర ఒక ఉంది
అపాస్టిఫియర్, అప్పుడు మేము సెట్ చూడాలని ఇండెక్స్ = "ALPHABET" -1, ఇది రెడీ
ఇండెక్స్ 26 ఉంటుంది.
>> ఎల్స్, ఇది అపాస్ట్రఫీని కాకుంటే, ఉన్నాయి మేము ఇండెక్స్ సెట్ చూడాలని
సి సమానంగా - ఒక.
కాబట్టి తిరిగి గతంలో p-సెట్స్ నుండి గుర్తు, సి - ఒక మాకు ఇవ్వాలని అన్నారు
C. యొక్క అక్షర స్థానం అయితే సి ఈ రెడీ లేఖ, ఉంది
మాకు ఇండెక్స్ సున్నా ఇస్తాయి.
లేఖ B, అది ఇస్తుంది కాబట్టి మాకు ఇండెక్స్ 1, మరియు.
>> కాబట్టి ఈ మాకు లోకి సూచిక ఇస్తుంది మేము కావలసిన పిల్లలు శ్రేణి.
ఇప్పుడు ఈ ఇండెక్స్ లో ప్రస్తుతం శూన్య ఉంటే పిల్లలు, అని ఒక నోడ్
ప్రస్తుతం ఉనికిలో లేదు ఆ మార్గం నుండి.
కాబట్టి మేము కేటాయించాల్సిన అవసరం ఆ మార్గం కోసం ఒక నోడ్.
ఆ మేము ఇక్కడ ఏమిటి.
>> కనుక మనం మళ్ళీ calloc ఉపయోగించడానికి వెళుతున్న ఫంక్షన్, మేము లేదు కాబట్టి
అన్ని గమనికలు అవుట్ సున్నాకి.
మరియు మేము నిర్ధారించుకోడానికి అవసరం ఆ calloc విఫలం లేదు.
Calloc విఫలం చేయలేదు, అప్పుడు మేము అవసరం ప్రతిదీ దించుతున్న, దగ్గరగా మా
నిఘంటువు, మరియు తప్పుడు తిరిగి.
కాబట్టి అది, విఫలం లేదని ఊహిస్తూ ఈ మాకు ఒక కొత్త పిల్లల సృష్టిస్తుంది.
మరియు తర్వాత ఆ పిల్లల వెళతారు.
మా కర్సర్ iterate ఉంటుంది బిడ్డకు డౌన్.
>> ఇప్పుడు ఈ తో ప్రారంభించడానికి శూన్య కాకుంటే, అప్పుడు కర్సర్ iterate చేయవచ్చు
నిజానికి లేకుండా బిడ్డకు డౌన్ ఏదైనా కేటాయించే కలిగి.
ఈ మేము మొదటి జరిగిన సందర్భంలో ఉంటుంది పదం కేటాయించాలని "పిల్లి." మరియు
మేము కేటాయించే వెళ్ళేటప్పుడు అర్థం "విపత్తు" మేము సృష్టించాలి లేదు
మళ్ళీ సి-A-T కోసం నోడ్స్.
అవి ఇప్పటికే ఉన్నాయి.
>> ఇంకా ఈ ఏమిటి?
ఈ సి అక్కడ పరిస్థితి సి కొత్త లైన్ అక్కడ బాక్ స్లాష్ n,.
ఈ మేము విజయవంతంగా అర్థం ఒక పదం పూర్తి.
ఇప్పుడు మేము ఏమి అనుకుంటున్నారు మేము విజయవంతంగా ఒక పదం పూర్తి?
మేము ఈ పదం రంగంలో ఉపయోగించడానికి వెళుతున్న మా struct నోడ్ లోపలి.
మేము నిజమైన కు సెట్ కావలసిన.
కాబట్టి సూచిస్తుంది అని ఈ నోడ్ ఒక విజయవంతమైన సూచిస్తుంది
పదం, ఒక వాస్తవ పదం.
>> ఇప్పుడు నిజమైన కు సెట్.
మేము పాయింట్ మా కర్సర్ రీసెట్ చేయాలనుకుంటున్నారా మళ్ళీ trie ప్రారంభానికి.
చివరకు మా నిఘంటువులో పెంచడం పరిమాణం, మేము మరొక పని దొరకలేదు.
కాబట్టి మేము ఆ పనిని చూడాలని, , పాత్ర పాత్ర లో చదవడం
మా trie కొత్త నోడ్స్ నిర్మించడం మరియు నిఘంటువు లో, వరకు ప్రతి పదం కోసం
మేము చివరకు సి చేరుకోవడానికి! = EOF, దీనిలో సందర్భంలో మేము ఫైలు బయటకు.
>> ఇప్పుడు రెండు కేసులు కింద ఉన్నాయి మేము EOF హిట్ ఉండవచ్చు ఇది.
లోపం ఉంది ఉంటే మొదటి ఫైలు చదవడం.
లోపం ఉంది ఉంటే, మేము సాధారణ చెయ్యాల్సిన.
దగ్గరగా, ప్రతిదీ దించుతున్న ఫైలు, తప్పుడు తిరిగి.
, లోపం లేదు ఊహిస్తూ ఆ కేవలం మేము నిజంగా ముగింపు హిట్ అర్థం
ఫైలు, ఈ సందర్భంలో, మేము దగ్గరగా ఫైల్ మరియు నిజమైన తిరిగి నుండి మేము
విజయవంతంగా లోడ్ నిఘంటువు మా trie లోకి.
>> కాబట్టి ఇప్పుడు యొక్క చెక్ తనిఖీ వీలు.
చెక్ ఫంక్షన్ వద్ద గురించి, మేము చూడండి ఆ చెక్ ఒక bool తిరిగి అన్నారు.
ఈ పదం అని ఉంటే అది నిజమైన తిరిగి తరాలకు మా trie ఉంది.
లేకపోతే తప్పుడు తిరిగి.
కాబట్టి మీరు నిర్ధారించడానికి ఉంటాయి ఈ పదం మా trie ఉంది?
>> మేము ఇక్కడ చూసే ముందు వలె, మేము iterate కర్సర్ ఉపయోగించడానికి వెళుతున్న
మా trie ద్వారా.
ఇప్పుడు ఇక్కడ మేము iterate చూడాలని మా మొత్తం పదంపైన.
కాబట్టి, మేము గతంలో ఉన్నాయి పదం మీద iterating మేము నిర్ణయించే చూడాలని
ఇండెక్స్ పిల్లలు శ్రేణి ఆ పదం బ్రాకెట్ I. అనుగుణంగా ఈ
ఖచ్చితంగా ఇలా అన్నారు లోడ్, పేరు పదం [i]
అపాస్ట్రఫీని, అప్పుడు మేము కావలసిన ఉంది ఇండెక్స్ "ALPHABET" ఉపయోగించడానికి - 1.
మేము గుర్తిస్తారు ఎందుకంటే ఆ మేము నిల్వ వెళుతున్న ఉంది
సంగ్రహంగా రాయడానికి.
>> మిగతా మేము దిగువ రెండు పదం ఉపయోగించడానికి వెళుతున్న బ్రాకెట్ I. కాబట్టి ఆ పదం గుర్తుంచుకోగలరు
అనియత మూలధనీకరణ.
కాబట్టి మేము అని నిర్ధారించుకోవాలి విషయాలు చిన్న వెర్షన్ ఉపయోగించి.
మరియు ఆ 'ఒక' ఒకసారి నుండి వ్యవకలనం మళ్ళీ మాకు అక్షర ఇవ్వాలని
ఆ పాత్ర యొక్క స్థానం.
కాబట్టి మా ఇండెక్స్ చేస్తాడు పిల్లలు శ్రేణి లోకి.
>> ఇప్పుడు ఉంటే పిల్లలు ఆ ఇండెక్స్ శ్రేణి శూన్య, మేము అర్థం
ఇకపై iterating కొనసాగించవచ్చు మా trie డౌన్.
ఒకవేళ, ఈ పదం కాదు బహుశా మా trie ఉంటుంది.
ఇది అయితే, కోరిరి నుండి ఒక మార్గం ఉంటుంది అర్థం
ఆ పదం డౌన్.
మరియు మీరు శూన్య ఎదుర్కునే ఎప్పటికీ.
కాబట్టి శూన్య ఎదుర్కొనడానికి, మేము తప్పుడు తిరిగి.
నిఘంటువులో పదం కాదు.
అది శూన్య కాదు, అప్పుడు మేము iterating కొనసాగుతుంది అన్నారు.
>> కాబట్టి మేము అక్కడ కర్సర్ బయటకు చూడాలని నిర్దిష్ట సూచించడానికి
ఆ సూచిక వద్ద నోడ్.
మేము అంతటా ఆ పనిని కలిగేది, ఊహిస్తూ
మేము శూన్య హిట్ ఎప్పుడూ.
దీంతో ను సాధించారు అర్థం కలిగేది మరియు కనుగొనేందుకు
మా ప్రయత్నించండి ఒక నోడ్.
కానీ మేము చాలా ఇంకా పూర్తి లేదు.
>> మేము నిజమైన తిరిగి వద్దు.
మేము కర్సర్> పదం తిరిగి.
మళ్ళీ గుర్తు నుండి, "పిల్లి" చేయలేదా మా నిఘంటువులో లో, మరియు "విపత్తు"
, అప్పుడు మేము విజయవంతంగా మేము పొందుతారు ఉంది ద్వారా పదం "పిల్లి." కానీ కర్సర్
పదం తప్పుడు మరియు నిజమైన కాదు ఉంటుంది.
కాబట్టి మేము సూచించడానికి కర్సర్ పదం తిరిగి అని ఈ నోడ్ వాస్తవానికి ఒక పదం ఉంది.
మరియు ఆ చెక్ కోసం ఇది.
>> కాబట్టి యొక్క పరిమాణం తనిఖీ వీలు.
కాబట్టి పరిమాణం చాలా సులభం అన్నారు నుండి, లోడ్ లో గుర్తు, మేము ఉన్నాము
కోసం నిఘంటువులో పెంచడం పరిమాణం మేము ఎదుర్కొనే ప్రతి పదం.
కాబట్టి పరిమాణం కేవలం అన్నారు నిఘంటువు పరిమాణం తిరిగి.
అంతే.
>> కాబట్టి చివరగా మేము దించుతున్న చేశారు.
కాబట్టి దించుతున్న, మేము ఉపయోగించే చూడాలని ఒక నిజానికి అన్ని చేయడానికి పునరావృత ఫంక్షన్
మాకు పని.
మా ఫంక్షన్ అన్నారు unloader అని అంటాము.
ఏ unloader చేయబోవడం?
మేము ఆ unloader అన్నారు ఇక్కడ చూడండి పిల్లల అన్ని వద్ద మీద iterate
ఈ ప్రత్యేక నోడ్.
మరియు పిల్లల నోడ్ లేకపోతే శూన్య, అప్పుడు మేము చూడాలని
పిల్లల నోడ్ దించుతున్న.
>> కాబట్టి ఈ మీరు పునరావృతంగా దించుతున్న ఉంది మా పిల్లల అన్ని.
మేము ఖచ్చితంగా ఆ అయ్యాక మా పిల్లలు అన్ని గుళ్ళను చేశారు అప్పుడు మేము
కదలడం, కాబట్టి చేయవచ్చు మేమే దించుతున్న.
ఈ పునరావృతంగా పని చేస్తుంది మొత్తం trie దించుతున్న.
మరియు ఆ ఒకసారి, మేము నిజమైన తిరిగి.
దించుతున్న విఫలం కాదు.
మేము కేవలం విషయాలు ఉండండి లేదు.
కాబట్టి ఒకసారి మేము ఉండండి పూర్తి చేసిన ప్రతిదీ, నిజమైన తిరిగి.
అంతే.
నా పేరు రాబ్ ఉంది.
మరియు ఈ స్పెల్లర్ ఉంది.
>> [MUSIC ప్లే]