>> SPEAKER 1: యొక్క అనుమతిచ్చే ఈ పరిష్కారం ప్రయత్నించండి.
కాబట్టి యొక్క మా పరిశీలించి వీలు Struct నోడ్ కనిపిస్తుంది.
ఇక్కడ, మేము చూడాలని చూడండి ఒక Bool వర్డ్ మరియు ఒక struct నోడ్ స్టార్
పిల్లలు వర్ణమాల బ్రాకెట్.
కాబట్టి మొదటి విషయం మీరు వొండరింగ్ ఉండవచ్చు, ఎందుకు వర్ణమాల హాష్ 27 నిర్వచిస్తారు?
Well, మేము అవసరం చూడాలని గుర్తుంచుకోవాలి అపాస్టిఫియర్ పట్టుకోవడం తీసుకెళ్ళేవారు
ఒక ప్రత్యేక కొంతవరకు చేస్తాడు ఈ కార్యక్రమం అంతా కేసు.
>> OK, ఇప్పుడు, గుర్తు ఒక Trie వాస్తవానికి పనిచేస్తుంది.
యొక్క మేము పదం పిల్లులు ఇండెక్సింగ్ చేస్తున్నారు అనుకోండి, అప్పుడు మా Tri-ఇ యొక్క మూల నుండి,
మేము పిల్లలు చూడండి చూడాలని శ్రేణి మరియు మేము చూడండి చూడాలని
అక్షరం అనుగుణంగా ఆ సూచిక C. కాబట్టి ఆ సూచిక రెండు ఉంటుంది.
కాబట్టి ఆ, మాకు ఆ ఇస్తుంది ఇచ్చిన ఒక కొత్త నోడ్, మరియు అప్పుడు మేము చేస్తాము
ఆ నోడ్ నుండి పని.
>> ఆ నోడ్ ఇచ్చిన, మేము మరోసారి ఉన్నారు పిల్లలు శ్రేణి చూడండి వెళుతున్న,
మరియు మేము ఇండెక్స్ సున్నా చూడండి చూడాలని క్యాట్లో అనుగుణంగా.
కాబట్టి అప్పుడు మేము ఆ నోడ్ వెళుతున్నాం, మరియు ఆ నోడ్ ఇచ్చిన, మేము వెళుతున్న
చెందు ఇండెక్స్ చూడండి టి మరియు ఆ నోడ్ వెళ్ళేముందు, కు
చివరకు, మేము పూర్తిగా చూసారు మా పదం పిల్లి ద్వారా, మరియు ఇప్పుడు bool
పదం అని సూచించడానికి కోరుకుంటున్నాము ఈ ఇచ్చిన పదం వాస్తవానికి ఒక పదం ఉంది.
>> ఎందుకు మేము ఆ ప్రత్యేక సందర్భంలో చేయాలి?
Well, పదం విపత్తు మా నిఘంటువులో లో ఉంది, కానీ
పదం పిల్లి కాదు?
కాబట్టి పదం పిల్లి ఉంటే చూడటానికి చూస్తున్న లో మా నిఘంటువులో లో, మేము చూడాలని
విజయవంతంగా సూచికలు ద్వారా చూడండి సి-A-T మరియు నోడ్ చేరుకోవడానికి, కానీ ఆ
విపత్తు సంభవించింది ఎందుకంటే సి-A-T దారిలో నోడ్స్ సృష్టించడానికి అన్ని
పదం చివర మార్గం.
కాబట్టి bool పదాలు తెలుస్తుంది ఉపయోగిస్తారు ఈ ప్రత్యేక స్థానాన్ని నిజానికి
ఒక పదం సూచిస్తుంది.
>> అన్ని కుడి కాబట్టి ఇప్పుడు మేము తెలిసిన ఏమి ఒక Trie యొక్క చూద్దాం, లాగా అన్నారు
లోడ్ ఫంక్షన్ వద్ద.
కాబట్టి లోడ్ ఒక bool తిరిగి అన్నారు అని మేము విజయవంతంగా లేదా కోసం
విఫల లోడ్ నిఘంటువు మరియు ఈ నిఘంటువు అన్నారు
మేము లోడ్ కావలసిన.
మేము చేయబోతున్నామని కాబట్టి మొదటి విషయం తెరిచి ఉంది పఠనం కోసం ఆ నిఘంటువు అప్.
మేము విఫలం లేదు నిర్ధారించడానికి కలిగి, కాబట్టి నిఘంటువు కాకుంటే
విజయవంతంగా ప్రారంభించబడింది, ఇది చూపిస్తుంది ఏ, కేసు దీనిలో మేము చూడాలని
ఫాల్స్ తిరిగి.
కానీ ఊహిస్తూ అది విజయవంతంగా తెరిచింది, అప్పుడు మేము నిజంగా చదువుకోవచ్చు
నిఘంటువు ద్వారా.
>> మేము చూడాలని కాబట్టి మొదటి విషయం చేయాలనుకుంటున్నారా మేము ఈ కలిగి ఉంది
ప్రపంచ వేరియబుల్ రూట్.
ఇప్పుడు, రూట్ నోడ్ స్టార్ అన్నారు.
ఇది మేము మా Tri-ఇ పైన ఉంది ద్వారా iterating కావడం.
మేము మీరు చూడాలని కాబట్టి మొదటి విషయం అలా మా రూట్ కోసం మెమరీని కేటాయించాల్సిన ఉంది.
>> మేము calloc ఉపయోగించి గమనించవచ్చు ప్రధానంగా ఉంటుంది కార్యక్రమం,
Malloc విధిగా, తప్ప అది ఉంది అని ఏదో తిరిగి హామీ
పూర్తిగా జీరో.
మేము Malloc ఉపయోగిస్తారు, మేము అవసరం లో గమనికలు అన్ని ద్వారా మా
నోడ్ మరియు నిర్ధారించుకోండి వారు అన్ని శూన్య ఉన్నారు.
కాబట్టి calloc మాకు ఆ చేస్తుంది.
>> ఇప్పుడు, కేవలం Malloc వంటి, మేము అవసరం కేటాయింపు నిజానికి ఆ ఖచ్చితంగా
విజయవంతమైన.
ఈ శూన్య తిరిగి, అప్పుడు మేము మా నిఘంటువులో దగ్గరగా అవసరం
ఫైల్ మరియు ఫాల్స్ తిరిగి.
కాబట్టి జి ఊహిస్తూ విజయవంతమైన, మేము ఒక నోడ్ ఉపయోగించడానికి వెళుతున్న
iterate కర్సర్ను స్టార్ మా Tri-ఇ ద్వారా.
మా రూట్ మార్చుకోబోతున్నారు ఎప్పటికీ, కానీ మేము కర్సర్ ఉపయోగించడానికి వెళుతున్న
నిజానికి నోడ్ నుండి నోడ్ వెళ్ళండి.
>> అన్ని కుడి, ఈ లో లూప్, మేము ఉంటాయి , నిఘంటువు ఫైలు ద్వారా చదవడం
మరియు మేము fgetc వద్ద ఉపయోగిస్తున్నారు.
కాబట్టి fgetc ఒక పట్టుకోడానికి అన్నారు ఫైలు నుండి పాత్ర.
మేము ఈడ్చడం కొనసాగించడానికి వెళుతున్న అక్షరాలు మేము చేరలేదు అయితే
ఫైలు యొక్క ముగింపు, కాబట్టి ఉన్నాయి మేము నిర్వహించడానికి అవసరం రెండు కేసులు.
మొదటి, పాత్ర కాకుంటే ఒక అది ఒక న్యూ ఉంటే కొత్త లైన్, కాబట్టి మేము తెలుసు
లైన్, అప్పుడు మేము చేయబోతున్నారు ఒక కొత్త పదం కొనసాగండి.
కానీ, ఇది ఒక కొత్త లైన్ కాదు ఊహిస్తూ ఇక్కడ, మేము గుర్తించడానికి కావలసిన
ఇండెక్స్ మేము ఇండెక్స్ చూడాలని పిల్లలు శ్రేణి ఆ
మేము ముందు చూశారు.
>> నేను ముందు చెప్పారు కాబట్టి, మేము అవసరం ప్రత్యేక సందర్భంలో అపాస్టిఫియర్.
మేము టెర్నరీ ఆపరేటర్లు ఉపయోగిస్తున్నట్లయితే గమనించండి ఇక్కడ, కాబట్టి మేము చదవండి చూడాలని
ఈ మేము చదవడానికి పాత్ర గా ఉంటే అపాస్ట్రఫీని, అప్పుడు మేము చూడాలని
వర్ణమాల మైనస్ సమానంగా ఇండెక్స్ సెట్ 1, ఇది ఇండెక్స్ 26 ఉంటుంది.
ఎల్స్, ఇది అపాస్ట్రఫీని కాకుంటే, మేము సూచిక సెట్ చూడాలని
సి మైనస్ ఒక సమానంగా.
కాబట్టి తిరిగి మునుపటి p సెట్లు గుర్తు, సి మైనస్ ఒక మాకు ఇవ్వాలని అన్నారు
అక్షర సి యొక్క స్థానాన్ని ఉంటే సి లేఖ A ఈ అభీష్టం
మాకు ఇండెక్స్ సున్నా ఇస్తాయి.
లేఖ B కోసం, ఇచ్చి కాబట్టి మాకు ఇండెక్స్ 1, మరియు.
>> కాబట్టి ఈ మాకు లోకి సూచిక ఇస్తుంది మేము కావలసిన పిల్లలు శ్రేణి.
ఇప్పుడు, ఈ ఇండెక్స్ లో ప్రస్తుతం శూన్య ఉంటే పిల్లలు శ్రేణి, అని
ఒక నోడ్ ప్రస్తుతం నుండి లేదు ఆ మార్గం, కాబట్టి మేము కేటాయించాల్సిన అవసరం ఒక
ఆ మార్గం కోసం నోడ్.
మేము ఇక్కడ ఏమి ఉంది.
కాబట్టి మేము, మళ్ళీ, calloc ఉపయోగించడానికి వెళుతున్న ఫంక్షన్ మేము లేదు కాబట్టి
గమనికలు అన్ని బయటకు సున్నాకి, మరియు మేము, మళ్ళీ, ఆ calloc తనిఖీ చెయ్యాలి
విఫలం లేదు.
Calloc విఫలం చేయలేదు, అప్పుడు మేము అవసరం ప్రతిదీ దించుతున్న, దగ్గరగా మా
నిఘంటువు, మరియు ఫాల్స్ తిరిగి.
>> కాబట్టి అది, విఫలం లేదని ఊహిస్తూ ఈ, మాకు కొత్త పిల్లల సృష్టిస్తుంది
మరియు తర్వాత ఆ పిల్లల వెళతారు.
మా కర్సర్ iterate ఉంటుంది బిడ్డకు డౌన్.
ఇప్పుడు, ఈ తో ప్రారంభించడానికి శూన్య కాకుంటే, అప్పుడు కర్సర్ iterate చేయవచ్చు
నిజానికి లేకుండా బిడ్డకు డౌన్ ఏదైనా కేటాయించే కలిగి.
ఈ మేము మొదటి జరిగిన సందర్భంలో ఉంటుంది పదం పిల్లి కేటాయించాలని, మరియు
మేము కేటాయించే వెళ్ళేటప్పుడు అర్థం విపత్తు, మేము సృష్టించాలి లేదు
మళ్ళీ సి-A-T కోసం నోడ్స్.
అవి ఇప్పటికే ఉన్నాయి.
>> సరే, ఈ ఏమి ఉంది?
ఈ సి అక్కడ పరిస్థితి సి కొత్త లైన్ అక్కడ బాక్ స్లాష్ n,.
ఈ మేము విజయవంతంగా అర్థం ఒక పదం పూర్తి.
ఇప్పుడు మనం ఏమి అనుకుంటున్నారు మేము విజయవంతంగా ఒక పదం పూర్తి?
మేము ఈ పదం రంగంలో ఉపయోగించడానికి వెళుతున్న మా struct నోడ్ లోపలి.
>> మేము ట్రూ ఆ సెట్ చేయాలనుకుంటున్నారా కాబట్టి ఈ నోడ్ సూచిస్తుంది సూచిస్తుంది ఒక
విజయవంతమైన పదం అసలు పదం.
ఇప్పుడు, ట్రూ కు సెట్.
మేము పాయింట్ మా కర్సర్ రీసెట్ చేయాలనుకుంటున్నారా మళ్ళీ Tri-ఇ ప్రారంభానికి.
చివరకు మా నిఘంటువులో పెంచడం మేము మరొక పదం దొరకలేదు పరిమాణం నుండి.
>> అన్ని కుడి, మేము పనిని చూడాలని ఆ, పాత్రధారిగా చదవడం
పాత్ర, కొత్త నోడ్స్ నిర్మించడానికి మా Tri-ఇ మరియు ప్రతి పదం కోసం
నిఘంటువు, మేము చివరకు సి చేరుకోవడానికి వరకు , మేము విచ్ఛిన్నం సందర్భంలో EOF, సమానం
ఫైల్.
ఇప్పుడు, రెండు కేసులు కింద ఉన్నాయి మేము EOF హిట్ ఉండవచ్చు ఇది.
లోపం ఉంది ఉంటే మొదటి ఉంది ఉంటే ఫైలు చదవడం, కాబట్టి
లోపం, మేము సాధారణ చెయ్యాల్సిన , ప్రతిదీ దించుతున్న ఫైలు దగ్గరగా,
ఫాల్స్ తిరిగి.
, లోపం లేదు ఊహిస్తూ ఆ కేవలం మేము నిజంగా ముగింపు హిట్ అర్థం
ఫైలు, ఈ సందర్భంలో, మేము దగ్గరగా ఫైల్ మరియు ట్రూ తిరిగి నుండి మేము
విజయవంతంగా నిఘంటువు లోడ్ మా Tri-ఇ లోకి.
>> అన్ని కుడి కాబట్టి ఇప్పుడు వీలు యొక్క చెక్ తనిఖీ.
చెక్ ఫంక్షన్ వద్ద గురించి, మేము చూడండి ఆ చెక్ ఒక bool తిరిగి అన్నారు.
ఈ పదం అని ఉంటే ఇది ట్రూ రిటర్న్ తరాలకు మా trie ఉంది.
ఇది లేకపోతే అది ఫాల్స్.
>> కాబట్టి మేము ఎలా నిర్ధారించడానికి వెళ్తున్నారు ఈ పదం మా trie ఉంది?
మేము ఇక్కడ చూసే ముందు వలె, మేము iterate కర్సర్ ఉపయోగించడానికి వెళుతున్న
మా Tri-ఇ ద్వారా.
ఇప్పుడు, ఇక్కడ, మేము iterate చూడాలని మా మొత్తం పదంపైన.
మేము ఉన్నాయి పదం మీద iterating ఆమోదించింది, మేము గుర్తించడానికి చూడాలని
ఇండెక్స్ పిల్లలు శ్రేణి ఆ పదం బ్రాకెట్ నేను సూచించదు.
కాబట్టి ఈ ఖచ్చితంగా లాగా అన్నారు లోడ్, పేరు పదం బ్రాకెట్ నేను ఒక ఉంటే
అపాస్టిఫియర్, మేము సూచిక ఉపయోగించడానికి 1 మైనస్ వర్ణమాల మేము గుర్తిస్తారు ఎందుకంటే
మేము వెళుతున్న అని సంగ్రహంగా రాయడానికి నిల్వ.
>> మిగతా మేము tolower ఉపయోగించడానికి వెళుతున్న పదం బ్రాకెట్ నేను.
కాబట్టి కలిగి పదం గుర్తు అనియత క్యాపిటలైజేషన్, అందువలన మేము
మేము ఆ ఉపయోగిస్తున్నారు నిర్ధారించుకోవాలి విషయాలు చిన్న వెర్షన్.
మరియు ఆ చిన్న నుండి వ్యవకలనం ఒక మరోసారి మాకు ఇవ్వాలని
అక్షర స్థానం ఆ పాత్ర యొక్క.
కాబట్టి మా ఇండెక్స్ చేస్తాడు పిల్లలు శ్రేణి లోకి.
>> ఇప్పుడు, ఉంటే పిల్లలు ఆ ఇండెక్స్ శ్రేణి శూన్య, మేము అర్థం
ఇకపై iterating కొనసాగించవచ్చు మా Tri-ఇ డౌన్.
ఒకవేళ, ఈ పదం కాదు బహుశా మా Tri-ఇ లో నుండి ఉంటే అది
, ఒక ఉండొచ్చు అర్థం చేశారు మార్గం డౌన్ మాట, మరియు మీరు
శూన్య రాదు.
కాబట్టి శూన్య ఎదుర్కొనడానికి, మేము ఫాల్స్ తిరిగి.
నిఘంటువులో పదం కాదు.
అది శూన్య కాదు, అప్పుడు మేము చూడాలని iterating కొనసాగుతుంది, కాబట్టి మేము చూడాలని
ఆ సూచించండి మా కర్సర్ అప్డేట్ ఆ సూచిక వద్ద ప్రత్యేక నోడ్.
>> కాబట్టి మేము అంతటా ఆ పనిని కలిగేది.
, మేము శూన్య హిట్ ఎప్పుడూ ఊహిస్తూ సాధనాలు మేము మొత్తం ద్వారా ను సాధించారు
ప్రపంచ మరియు మా trie ఒక నోడ్ కనుగొనేందుకు, కానీ మేము చాలా ఇంకా పూర్తి లేదు.
మేము కేవలం ట్రూ తిరిగి వద్దు.
మేము కర్సర్ లోపం పదం తిరిగి పిల్లి కాదు ఉంటే నుండి,, మళ్ళీ గుర్తు
మా నిఘంటువులో మరియు విపత్తు ఉంది లో అప్పుడు మేము విజయవంతంగా ద్వారా పొందుతారు
పదం పిల్లి, కానీ కర్సర్ పదం ఫాల్స్ మరియు ట్రూ కాదు ఉంటుంది.
కాబట్టి మేము సూచించడానికి కర్సర్ పదం తిరిగి అని ఈ నోడ్ వాస్తవానికి ఒక పదం ఉంది,
మరియు ఆ చెక్ కోసం ఇది.
>> కాబట్టి యొక్క పరిమాణం తనిఖీ వీలు.
కాబట్టి పరిమాణం చాలా సులభం అన్నారు నుండి, లోడ్ లో గుర్తు, మేము ఉన్నాము
కోసం నిఘంటువులో పెంచడం పరిమాణం మేము ఎదుర్కొనే ప్రతి పదం.
కాబట్టి పరిమాణం కేవలం తిరిగి అన్నారు నిఘంటువు పరిమాణం, అంతే.
>> అన్ని కుడి, చివరికి, మేము దించుతున్న చేశారు.
కాబట్టి దించుతున్న, మేము ఉపయోగించే చూడాలని ఒక నిజానికి అన్ని చేయడానికి పునరావృత ఫంక్షన్
మాకు, మా ఫంక్షన్ కోసం పని Unloader అని అన్నారు.
ఏ Unloader చేయబోవడం?
మేము ఆ Unloader అన్నారు ఇక్కడ చూడండి పిల్లల అన్ని వద్ద మీద iterate
ఈ ప్రత్యేక నోడ్, మరియు ఉంటే పిల్లల నోడ్ శూన్య కాదు, అప్పుడు మేము చూడాలని
పిల్లల నోడ్ దించుతున్న.
>> కాబట్టి ఈ పునరావృతంగా అన్నారు మా పిల్లల అన్ని దించుతున్న.
మేము ఖచ్చితంగా ఆ అయ్యాక మా పిల్లలు అన్ని గుళ్ళను చేశారు అప్పుడు మేము
కదలడం, కాబట్టి స్వయంగా దించుతున్న చేయవచ్చు.
కాబట్టి ఈ పునరావృతంగా దించుతున్న ఉంటుంది మొత్తం Tri-ఇ, మరియు ఆ ఒకసారి
పూర్తి, మేము నిజమైన తిరిగి.
దించుతున్న మేము, విఫలం కాదు కేవలం విషయాలు ఉండండి.
కాబట్టి ఒకసారి మేము ఉండండి పూర్తి చేసిన ప్రతిదీ, ట్రూ తిరిగి.
అంతే.
నా పేరు రాబ్ ఉంది, మరియు ఈ [వినబడని] ఉంది.